}
		}

		if( -1 == nMinMaxIndex )
			break;
		adwSortID.Add( nMinMaxIndex );
	}

	return TRUE;
}

BOOL CStockContainer::GetVariantSaveValue( double *pValue, UINT nVariantID, CStockInfo &info, BOOL *pNoValue )
{
	CSPMutex::Scoped	l(m_mutex);

	void * pArrayID	=	NULL;
	if( !m_map.Lookup( info.GetStockCode(), pArrayID ) )
		return FALSE;

	int	nIndex	=	(int)pArrayID;
	if( nIndex >= 0 && nIndex < m_aptrSaveValueArray.GetSize() )
	{
		CSPPtrArray * pArray = (CSPPtrArray *)m_aptrSaveValueArray.ElementAt( nIndex );
		if( pArray )
		{
			VARIANT_SAVEVALUE * pSave = NULL;
			for( int j=0; j<pArray->GetSize(); j++ )
			{
				pSave = (VARIANT_SAVEVALUE *) pArray->GetAt(j);
				if( pSave->nVariantID == nVariantID )
				{
					if( pValue )	*pValue		=	pSave->Value;
					if( pNoValue )	*pNoValue	=	pSave->bNoValue;
					return TRUE;
				}
			}
		}
	}
	
	return FALSE;
}

void CStockContainer::SetVariantSaveValue( double Value, UINT nVariantID, CStockInfo &info, BOOL bNoValue )
{
	CSPMutex::Scoped	l(m_mutex);

	void * pArrayID	=	NULL;
	if( !m_map.Lookup( info.GetStockCode(), pArrayID ) )
		return;

	// alloc for m_aptrSaveValueArray
	if( m_aptrSaveValueArray.GetSize() == 0 )
	{
		m_aptrSaveValueArray.SetSize( GetSize() );
		for( int i=0; i<m_aptrSaveValueArray.GetSize(); i++ )
			m_aptrSaveValueArray.SetAt( i, NULL );
	}

	int	nIndex	=	(int)pArrayID;
	if( nIndex >= 0 && nIndex < m_aptrSaveValueArray.GetSize() )
	{
		CSPPtrArray * pArray = (CSPPtrArray *)m_aptrSaveValueArray.ElementAt( nIndex );
		if( NULL == pArray )
		{
			pArray	=	new	CSPPtrArray;
			m_aptrSaveValueArray.SetAt( nIndex, pArray );
		}
		
		// 如果已經(jīng)存在，覆蓋之
		for( int j=0; j<pArray->GetSize(); j++ )
		{
			VARIANT_SAVEVALUE * pSave = (VARIANT_SAVEVALUE *) pArray->GetAt(j);
			if( pSave->nVariantID == nVariantID )
			{
				pSave->Value	=	Value;
				pSave->bNoValue	=	bNoValue;
				return;
			}
		}
		
		// 加入新的
		VARIANT_SAVEVALUE * pSaveValue = new VARIANT_SAVEVALUE;
		pSaveValue->nVariantID	=	nVariantID;
		pSaveValue->Value		=	Value;
		pSaveValue->bNoValue	=	bNoValue;
		pArray->Add( pSaveValue );
	}
}

void CStockContainer::ClearVariantSaveValue( )
{
	CSPMutex::Scoped	l(m_mutex);

	for( int i=0; i<m_aptrSaveValueArray.GetSize(); i++ )
	{
		CSPPtrArray * pArray = (CSPPtrArray *)m_aptrSaveValueArray.ElementAt( i );
		if( pArray )
		{
			for( int j=0; j<pArray->GetSize(); j++ )
				delete	pArray->GetAt(j);
			delete	pArray;
		}
	}
	m_aptrSaveValueArray.RemoveAll();
}

//////////////////////////////////////////////////////////////////////
// class CDomain

CDomain::CDomain( )
{
}

CDomain::CDomain( const CDomain &src )
{
	*this	=	src;
}

