container.cpp

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

BOOL CStockContainer::SetMap( )
{
	CSPMutex::Scoped	l(m_mutex);

	m_map.RemoveAll( );

	if( GetSize() == 0 )
		return TRUE;

	m_map.InitHashTable( GetSize() * 2 + 10 );

	for( int i=0; i<GetSize(); i++ )
	{
		CStockInfo	&info	=	ElementAt(i);
		m_map.SetAt( info.GetStockCode(), (void *)i );
	}
	return TRUE;
}

BOOL CStockContainer::SetAverage( PROGRESS_CALLBACK fnCallback, void *cookie, int nProgStart, int nProgEnd )
{
	CSPMutex::Scoped	l(m_mutex);

	SP_ASSERT( nProgStart <= nProgEnd );
	if( nProgStart > nProgEnd )
		return FALSE;

	CStockInfo & ave = m_infoAverage;
	CStockInfo & wave = m_infoWeightAverage;
	
	ave.Clear( );
	wave.Clear( );

	ave.SetStockCode( CStock::marketUnknown, slh_avrcode );
	ave.SetStockName( slh_avrname );
	wave.SetStockCode( CStock::marketUnknown, slh_wavrcode );
	wave.SetStockName( slh_wavrname );
	
	ave.m_reporttype	=	CStock::reportUnknown;
	wave.m_reporttype	=	CStock::reportUnknown;

	float	fTemp	=	0;

	float	dc[100], wdc[100];
	int i = 0;
	for( i=0; i<sizeof(dc)/sizeof(dc[0]); i++ )		dc[i]	=	0.;
	for( i=0; i<sizeof(wdc)/sizeof(wdc[0]); i++ )	wdc[i]	=	(float)0.0001;

	int		nProgressSegment	=	GetSize() / 25;
	float	dProgressRatio		=	( 0 == GetSize() ? 1 : ((float)(nProgEnd - nProgStart))/GetSize() );

	for( int nCount=0; nCount<GetSize(); nCount++ )
	{
		if( fnCallback && !(nCount % nProgressSegment) )
			fnCallback( PROG_PROGRESS, (int)(nProgStart+nCount*dProgressRatio), NULL, cookie );

		CStockInfo & info = ElementAt(nCount);

		float	factor	=	1; // (float)CStock::GetReportFactor( info.m_reporttype );

		if( CStock::typeshIndex == info.GetType() || CStock::typeszIndex == info.GetType()
			|| CStock::typeshBond == info.GetType() || CStock::typeszBond == info.GetType() )
			continue;

		ave.m_datebase		=	info.m_datebase;
		ave.m_datetech		=	info.m_datetech;
		wave.m_datebase		=	info.m_datebase;
		wave.m_datetech		=	info.m_datetech;

		float	w	=	info.m_fShare_count_total;

		/* 平均值 *********************************************************************/
		// ★技术数据
		int	m = 0, n = 0;
		if( info.m_fLast > 1e-4 )
		{
			ave.m_fLast		=	( ave.m_fLast * dc[m] + info.m_fLast )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fLast	=	( wave.m_fLast * wdc[n] + info.m_fLast * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( info.m_fOpen > 1e-4 )
		{
			ave.m_fOpen		=	( ave.m_fOpen * dc[m] + info.m_fOpen )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fOpen	=	( wave.m_fOpen * wdc[n] + info.m_fOpen * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( info.m_fClose > 1e-4 )
		{	
			ave.m_fClose	=	( ave.m_fClose * dc[m] + info.m_fClose )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fClose	=	( wave.m_fClose * wdc[n] + info.m_fClose * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( info.m_fHigh > 1e-4 )
		{
			ave.m_fHigh		=	( ave.m_fHigh * dc[m] + info.m_fHigh )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fHigh	=	( wave.m_fHigh * wdc[n] + info.m_fHigh * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( info.m_fLow > 1e-4 )
		{
			ave.m_fLow		=	( ave.m_fLow * dc[m] + info.m_fLow )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fLow		=	( wave.m_fLow * wdc[n] + info.m_fLow * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( info.m_fVolume > 1e-4 )
		{
			ave.m_fVolume	=	( ave.m_fVolume * dc[m] + info.m_fVolume )/(dc[m]+1);	dc[m]	+=	1;
		}
		m++;	n++;
		if( info.m_fAmount > 1e-4 )
		{
			ave.m_fAmount	=	( ave.m_fAmount * dc[m] + info.m_fAmount )/(dc[m]+1);	dc[m]	+=	1;
		}

		for( i=0; i<sizeof(ave.m_fBuyPrice)/sizeof(ave.m_fBuyPrice[0]); i++ )
		{
			m++;	n++;
			if( info.m_fBuyPrice[i] > 1e-4 )
			{
				ave.m_fBuyPrice[i]		=	( ave.m_fBuyPrice[i] * dc[m] + info.m_fBuyPrice[i] )/(dc[m]+1);		dc[m]	+=	1;
				wave.m_fBuyPrice[i]		=	( wave.m_fBuyPrice[i] * wdc[n] + info.m_fBuyPrice[i] )/(wdc[n]+1);	wdc[n]	+=	w;
			}
		}
		for( i=0; i<sizeof(ave.m_fBuyVolume)/sizeof(ave.m_fBuyVolume[0]); i++ )
		{
			m++;	n++;
			if( info.m_fBuyVolume[i] > 1e-4 )
			{
				ave.m_fBuyVolume[i]		=	( ave.m_fBuyVolume[i] * dc[m] + info.m_fBuyVolume[i] )/(dc[m]+1);		dc[m]	+=	1;
				wave.m_fBuyVolume[i]	=	( wave.m_fBuyVolume[i] * wdc[n] + info.m_fBuyVolume[i] )/(wdc[n]+1);	wdc[n]	+=	w;
			}
		}
		for( i=0; i<sizeof(ave.m_fSellPrice)/sizeof(ave.m_fSellPrice[0]); i++ )
		{
			m++;	n++;
			if( info.m_fSellPrice[i] > 1e-4 )
			{
				ave.m_fSellPrice[i]		=	( ave.m_fSellPrice[i] * dc[m] + info.m_fSellPrice[i] )/(dc[m]+1);		dc[m]	+=	1;
				wave.m_fSellPrice[i]	=	( wave.m_fSellPrice[i] * wdc[n] + info.m_fSellPrice[i] )/(wdc[n]+1);	wdc[n]	+=	w;
			}
		}
		for( i=0; i<sizeof(ave.m_fSellVolume)/sizeof(ave.m_fSellVolume[0]); i++ )
		{
			m++;	n++;
			if( info.m_fSellVolume[i] > 1e-4 )
			{
				ave.m_fSellVolume[i]	=	( ave.m_fSellVolume[i] * dc[m] + info.m_fSellVolume[i] )/(dc[m]+1);		dc[m]	+=	1;
				wave.m_fSellVolume[i]	=	( wave.m_fSellVolume[i] * wdc[n] + info.m_fSellVolume[i] )/(wdc[n]+1);	wdc[n]	+=	w;
			}
		}

		// ★偿债能力
		m++;	n++;
		if( fabs(info.m_fRatio_liquidity) > 1e-4 )
		{
			ave.m_fRatio_liquidity		=	( ave.m_fRatio_liquidity * dc[m] + info.m_fRatio_liquidity )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fRatio_liquidity		=	( wave.m_fRatio_liquidity * wdc[n] + info.m_fRatio_liquidity * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fRatio_quick) > 1e-4 )
		{
			ave.m_fRatio_quick			=	( ave.m_fRatio_quick * dc[m] + info.m_fRatio_quick )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fRatio_quick			=	( wave.m_fRatio_quick * wdc[n] + info.m_fRatio_quick * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fVelocity_receivables) > 1e-4 )
		{
			ave.m_fVelocity_receivables	=	( ave.m_fVelocity_receivables * dc[m] + info.m_fVelocity_receivables )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fVelocity_receivables=	( wave.m_fVelocity_receivables * wdc[n] + info.m_fVelocity_receivables * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}

		// ★经营能力
		m++;	n++;
		if( fabs(info.m_fVelocity_merchandise) > 1e-4 )
		{
			ave.m_fVelocity_merchandise	=	( ave.m_fVelocity_merchandise * dc[m] + info.m_fVelocity_merchandise )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fVelocity_merchandise=	( wave.m_fVelocity_merchandise * wdc[n] + info.m_fVelocity_merchandise * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fMain_income) > 1e-4 )
		{
			ave.m_fMain_income			=	( ave.m_fMain_income * dc[m] + factor*info.m_fMain_income )/(dc[m]+1);		dc[m]	+=	1;
		}
		m++;	n++;
		if( fabs(info.m_fCash_ps) > 1e-4 )
		{
			ave.m_fCash_ps				=	( ave.m_fCash_ps * dc[m] + factor*info.m_fCash_ps )/(dc[m]+1);				dc[m]	+=	1;
			wave.m_fCash_ps				=	( wave.m_fCash_ps * wdc[n] + factor * info.m_fCash_ps * w )/(wdc[n]+w);		wdc[n]	+=	w;
		}

		// ★盈利能力
		m++;	n++;
		if( fabs(info.m_fProfit_margin) > 1e-4 )
		{
			ave.m_fProfit_margin	=	( ave.m_fProfit_margin * dc[m] + info.m_fProfit_margin )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fProfit_margin	=	( wave.m_fProfit_margin * wdc[n] + info.m_fProfit_margin * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fNetasset_yield) > 1e-4 )
		{
			ave.m_fNetasset_yield	=	( ave.m_fNetasset_yield * dc[m] + factor*info.m_fNetasset_yield )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fNetasset_yield	=	( wave.m_fNetasset_yield * wdc[n] + factor * info.m_fNetasset_yield * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}

		// ★资本结构
		m++;	n++;
		if( info.m_fShare_count_total > 1e-4 )
		{
			ave.m_fShare_count_total	=	( ave.m_fShare_count_total * dc[m] + info.m_fShare_count_total )/(dc[m]+1);	dc[m]	+=	1;
		}
		m++;	n++;
		if( info.m_fShare_count_a > 1e-4 )
		{
			ave.m_fShare_count_a		=	( ave.m_fShare_count_a * dc[m] + info.m_fShare_count_a )/(dc[m]+1);			dc[m]	+=	1;
		}
		m++;	n++;
		if( info.m_fShare_count_b > 1e-4 )
		{
			ave.m_fShare_count_b		=	( ave.m_fShare_count_b * dc[m] + info.m_fShare_count_b )/(dc[m]+1);			dc[m]	+=	1;
		}
		m++;	n++;
		if( info.m_fShare_count_h > 1e-4 )
		{
			ave.m_fShare_count_h		=	( ave.m_fShare_count_h * dc[m] + info.m_fShare_count_h )/(dc[m]+1);			dc[m]	+=	1;
		}
		m++;	n++;
		if( info.m_fShare_count_national > 1e-4 )
		{
			ave.m_fShare_count_national	=	( ave.m_fShare_count_national * dc[m] + info.m_fShare_count_national )/(dc[m]+1);	dc[m]	+=	1;
		}
		m++;	n++;
		if( info.m_fShare_count_corp > 1e-4 )
		{
			ave.m_fShare_count_corp		=	( ave.m_fShare_count_corp * dc[m] + info.m_fShare_count_corp )/(dc[m]+1);	dc[m]	+=	1;
		}
		m++;	n++;
		if( fabs(info.m_fProfit_psud) > 1e-4 )
		{
			ave.m_fProfit_psud			=	( ave.m_fProfit_psud * dc[m] + info.m_fProfit_psud )/(dc[m]+1);				dc[m]	+=	1;
			wave.m_fProfit_psud			=	( wave.m_fProfit_psud * wdc[n] + info.m_fProfit_psud * w )/(wdc[n]+w);		wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fAsset) > 1e-4 )
		{
			ave.m_fAsset				=	( ave.m_fAsset * dc[m] + info.m_fAsset )/(dc[m]+1);							dc[m]	+=	1;
		}
		m++;	n++;
		if( fabs(info.m_fRatio_holderright) > 1e-4 )
		{
			ave.m_fRatio_holderright	=	( ave.m_fRatio_holderright * dc[m] + info.m_fRatio_holderright )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fRatio_holderright	=	( wave.m_fRatio_holderright * wdc[n] + info.m_fRatio_holderright * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fRatio_longdebt) > 1e-4 )
		{
			ave.m_fRatio_longdebt		=	( ave.m_fRatio_longdebt * dc[m] + info.m_fRatio_longdebt )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fRatio_longdebt		=	( wave.m_fRatio_longdebt * wdc[n] + info.m_fRatio_longdebt * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fRatio_debt) > 1e-4 )
		{
			ave.m_fRatio_debt			=	( ave.m_fRatio_debt * dc[m] + info.m_fRatio_debt )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fRatio_debt			=	( wave.m_fRatio_debt * wdc[n] + info.m_fRatio_debt * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}

		// ★投资收益能力
		m++;	n++;
		if( fabs(info.m_fNetasset_ps) > 1e-4 )
		{
			ave.m_fNetasset_ps		=	( ave.m_fNetasset_ps * dc[m] + info.m_fNetasset_ps )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fNetasset_ps		=	( wave.m_fNetasset_ps * wdc[n] + info.m_fNetasset_ps * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fNetasset_ps_regulate) > 1e-4 )
		{
			ave.m_fNetasset_ps_regulate	=	( ave.m_fNetasset_ps_regulate * dc[m] + info.m_fNetasset_ps_regulate )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fNetasset_ps_regulate=	( wave.m_fNetasset_ps_regulate * wdc[n] + info.m_fNetasset_ps_regulate * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fEps) > 1e-4 )
		{
			ave.m_fEps			=	( ave.m_fEps * dc[m] + factor*info.m_fEps )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fEps			=	( wave.m_fEps * wdc[n] + factor * info.m_fEps * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fEps_deduct) > 1e-4 )
		{
			ave.m_fEps_deduct	=	( ave.m_fEps_deduct * dc[m] + factor*info.m_fEps_deduct )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fEps_deduct	=	( wave.m_fEps_deduct * wdc[n] + factor * info.m_fEps_deduct * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}
		m++;	n++;
		if( fabs(info.m_fNet_profit) > 1e-4 )
		{
			ave.m_fNet_profit	=	( ave.m_fNet_profit * dc[m] + factor*info.m_fNet_profit )/(dc[m]+1);	dc[m]	+=	1;
		}
		m++;	n++;
		if( fabs(info.m_fMain_profit) > 1e-4 )
		{
			ave.m_fMain_profit	=	( ave.m_fMain_profit * dc[m] + factor*info.m_fMain_profit )/(dc[m]+1);	dc[m]	+=	1;
		}
		m++;	n++;
		if( fabs(info.m_fTotal_profit) > 1e-4 )
		{
			ave.m_fTotal_profit	=	( ave.m_fTotal_profit * dc[m] + factor*info.m_fTotal_profit )/(dc[m]+1);dc[m]	+=	1;
		}

		// ★增长率
		m++;	n++;
		ave.m_fProfit_inc	=	( ave.m_fProfit_inc * dc[m] + info.m_fProfit_inc )/(dc[m]+1);			dc[m]	+=	1;
		wave.m_fProfit_inc	=	( wave.m_fProfit_inc * wdc[n] + info.m_fProfit_inc * w )/(wdc[n]+w);	wdc[n]	+=	w;

		m++;	n++;
		ave.m_fIncome_inc	=	( ave.m_fIncome_inc * dc[m] + info.m_fIncome_inc )/(dc[m]+1);			dc[m]	+=	1;
		wave.m_fIncome_inc	=	( wave.m_fIncome_inc * wdc[n] + info.m_fIncome_inc * w )/(wdc[n]+w);	wdc[n]	+=	w;

		m++;	n++;
		ave.m_fAsset_inc	=	( ave.m_fAsset_inc * dc[m] + info.m_fAsset_inc )/(dc[m]+1);			dc[m]	+=	1;
		wave.m_fAsset_inc	=	( wave.m_fAsset_inc * wdc[n] + info.m_fAsset_inc * w )/(wdc[n]+w);	wdc[n]	+=	w;

		// ★技术数据统计值
		m++;	n++;
		if( fabs(STKLIB_DATA_INVALID - info.m_fYield_average) > 1e-4 )
		{
			ave.m_fYield_average	=	( ave.m_fYield_average * dc[m] + info.m_fYield_average )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fYield_average	=	( wave.m_fYield_average * wdc[n] + info.m_fYield_average * w )/(wdc[n]+w);	wdc[n]	+=	w;
			m++;	n++;
			if( fabs(STKLIB_DATA_INVALID - info.m_fYield_stddev) > 1e-4 )
			{
				ave.m_fYield_stddev	=	( ave.m_fYield_stddev * dc[m] + info.m_fYield_stddev )/(dc[m]+1);			dc[m]	+=	1;
				wave.m_fYield_stddev=	( wave.m_fYield_stddev * wdc[n] + info.m_fYield_stddev * w )/(wdc[n]+w);	wdc[n]	+=	w;
			}
		}
		m++;	n++;
		if( fabs(STKLIB_DATA_INVALID - info.m_fBeite) > 1e-4 )
		{
			ave.m_fBeite	=	( ave.m_fBeite * dc[m] + info.m_fBeite )/(dc[m]+1);			dc[m]	+=	1;
			wave.m_fBeite	=	( wave.m_fBeite * wdc[n] + info.m_fBeite * w )/(wdc[n]+w);	wdc[n]	+=	w;
		}

		// K线数据
		m++;	n++;
		if( 0 == nCount )
		{
			m_infoAverage.m_kdata		=	info.m_kdata;
			m_infoWeightAverage.m_kdata	=	info.m_kdata;
		}
		for( int k=info.m_kdata.GetSize()-1; k>=0; k-- )
		{
			KDATA	&	kdInfo	=	info.m_kdata.ElementAt(k);
			// 平均值
			int	nIndex = k;
			if( nIndex >= m_infoAverage.m_kdata.GetSize() || m_infoAverage.m_kdata.ElementAt(nIndex).m_date != kdInfo.m_date )
				nIndex	=	m_infoAverage.m_kdata.GetIndexByDate(kdInfo.m_date);
			if( -1 == nIndex )
			{
				KDATA	kdNew;
				memset( &kdNew, 0, sizeof(kdNew) );
				kdNew.m_date	=	kdInfo.m_date;
				nIndex	=	m_infoAverage.m_kdata.InsertKDataSort(kdNew);
			}
			if( -1 == nIndex )
				continue;
			KDATA	&	kdAve	=	m_infoAverage.m_kdata.ElementAt(nIndex);
			kdAve.m_fOpen	=	(kdAve.m_fOpen * dc[m] + kdInfo.m_fOpen)/(dc[m]+1);
			kdAve.m_fHigh	=	(kdAve.m_fHigh * dc[m] + kdInfo.m_fHigh)/(dc[m]+1);
			kdAve.m_fLow	=	(kdAve.m_fLow * dc[m] + kdInfo.m_fLow)/(dc[m]+1);
			kdAve.m_fClose	=	(kdAve.m_fClose * dc[m] + kdInfo.m_fClose)/(dc[m]+1);
			kdAve.m_fVolume	=	(kdAve.m_fVolume * dc[m] + kdInfo.m_fVolume)/(dc[m]+1);
			kdAve.m_fAmount	=	(kdAve.m_fAmount * dc[m] + kdInfo.m_fAmount)/(dc[m]+1);

			// 加权平均值
			nIndex = k;
			if( nIndex >= m_infoWeightAverage.m_kdata.GetSize() || m_infoWeightAverage.m_kdata.ElementAt(nIndex).m_date != kdInfo.m_date )
				nIndex	=	m_infoWeightAverage.m_kdata.GetIndexByDate(kdInfo.m_date);
			if( -1 == nIndex )
			{
				KDATA	kdNew;
				memset( &kdNew, 0, sizeof(kdNew) );
				kdNew.m_date	=	kdInfo.m_date;
				nIndex	=	m_infoWeightAverage.m_kdata.InsertKDataSort(kdNew);
			}
			if( -1 == nIndex )
				continue;
			KDATA	&	kdWAve	=	m_infoWeightAverage.m_kdata.ElementAt(nIndex);
			kdWAve.m_fOpen		=	(kdWAve.m_fOpen * wdc[n] + kdInfo.m_fOpen * w)/(wdc[n]+w);
			kdWAve.m_fHigh		=	(kdWAve.m_fHigh * wdc[n] + kdInfo.m_fHigh * w)/(wdc[n]+w);
			kdWAve.m_fLow		=	(kdWAve.m_fLow * wdc[n] + kdInfo.m_fLow * w)/(wdc[n]+w);
			kdWAve.m_fClose		=	(kdWAve.m_fClose * wdc[n] + kdInfo.m_fClose * w)/(wdc[n]+w);
			kdWAve.m_fVolume	=	(kdWAve.m_fVolume * wdc[n] + kdInfo.m_fVolume * w)/(wdc[n]+w);
			kdWAve.m_fAmount	=	(kdWAve.m_fAmount * wdc[n] + kdInfo.m_fAmount * w)/(wdc[n]+w);
		}
		dc[m]	+=	1;
		wdc[n]	+=	w;

		SP_ASSERT( m <= sizeof(dc)/sizeof(dc[0]) );
		SP_ASSERT( n <= sizeof(wdc)/sizeof(wdc[0]) );
	
	}

	if( fnCallback )
		fnCallback( PROG_PROGRESS, nProgEnd, NULL, cookie );

	return TRUE;
}

BOOL CStockContainer::Clear( )
{
	CSPMutex::Scoped	l(m_mutex);

	ClearVariantSaveValue( );

	// WARNING: Cannot clear this m_nCurrentStock	=	-1;
	// WARNING: Cannot clear this m_strCurrentStockCode.Empty();
	m_nType		=	typeNone;
	m_strDomain.Empty();
	m_dwDate = -1;
	RemoveAll();
	m_map.RemoveAll( );
	m_infoAverage.Clear( );
	m_infoWeightAverage.Clear( );

	m_auidSort.RemoveAll();
	return TRUE;
}

void CStockContainer::CopyData( CStockContainer & src )
{
	CSPMutex::Scoped	l(m_mutex);

	SetSize( src.GetSize() );
	for( int i=0; i<src.GetSize(); i++ )
	{
		CStockInfo	& info	=	src.ElementAt(i);
		SetAt( i, info );
	}
}

int CStockContainer::SortFunction(const void *s1,const void *s2)
{
	CStockInfo *pStock1 = (CStockInfo *)s1;
	CStockInfo *pStock2 = (CStockInfo *)s2;

	if( NULL == pStock2 )
		return 1;

	if( NULL == pStock1 )
		return -1;

	if( NULL == CStockContainer::m_pSortContainer )
		return 1;

	int nRet = AfxCompareVariantValue(	CStockContainer::m_pSortContainer->m_nSortVariantID, *pStock1, *pStock2,
										CStockContainer::m_pSortContainer );
	if( CStockContainer::m_pSortContainer->m_bSortAscend )
		return nRet;
	if( nRet > 0 )
		return -1;
	else if( nRet < 0 )
		return 1;
	return 0;
}

int CStockContainer::StockInfoCompareFunc( const void *s1,const void *s2, CStockContainer * pContainer, int nSortVariantID )
{
	CStockInfo *pStock1 = (CStockInfo *)s1;
	CStockInfo *pStock2 = (CStockInfo *)s2;

	if( NULL == pStock2 )
		return 1;

	if( NULL == pStock1 )
		return -1;

	return AfxCompareVariantValue(	nSortVariantID, *pStock1, *pStock2, pContainer );
}


BOOL CStockContainer::Sort( int nSortVariantID, BOOL bAscend )
{
	CSPMutex::Scoped	l(m_mutex);

	m_auidSort.RemoveAll();	// if call this Sort(...), then not use m_auidSort
	
	CStockContainer::m_pSortContainer	=	this;
	m_nSortVariantID	=	nSortVariantID;
	m_bSortAscend		=	bAscend;

	if( NULL != GetData() )
		qsort( GetData(), GetSize(), sizeof(CStockInfo), SortFunction );
	return TRUE;
}

void CStockContainer::SetSortID( CSPDWordArray & auidsort )
{
	CSPMutex::Scoped	l(m_mutex);

	m_auidSort.RemoveAll();
	m_auidSort.Copy( auidsort );
}

BOOL CStockContainer::GetMultiSortIDArray( CSPDWordArray & adwSortID, LONG lStockType, UINT nSLH, BOOL bAsc, int nCount )
{
	CSPMutex::Scoped	l(m_mutex);

	SP_ASSERT( nCount > 0 && nSLH >= SLH_MIN && nSLH <= SLH_MAX );
	if( nCount <= 0 || nSLH < SLH_MIN || nSLH > SLH_MAX )
		return FALSE;

	adwSortID.RemoveAll();

	for( int n=0; n<nCount; n++ )
	{
		int		nMinMaxIndex	=	-1;
		double	dMinMaxValue	=	0;
		BOOL	bInited	=	FALSE;
		for( int i=0; i<GetSize(); i++ )
		{
			CStockInfo & info	=	ElementAt(i);

			// 股票类型
			if( info.GetType() != lStockType )
				continue;

			// 如果加过，则继续寻找下一个
			int k;
			for( k=0; k<adwSortID.GetSize(); k++ )
			{
				if( adwSortID[k] == (DWORD)i )
					break;
			}
			if( k != adwSortID.GetSize() )
				continue;

			// 判断大小
			double	dValue	=	0;
			if( AfxGetVariantValue( nSLH, info, &dValue, NULL ) )
			{
				if( !bInited )
				{
					nMinMaxIndex	=	i;
					dMinMaxValue	=	dValue;
					bInited	=	TRUE;
				}
				if( bAsc && dValue < dMinMaxValue )
				{
					nMinMaxIndex	=	i;
					dMinMaxValue	=	dValue;
				}
				if( !bAsc && dValue > dMinMaxValue )
				{
					nMinMaxIndex	=	(DWORD)i;
					dMinMaxValue	=	dValue;
				}