database.cpp.svn-base

股票软件源码

/*
	Cross Platform Core Code.

	Copyright(R) 2001-2002 Balang Software.
	All rights reserved.

	Using:
		DllMain( HANDLE, DWORD, LPVOID );
		class	CStDatabase;
*/

#include	"StdAfx.h"
#include	"../Include/Database.h"
#include	"../Include/SpString.h"
#include	<direct.h>
#include	"SelfDB.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

////////////////////////////////////////////////////////////////////////////////////////////
//	convertor

BOOL convert_TYDAY_RECORD_to_KDATA( TYDAY_RECORD * precord, KDATA * pkd )
{
	SP_ASSERT( precord && pkd );
	if( NULL == precord || NULL == pkd )
		return FALSE;
	memset( pkd, 0, sizeof(KDATA) );

	pkd->m_dwMarket	=	CStock::marketUnknown;
	strncpy( pkd->m_szCode, precord->code, min(sizeof(pkd->m_szCode)-1,sizeof(precord->code)) );

	pkd->m_date		=	precord->date;
	CSPTime	sptime;
	if( sptime.FromStockTimeDay(pkd->m_date) )
		pkd->m_time	=	sptime.GetTime();

	pkd->m_fOpen	=	(float)( precord->open * 0.001 );
	pkd->m_fHigh	=	(float)( precord->high * 0.001 );
	pkd->m_fLow		=	(float)( precord->low * 0.001 );
	pkd->m_fClose	=	(float)( precord->close * 0.001 );
	pkd->m_fAmount	=	(float)( precord->amount * 1000. );
	pkd->m_fVolume	=	(float)( precord->volume * 100. );
	return TRUE;
}

BOOL convert_TYDAY_RECORD_MIN_to_KDATA( TYDAY_RECORD * precord, KDATA * pkd )
{
	SP_ASSERT( precord && pkd );
	if( NULL == precord || NULL == pkd )
		return FALSE;
	memset( pkd, 0, sizeof(KDATA) );

	pkd->m_dwMarket	=	CStock::marketUnknown;
	strncpy( pkd->m_szCode, precord->code, min(sizeof(pkd->m_szCode)-1,sizeof(precord->code)) );

	pkd->m_date		=	precord->date;
	CSPTime	sptime;
	if( sptime.FromStockTimeDay(pkd->m_date) )
		pkd->m_time	=	sptime.GetTime();

	pkd->m_fOpen	=	(float)( precord->open * 0.001 );
	pkd->m_fHigh	=	(float)( precord->high * 0.001 );
	pkd->m_fLow		=	(float)( precord->low * 0.001 );
	pkd->m_fClose	=	(float)( precord->close * 0.001 );
	pkd->m_fAmount	=	(float)( precord->amount * 100. );
	pkd->m_fVolume	=	(float)( precord->volume * 100. );
	return TRUE;
}

BOOL convert_KDATA_to_TYDAY_RECORD( DWORD dwSerial, const char * name, KDATA * pkd, TYDAY_RECORD * precord )
{
	SP_ASSERT( precord && pkd );
	if( NULL == precord || NULL == pkd )
		return FALSE;
	memset( precord, 0, sizeof(TYDAY_RECORD) );

	precord->magic	=	0x06;
	precord->magic2	=	0x08;
	
	strncpy( precord->code, pkd->m_szCode, min(sizeof(precord->code),sizeof(pkd->m_szCode)) );
	if( name )
		strncpy( precord->name, name, min(sizeof(precord->name),strlen(name)) );

	precord->date		=	pkd->m_date;
	
	precord->open	=	(DWORD)( pkd->m_fOpen * 1000 );
	precord->high	=	(DWORD)( pkd->m_fHigh * 1000 );
	precord->low	=	(DWORD)( pkd->m_fLow * 1000 );
	precord->close	=	(DWORD)( pkd->m_fClose * 1000 );
	precord->amount	=	(DWORD)( pkd->m_fAmount * 0.001 );
	precord->volume	=	(DWORD)( pkd->m_fVolume * 0.01 );
	precord->serial	=	dwSerial;
	return TRUE;
}

