kdata.cpp

股软 通达信行情接收接口, 包括美元汇率

/*
	Cross Platform Core Code.

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

	Using:
		class	CKData;
*/

#include	"StdAfx.h"
#include	"Stock.h"

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

#ifdef	_DEBUG
#define	new	DEBUG_NEW
#endif

/////////////////////////////////////////////////////////////////////////////
CKData::CKData()
{
	m_nKType	=	ktypeDay;
	m_nCurFormat=	formatOriginal;
	m_nCurMaindataType	=	mdtypeClose;
	m_pDataOriginal	=	NULL;
	m_nSizeOriginal = m_nMaxSizeOriginal = 0;
	m_pData	=	NULL;
	m_nSize = m_nMaxSize = m_nGrowBy = 0;
}

CKData::CKData( int ktype, int maindatatype )
{
	m_nKType	=	ktype;
	m_nCurFormat=	formatOriginal;
	m_nCurMaindataType	=	maindatatype;
	m_pDataOriginal	=	NULL;
	m_nSizeOriginal = m_nMaxSizeOriginal = 0;
	m_pData = NULL;
	m_nSize = m_nMaxSize = m_nGrowBy = 0;
}

CKData::CKData( const CKData &src )
{
	m_nKType	=	ktypeDay;
	m_nCurFormat=	formatOriginal;
	m_nCurMaindataType	=	mdtypeClose;
	m_pDataOriginal	=	NULL;
	m_nSizeOriginal = m_nMaxSizeOriginal = 0;
	m_pData	=	NULL;
	m_nSize = m_nMaxSize = m_nGrowBy = 0;
	*this	=	src;
}

CKData	& CKData::operator = ( const CKData &src )
{
	Clear();
	
	m_nKType			=	src.m_nKType;
	m_nCurFormat		=	src.m_nCurFormat;
	m_nCurMaindataType	=	src.m_nCurMaindataType;
	m_drdata			=	src.m_drdata;

	CopyData( src );
	
	return	*this;
}

BOOL CKData::IsDayOrMin( int nKType )
{
	return (nKType == CKData::ktypeDay || nKType == CKData::ktypeWeek || nKType == CKData::ktypeMonth);
}

CKData::~CKData()
{
	Clear();
}

int CKData::GetSize() const
	{ return m_nSize; }
int CKData::Add(KDATA newElement)
	{ int nIndex = m_nSize;
		SetAtGrow(nIndex, newElement);
		return nIndex; }

void CKData::SetSize(int nNewSize, int nGrowBy /* = -1 */)
{
	SP_ASSERT(nNewSize >= 0);

	if (nGrowBy != -1)
		m_nGrowBy = nGrowBy;  // set new size

	if (nNewSize == 0)
	{
		// shrink to nothing
		delete [] (BYTE*)m_pData;
		m_pData = NULL;
		m_nSize = m_nMaxSize = 0;
	}
	else if (m_pData == NULL)
	{
		// create one with exact size
#ifdef SIZE_T_MAX
		SP_ASSERT((long)nNewSize * sizeof(KDATA) <= SIZE_T_MAX);  // no overflow
#endif
		m_pData = (KDATA*) new BYTE[nNewSize * sizeof(KDATA)];

		memset(m_pData, 0, nNewSize * sizeof(KDATA));  // zero fill

		m_nSize = m_nMaxSize = nNewSize;
	}
	else if (nNewSize <= m_nMaxSize)
	{
		// it fits
		if (nNewSize > m_nSize)
		{
			// initialize the new elements

			memset(&m_pData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(KDATA));

		}

		m_nSize = nNewSize;
	}
	else
	{
		// Otherwise grow array
		int nNewMax;
		if (nNewSize < m_nMaxSize + m_nGrowBy)
			nNewMax = m_nMaxSize + m_nGrowBy;  // granularity
		else
			nNewMax = nNewSize;  // no slush

#ifdef SIZE_T_MAX
		SP_ASSERT((long)nNewMax * sizeof(KDATA) <= SIZE_T_MAX);  // no overflow
#endif
		KDATA* pNewData = (KDATA*) new BYTE[nNewMax * sizeof(KDATA)];

		// copy new data from old
		memcpy(pNewData, m_pData, m_nSize * sizeof(KDATA));

		// construct remaining elements
		SP_ASSERT(nNewSize > m_nSize);

		memset(&pNewData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(KDATA));


		// get rid of old stuff (note: no destructors called)
		delete [] (BYTE*)m_pData;
		m_pData = pNewData;
		m_nSize = nNewSize;
		m_nMaxSize = nNewMax;
	}
}