CDomain::~CDomain( )
{
}

BOOL CDomain::AddStock( LPCTSTR lpszStockCode )
{
	if( NULL == lpszStockCode || strlen(lpszStockCode) <= 0 )
		return FALSE;

	for( int k=0; k<GetSize(); k++ )
	{
		int nCmp = ElementAt(k).CompareNoCase(lpszStockCode);
		if( 0 == nCmp )
			return FALSE;
	}

	Add( lpszStockCode );
	return TRUE;
}

BOOL CDomain::AddStockSort( LPCTSTR lpszStockCode )
{
	if( NULL == lpszStockCode || strlen(lpszStockCode) <= 0 )
		return FALSE;

	for( int k=0; k<GetSize(); k++ )
	{
		int nCmp = ElementAt(k).CompareNoCase(lpszStockCode);
		if( 0 == nCmp )
			return FALSE;
		if( nCmp > 0 )
		{
			InsertAt(k, lpszStockCode );
			return TRUE;
		}
	}

	Add( lpszStockCode );
	return TRUE;
}

BOOL CDomain::RemoveStock( LPCTSTR lpszStockCode )
{
	if( NULL == lpszStockCode || strlen(lpszStockCode) <= 0 )
		return FALSE;

	for( int k=0; k<GetSize(); k++ )
	{
		if( 0 == ElementAt(k).CompareNoCase(lpszStockCode) )
		{
			RemoveAt(k);
			return TRUE;
		}
	}
	return FALSE;
}

CDomain &CDomain::operator = ( const CDomain &src )
{
	m_strName		=	src.m_strName;
	Copy( src );
	return *this;
}

struct fxj_block_t {
	WORD	wMarket;
	char	szCode[10];
};

int CDomain::AddFxjDomain( LPCTSTR lpszFile )
{
	CSPFile file;
	DWORD	dwMagic;
	if( !file.Open( lpszFile, CSPFile::modeRead )
		|| sizeof(dwMagic) != file.Read(&dwMagic,sizeof(dwMagic)) || dwMagic != 0xFF5100A5 )
		return 0;

	int nCount = 0;
	struct fxj_block_t stock;
	while( sizeof(stock) == file.Read(&stock,sizeof(stock)) )
	{
		if( 0 == stock.szCode[6] )
		{
			CSPString sCode = stock.szCode;
			if( sCode.GetLength() == 4 )
				sCode = "00" + sCode;
			if( sCode.GetLength() == 6 )
				AddStock( sCode );
		}
	}
	
	return GetSize();
}


//////////////////////////////////////////////////////////////////////
// class CDomainContainer

CDomainContainer::CDomainContainer( )
{
}

CDomainContainer::CDomainContainer( CDomainContainer & src )
{
	*this	=	src;
}

CDomainContainer::~CDomainContainer( )
{
	RemoveAll( );
}

CDomainContainer & CDomainContainer::operator = ( CDomainContainer & src )
{
	SetSize( src.GetSize() );
	for( int i=0; i<src.GetSize(); i++ )
	{
		CDomain domain = src.ElementAt(i);
		SetAt( i, domain );
	}
	return *this;
}

int CDomainContainer::AddDomain( LPCTSTR lpszDomainName )
{
	if( NULL == lpszDomainName || strlen(lpszDomainName) <=0  )
		return -1;
	CDomain	newdomain;
	newdomain.m_strName	=	lpszDomainName;
	return AddDomain( newdomain );
}

int CDomainContainer::AddDomain( CDomain & newdomain )
{
	if( 0 == newdomain.m_strName.GetLength() )
		return -1;

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain & domain = ElementAt(i);
		if( 0 == newdomain.m_strName.CompareNoCase( domain.m_strName ) )
			return -1;
	}
	return Add( newdomain );
}