BOOL convert_KDATA_to_TYDAY_RECORD_MIN( DWORD dwSerial, const char * name, KDATA * pkd, TYDAY_RECORD * precord )
{
	SP_ASSERT( precord && pkd );
	if( NULL == precord || NULL == pkd )
		return FALSE;
	memset( precord, 0, sizeof(TYDAY_RECORD) );

	precord->magic	=	0x06;
	precord->magic2	=	0x08;
	
	strncpy( precord->code, pkd->m_szCode, min(sizeof(precord->code),sizeof(pkd->m_szCode)) );
	if( name )
		strncpy( precord->name, name, min(sizeof(precord->name),strlen(name)) );

	precord->date		=	pkd->m_date;
	
	precord->open	=	(DWORD)( pkd->m_fOpen * 1000 );
	precord->high	=	(DWORD)( pkd->m_fHigh * 1000 );
	precord->low	=	(DWORD)( pkd->m_fLow * 1000 );
	precord->close	=	(DWORD)( pkd->m_fClose * 1000 );
	precord->amount	=	(DWORD)( pkd->m_fAmount * 0.01 );
	precord->volume	=	(DWORD)( pkd->m_fVolume * 0.01 );
	precord->serial	=	dwSerial;
	return TRUE;
}

BOOL convert_FXJDAY_RECORD_to_KDATA( DWORD dwMarket, LPCTSTR lpszCode, int nKType, FXJDAY_RECORD *precord, KDATA *pkd )
{
	SP_ASSERT( precord && pkd && lpszCode );
	if( NULL == precord || NULL == pkd )
		return FALSE;
	memset( pkd, 0, sizeof(KDATA) );

	pkd->m_dwMarket	=	dwMarket;
	strncpy( pkd->m_szCode, lpszCode, min(sizeof(pkd->m_szCode)-1,strlen(lpszCode)) );

	pkd->m_time		=	precord->m_time;
	CSPTime	sptime(pkd->m_time);
	pkd->m_date		=	sptime.ToStockTime( CKData::IsDayOrMin(nKType) );

	pkd->m_fOpen	=	precord->open;
	pkd->m_fHigh	=	precord->high;
	pkd->m_fLow		=	precord->low;
	pkd->m_fClose	=	precord->close;
	pkd->m_fAmount	=	precord->amount;
	pkd->m_fVolume	=	(float)( precord->volume * 100. );
	return TRUE;
}

////////////////////////////////////////////////////////////////////////////////////////////
//	class	CStDatabase

CStDatabase::CStDatabase()
{
	m_pStore	=	NULL;
}

CStDatabase::~CStDatabase()
{
	if( m_pStore )
	{
		delete m_pStore;
		m_pStore	=	NULL;
	}

	for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
	{
		IStStore	* pStore	=	(IStStore *)m_aptrAssistant.ElementAt(i);
		if( pStore )
			delete	pStore;
	}
	m_aptrAssistant.RemoveAll();
}

BOOL CStDatabase::CreateSelfDB( const char * rootpath )
{
	return CSelfDB::CreateSelfDB( rootpath );
}

int	CStDatabase::IsValidDataType ( int nType )
{
	return IStStore::IsValidDataType( nType );
}

int	CStDatabase::GetSupportedDataType ( CDBType * pdbtype, int maxsize )
{
	return IStStore::GetSupportedDataType( pdbtype, maxsize );
}

BOOL CStDatabase::SetRootPath( const char * rootpath, int nDBType )
{
	if( m_pStore )
		delete m_pStore;
	m_pStore	=	IStStore::CreateStore( rootpath, nDBType );
	return (NULL != m_pStore);
}

BOOL CStDatabase::IsOK( )
	{ return m_pStore && m_pStore->IsOK(); }
const char *CStDatabase::GetRootPath( )
	{ if(!IsOK()) return NULL; return m_pStore->GetRootPath(); }
int	CStDatabase::GetDBType( )
	{ if(!IsOK()) return IStStore::dbtypeUnknown; return m_pStore->GetDBType(); }
const char *CStDatabase::GetDBTypeName( )
	{ if(!IsOK()) return NULL;	return m_pStore->GetDBTypeName(); }

DWORD CStDatabase::GetSelfTempPath( char *szTempPath, int size )
{
	const char *szRoot = GetRootPath();
	if( 0 == strlen( szRoot ) )
	{
		if( NULL != szTempPath && size > 0 )
			szTempPath[0]	=	'\0';
		return 0;
	}

	char szReturn[MAX_PATH+1];
	memset( szReturn, 0, sizeof(szReturn) );
	strncpy( szReturn, szRoot, MAX_PATH );
	strncat( szReturn, "temp", MAX_PATH-strlen(szReturn) );
	strncat( szReturn, STRING_DIRSEP, MAX_PATH-strlen(szReturn) );
	

	BOOL	bCreated	=	TRUE;
	if( 0 != access(szReturn,0) )
		bCreated = (0==_mkdir(szReturn));
	if( !bCreated )
	{
		if( NULL != szTempPath && size > 0 )
			szTempPath[0]	=	'\0';
		return 0;
	}
	strncpy( szTempPath, szReturn, size );
	return strlen(szReturn);
}