void CKData::FreeExtra()
{
	if (m_nSize != m_nMaxSize)
	{
		// shrink to desired size
#ifdef SIZE_T_MAX
		SP_ASSERT((long)m_nSize * sizeof(KDATA) <= SIZE_T_MAX);  // no overflow
#endif
		KDATA* pNewData = NULL;
		if (m_nSize != 0)
		{
			pNewData = (KDATA*) new BYTE[m_nSize * sizeof(KDATA)];
			// copy new data from old
			memcpy(pNewData, m_pData, m_nSize * sizeof(KDATA));
		}

		// get rid of old stuff (note: no destructors called)
		delete [] (BYTE*)m_pData;
		m_pData = pNewData;
		m_nMaxSize = m_nSize;
	}
}

BOOL CKData::LatestDate( int &nYear, int &nMonth, int &nDay, int &nHour, int &nMinute ) const
{
	nYear	=	nMonth	=	nDay	=	nHour	=	nMinute	=	0;
	if( GetSize() > 0 )
		return DateAt( GetSize()-1, nYear, nMonth, nDay, nHour, nMinute );
	return FALSE;
}

DWORD CKData::GetDate( int nIndex )
{
	if( nIndex >=0 && nIndex < GetSize() )
		return ElementAt(nIndex).m_date;
	if( GetSize() > 0 )
		return ElementAt(GetSize()-1).m_date;
	return 0;
}

DWORD CKData::GetDateDay( int nIndex )
{
	DWORD	date	=	GetDate(nIndex);
	if( CKData::ktypeMin5 == m_nKType || CKData::ktypeMin15 == m_nKType
		|| CKData::ktypeMin30 == m_nKType || CKData::ktypeMin60 == m_nKType )
	{
		CSPTime	sptime;
		if( sptime.FromStockTimeMin( date ) )
			return sptime.ToStockTimeDay();
		else
			return 0;
	}
	return date;
}

int CKData::GetIndexByDate( DWORD date )
{
	if( GetSize() > 0 && ElementAt(GetSize()-1).m_date < date )
		return -1;
	if( GetSize() > 0 && ElementAt(0).m_date > date )
		return -1;
	for( int k=GetSize()-1; k >= 0 ; k-- )
	{
		if( ElementAt(k).m_date == date )
			return k;
		else if( ElementAt(k).m_date < date )
			break;
	}
	return -1;
}

int CKData::GetAboutIndexByDate( DWORD date )
{
	for( int k=GetSize()-1; k >= 0 ; k-- )
	{
		if( ElementAt(k).m_date <= date )
			return k;
	}
	return -1;
}

/////////////////////////////////////////////////////////////////////////////

void CKData::SetAtGrow(int nIndex, KDATA newElement)
{
	SP_ASSERT(nIndex >= 0);

	if (nIndex >= m_nSize)
		SetSize(nIndex+1);
	m_pData[nIndex] = newElement;
}

void CKData::InsertAt(int nIndex, KDATA newElement, int nCount /*=1*/)
{
	SP_ASSERT(nIndex >= 0);    // will expand to meet need
	SP_ASSERT(nCount > 0);     // zero or negative size not allowed

	if (nIndex >= m_nSize)
	{
		// adding after the end of the array
		SetSize(nIndex + nCount);  // grow so nIndex is valid
	}
	else
	{
		// inserting in the middle of the array
		int nOldSize = m_nSize;
		SetSize(m_nSize + nCount);  // grow it to new size
		// shift old data up to fill gap
		memmove(&m_pData[nIndex+nCount], &m_pData[nIndex],
			(nOldSize-nIndex) * sizeof(KDATA));

		// re-init slots we copied from

		memset(&m_pData[nIndex], 0, nCount * sizeof(KDATA));

	}

	// insert new value in the gap
	SP_ASSERT(nIndex + nCount <= m_nSize);
	while (nCount--)
		m_pData[nIndex++] = newElement;
}