int CDomainContainer::AddDomainReplace( CDomain & newdomain )
{
	if( 0 == newdomain.m_strName.GetLength() )
		return -1;

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain & domain = ElementAt(i);
		if( 0 == newdomain.m_strName.CompareNoCase( domain.m_strName ) )
		{
			SetAt( i, newdomain );
			return i;
		}
	}
	return Add( newdomain );
}

int CDomainContainer::AddDomainReplace( CDomainContainer & newdomains )
{
	int nCount = 0;
	for( int i=0; i<newdomains.GetSize(); i++ )
	{
		if( AddDomainReplace( newdomains.ElementAt(i) ) >= 0 )
			nCount ++;
	}
	return nCount;
}

BOOL CDomainContainer::RemoveDomain( LPCTSTR lpszDomainName )
{
	if( NULL == lpszDomainName || strlen(lpszDomainName) <= 0 )
		return FALSE;

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain & domain = ElementAt(i);
		if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
		{
			RemoveAt( i );
			return TRUE;
		}
	}
	
	return FALSE;
}

BOOL CDomainContainer::AddDomainStock( LPCTSTR lpszDomainName, LPCTSTR lpszStockCode )
{
	if( NULL == lpszDomainName || strlen(lpszDomainName) < 0
		|| NULL == lpszStockCode || strlen(lpszStockCode) < 0 )
		return FALSE;

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain	& domain	=	ElementAt(i);
		if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
		{
			return domain.AddStock( lpszStockCode );
		}
	}

	return FALSE;
}

BOOL CDomainContainer::AddDomainStock( LPCTSTR lpszDomainName, CSPStringArray & astr )
{
	if( NULL == lpszDomainName || strlen(lpszDomainName) < 0 )
		return FALSE;

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain	& domain	=	ElementAt(i);
		if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
		{
			for( int j=0; j<astr.GetSize(); j++ )
				domain.AddStock( astr.ElementAt(j) );
			return TRUE;
		}
	}

	return FALSE;
}

BOOL CDomainContainer::RemoveDomainStock( LPCTSTR lpszDomainName, LPCTSTR lpszStockCode )
{
	if( NULL == lpszDomainName || strlen(lpszDomainName) < 0
		|| NULL == lpszStockCode || strlen(lpszStockCode) < 0 )
		return FALSE;

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain	& domain	=	ElementAt(i);
		if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
		{
			for( int k=0; k<domain.GetSize(); k++ )
			{
				if( 0 == domain.ElementAt(k).CompareNoCase(lpszStockCode) )
				{
					domain.RemoveAt(k);
					return TRUE;
				}
			}
			break;
		}
	}

	return FALSE;
}

BOOL CDomainContainer::RemoveDomainStockAll( LPCTSTR lpszDomainName )
{
	if( NULL == lpszDomainName || strlen(lpszDomainName) < 0 )
		return FALSE;

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain	& domain	=	ElementAt(i);
		if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
		{
			domain.RemoveAll();
			return TRUE;
		}
	}

	return FALSE;
}

BOOL CDomainContainer::GetDomainStocks( LPCTSTR lpszDomain, CSPStringArray &astr )
{
	if( NULL == lpszDomain || strlen(lpszDomain) < 0 )
		return FALSE;

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain	& domain	=	ElementAt(i);
		if( 0 == domain.m_strName.CompareNoCase( lpszDomain ) )
		{
			astr.Copy( domain );
			return TRUE;
		}
	}

	return FALSE;
}

BOOL CDomainContainer::GetDomains( CSPStringArray & astr )
{
	astr.SetSize( GetSize() );

	for( int i=0; i<GetSize(); i++ )
	{
		CDomain	& domain	=	ElementAt(i);
		CSPString	string	=	domain.m_strName;
		astr.SetAt( i, string );
	}
	return TRUE;
}