BOOL CStDatabase::GetLastErrorMessage(LPTSTR lpszError, UINT nMaxError)
{
	if( nMaxError > 0 )
		lpszError[0]	=	'\0';
	return FALSE;
}

int	CStDatabase::GetMaxStockNumber( )
{
	if(!IsOK())	return 0;

	int nSize = m_pStore->GetMaxStockNumber();
	if( nSize > 0 )
		return nSize;

	for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
	{
		IStStore	* pStore	=	(IStStore *)m_aptrAssistant.ElementAt(i);
		nSize	=	pStore->GetMaxStockNumber();
		if( nSize > 0 )
			return nSize;
	}
	return nSize;
}

int CStDatabase::LoadCodetable( CStockContainer & container )
{
	if(!IsOK())	return 0;

	int nSize = m_pStore->LoadCodetable( container );
	if( nSize > 0 )
		return nSize;

	for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
	{
		IStStore	* pStore	=	(IStStore *)m_aptrAssistant.ElementAt(i);
		nSize	=	pStore->LoadCodetable( container );
		if( nSize > 0 )
			return nSize;
	}
	return nSize;
}

int CStDatabase::StoreCodetable( CStockContainer & container )
	{ if(!IsOK()) return 0;	return m_pStore->StoreCodetable( container ); }

int CStDatabase::LoadKDataCache( CStockContainer & container, PROGRESS_CALLBACK fnCallback, void *cookie, int nProgStart, int nProgEnd )
{
	if(!IsOK())	return 0;

	int nSize = m_pStore->LoadKDataCache( container, fnCallback, cookie, nProgStart, nProgEnd );
	if( nSize > 0 )
		return nSize;

	for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
	{
		IStStore	* pStore	=	(IStStore *)m_aptrAssistant.ElementAt(i);
		nSize	=	pStore->LoadKDataCache( container, fnCallback, cookie, nProgStart, nProgEnd );
		if( nSize > 0 )
			return nSize;
	}
	return nSize;
}

int CStDatabase::LoadBasetable( CStockContainer & container )
	{ if(!IsOK()) return 0;	return m_pStore->LoadBasetable( container ); }
int CStDatabase::StoreBasetable( CStockContainer & container )
	{ if(!IsOK()) return 0;	return m_pStore->StoreBasetable( container ); }

int CStDatabase::LoadBaseText( CStock *pstock )
{
	if( !pstock || !IsOK() )	return 0;

	int nSize = m_pStore->LoadBaseText( pstock );
	if( nSize > 0 )
		return nSize;

	for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
	{
		IStStore	* pStore	=	(IStStore *)m_aptrAssistant.ElementAt(i);
		CStock	stock;
		stock.SetStockInfo( &(pstock->GetStockInfo()) );
		if( pStore && pStore->LoadBaseText( &stock ) > 0 )
		{
			nSize	=	pstock->MergeBaseText( stock );
		}
	}
	return nSize;
}

int CStDatabase::LoadKData( CStock *pstock, int period )
{
	if( !pstock || !IsOK())	return 0;

	int nSize = m_pStore->LoadKData( pstock, period );

	for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
	{
		IStStore	* pStore	=	(IStStore *)m_aptrAssistant.ElementAt(i);
		CStock	stock;
		stock.SetStockInfo( &(pstock->GetStockInfo()) );
		if( pStore->LoadKData( &stock, period ) > 0 )
		{
			nSize	=	pstock->MergeKData( stock, period );
		}
	}
	return nSize;
}

int CStDatabase::LoadDRData( CStock *pstock )
{
	if( !pstock || !IsOK() )
		return 0;

	int nSize = m_pStore->LoadDRData( pstock );

	for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
	{
		IStStore	* pStore	=	(IStStore *)m_aptrAssistant.ElementAt(i);
		CStock	stock;
		stock.SetStockInfo( &(pstock->GetStockInfo()) );
		if( pStore && pStore->LoadDRData( &stock ) > 0 )
		{
			nSize	=	pstock->MergeDRData( stock );
		}
	}
	return nSize;
}

int CStDatabase::StoreDRData( CStock *pstock )
	{	if(!IsOK()) return 0;
		return m_pStore->StoreDRData( pstock );	}

int CStDatabase::LoadReport( CStock *pstock )
{