int CKData::InsertKDataSort( KDATA newElement )
{
	for( int i=0; i<GetSize(); i++ )
	{
		KDATA	& temp = ElementAt(i);
		if( temp.m_date == newElement.m_date )
		{
			SetAt(i,newElement);
			return i;
		}
		if( temp.m_date > newElement.m_date )
		{
			InsertAt(i,newElement);
			return i;
		}
	}
	return Add( newElement );
}

BOOL CKData::IsNewValue( int nIndex, BOOL bTopOrBottom, int nDays )
{
	if( nIndex < nDays-1 || nIndex < 0 || nIndex >= GetSize() || nDays < 3 )
		return FALSE;

	BOOL	bFirst	=	TRUE;
	float	fLast	=	0;
	int		nLast	=	0;
	float	fNow	=	MaindataAt( nIndex );

	for( int k=nIndex-1; k>=0 && k>nIndex-nDays; k-- )
	{
		float	fCur	=	MaindataAt(k);
		if( bFirst )
		{
			fLast	=	fCur;
			nLast	=	k;
			bFirst	=	FALSE;
		}
		
		if( bTopOrBottom )
		{
			if( fCur > fNow )
				return FALSE;

			if( fCur > fLast )
			{
				fLast	=	fCur;
				nLast	=	k;
			}
		}
		else
		{
			if( fCur < fNow )
				return FALSE;

			if( fCur < fLast )
			{
				fLast	=	fCur;
				nLast	=	k;
			}
		}
	}
	if( bFirst )
		return FALSE;

	if( nLast >= nIndex-30 && nLast <= nIndex-5 )
		return TRUE;

	return FALSE;
}

BOOL CKData::GetMinMaxInfo( int nStart, int nEnd, float * pfMin, float *pfMax )
{
	if( nStart < 0 || nEnd < 0 || nStart > nEnd || nEnd >= GetSize() )
		return FALSE;

	float	fMin = 0, fMax = 0;
	BOOL	bFirst	=	TRUE;
	for( int k=nStart; k<=nEnd; k++ )
	{
		KDATA	& kd	=	ElementAt(k);
		if( bFirst )
		{
			fMin	=	kd.m_fLow;
			fMax	=	kd.m_fHigh;
			bFirst	=	FALSE;
		}
		if( kd.m_fLow < fMin )
			fMin	=	kd.m_fLow;
		if( kd.m_fHigh > fMax )
			fMax	=	kd.m_fHigh;
	}
	
	if( pfMin )		*pfMin	=	fMin;
	if( pfMax )		*pfMax	=	fMax;
	return !bFirst;
}

void CKData::RemoveAt(int nIndex, int nCount /* = 1 */)
{
	SP_ASSERT(nIndex >= 0);
	SP_ASSERT(nCount >= 0);
	SP_ASSERT(nIndex + nCount <= m_nSize);

	// just remove a range
	int nMoveCount = m_nSize - (nIndex + nCount);

	if (nMoveCount)
		memcpy(&m_pData[nIndex], &m_pData[nIndex + nCount],
			nMoveCount * sizeof(KDATA));
	m_nSize -= nCount;
}

void CKData::InsertAt(int nStartIndex, CKData* pNewArray)
{
	SP_ASSERT(pNewArray != NULL);
	SP_ASSERT(nStartIndex >= 0);

	if (pNewArray->GetSize() > 0)
	{
		InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize());
		for (int i = 0; i < pNewArray->GetSize(); i++)
			SetAt(nStartIndex + i, pNewArray->GetAt(i));
	}
}


/////////////////////////////////////////////////////////////////////////////
// Extra Operations

void CKData::SetKType( int ktype ) {	m_nKType = ktype;	}
void CKData::AutoSetKType( )
{
	if( GetSize() >= 4 )
	{
		long elapse1 = ElementAt(1).m_time - ElementAt(0).m_time;
		long elapse2 = ElementAt(2).m_time - ElementAt(1).m_time;
		long elapse3 = ElementAt(3).m_time - ElementAt(2).m_time;
		long elapse = min(elapse1,elapse2);
		elapse = min(elapse,elapse3);
		if( elapse < 600 )
			m_nKType = ktypeMin5;
		else if( elapse < 1200 )
			m_nKType = ktypeMin15;
		else if( elapse < 2400 )
			m_nKType = ktypeMin30;
		else if( elapse < 7200 )
			m_nKType = ktypeMin60;
		else if( elapse < 172800 )
			m_nKType = ktypeDay;
		else if( elapse < 864000 )