BOOL CDomainContainer::GetAllDomainInfo( CStockContainer * pContainer, DWORD dwDate )
{
	SP_ASSERT( pContainer );
	if( NULL == pContainer )
		return FALSE;

	DWORD	dwDateLatest = -1;
	AfxGetStockContainer().GetLatestTechDate( &dwDateLatest );

	for( int nDomain=0; nDomain<GetSize(); nDomain++ )
	{
		CDomain	&	domain	=	ElementAt(nDomain);
		CStockContainer	cntn;
		if( cntn.RetrieveSpecify( domain ) )
		{
			if( -1 != dwDate && dwDateLatest != dwDate )
			{
				for( int i=0; i<cntn.GetSize(); i++ )
				{
					CStockInfo	& info	=	cntn.ElementAt(i);
					info.StatBaseIndex( dwDate );
					info.StatTechIndex( dwDate );
				}
			}
			// cntn.SetMap( );
			cntn.SetAverage( );

			CStockInfo	info	=	cntn.GetAverage( );
			info.SetStockName( domain.m_strName );
			info.SetStockShortName( domain.m_strName );
			pContainer->Add( info );
		}
	}
	pContainer->SetMap();
	pContainer->SetAverage();
	return TRUE;
}

#define	SF_MAX_DOMAINFILE_LENGTH	0x10000000

BOOL CDomainContainer::Load( LPCTSTR lpszFileName )
{
	if( NULL == lpszFileName || strlen(lpszFileName) <= 0 )
		return FALSE;

	BOOL	bOK	=	FALSE;
	CSPFile file;
	
	if( file.Open( lpszFileName, CSPFile::modeRead ) )
	{
		DWORD dwLen = file.GetLength();
		if( 0 == dwLen || dwLen > SF_MAX_DOMAINFILE_LENGTH )
		{
			file.Close();
			return FALSE;
		}

		SetSize( 0, min(dwLen / 300, 20) );

		CDomain	domain;
		CSPString	rString;
		while( file.ReadString( rString ) )
		{
			int	nIndex	=	rString.Find( "\r" );
			if( -1 == nIndex )
				nIndex	=	rString.Find( "\n" );
			if( -1 != nIndex )
				rString	=	rString.Left( nIndex );
			rString.TrimLeft();
			rString.TrimRight();

			if( rString.GetLength() > 0 )
			{
				if( domain.m_strName.IsEmpty() )	// 新版塊名稱(chēng)
					domain.m_strName	=	rString;
				else
					domain.AddStock( rString );
			}
			else
			{	// 版塊結(jié)束
				if( !domain.m_strName.IsEmpty() )
					AddDomain( domain );
				domain.m_strName.Empty();
				domain.RemoveAll();
			}
		}
		if( !domain.m_strName.IsEmpty() )
			Add( domain );
		domain.m_strName.Empty();
		domain.RemoveAll();

		file.Close();
		bOK	=	TRUE;
	}

	return bOK;
}

BOOL CDomainContainer::Store( LPCTSTR lpszFileName )
{
	if( NULL == lpszFileName || strlen(lpszFileName) <= 0 )
		return FALSE;

	CSPFile file;
	if( file.Open( lpszFileName, CSPFile::modeCreate | CSPFile::modeWrite ) )
	{
		for( int i=0; i<GetSize(); i++ )
		{
			CDomain	& domain = ElementAt(i);
			CSPString	strDomain	=	domain.m_strName;
			file.Write( strDomain.GetBuffer(strDomain.GetLength()+1), strDomain.GetLength() );
			file.Write( STRING_CRLF, strlen(STRING_CRLF) );
			for( int k=0; k<domain.GetSize(); k++ )
			{
				CSPString	strStock	=	domain[k];
				if( strStock.GetLength() > 0 )
				{
					file.Write( strStock.GetBuffer(strStock.GetLength()), strStock.GetLength() );
					file.Write( STRING_CRLF, strlen(STRING_CRLF) );
				}
			}
			file.Write( STRING_CRLF, strlen(STRING_CRLF) );
		}
		
		file.Close();
		return TRUE;
	}
	return FALSE;
}