inputer.cpp

包含拼音和笔画输入的中文输入法,使用VC.NET2003开发.portable Chinese input method includes phonetic input and stroke, the

			break;
		default	:
			return	FALSE;
		}
	}
	return	TRUE;
}

//===================================================================================
//
//	查询过滤器
//
//===================================================================================

/*
*	构造函数
*/
ChineseInputer::SpellFilter::SpellFilter( const TCHAR* szSpell ) : QueryFilter(szSpell)
{
}

/*
*	查询
*/
BOOL	ChineseInputer::SpellFilter::QueryWords( WordEnumerator& enumer )
{
	return	ChineseDictionary::GetSpellQuery()->QueryWords( GetFilter(), enumer );
}


/*
*	验证字是否满足要求
*/
BOOL	ChineseInputer::SpellFilter::Pass( Word wd ) 
{
	SpellGroup	sg	=	GetComment(wd).GetSpellGroup( );

	SpellGroup::const_iterator	it;
	for ( it=sg.begin(); it!=sg.end(); it++ )
	{
		if ( SpellContainTester::Contain( *it, GetFilter() ) )
			return	TRUE;
	}

	return	FALSE;
}

ChineseInputer::BSFilter::BSFilter( const TCHAR* szBS ) : QueryFilter(szBS)
{
}

BOOL	ChineseInputer::BSFilter::QueryWords( WordEnumerator& enumer )
{
	return	ChineseDictionary::GetBSQuery()->QueryWords( GetFilter(), enumer );
}

BOOL	ChineseInputer::BSFilter::Pass( Word wd )
{
	return	GetComment(wd).GetBS() == GetFilter();
}

ChineseInputer::StrokesFilter::StrokesFilter( const TCHAR* szStrokes ) 
	:	QueryFilter(szStrokes)
{
	m_nStrokes	=	_ttoi(szStrokes);
}

BOOL	ChineseInputer::StrokesFilter::QueryWords( WordEnumerator& enumer )
{
	return	ChineseDictionary::GetStrokesQuery()->QueryWords( GetFilter(), enumer );
}

BOOL	ChineseInputer::StrokesFilter::Pass( Word wd )
{
	return	GetComment(wd).GetStrokes() == GetStrokes();
}

ChineseInputer::StrokesOrderFilter::StrokesOrderFilter( const StrokesOrder& sodr ) 
	:	QueryFilter(sodr.GetAsDigits())
{
}

BOOL	ChineseInputer::StrokesOrderFilter::QueryWords( WordEnumerator& enumer )
{
	return	ChineseDictionary::GetStrokesOrderQuery()->QueryWords( GetFilter(), enumer );
}

BOOL	ChineseInputer::StrokesOrderFilter::Pass( Word wd )
{
	return	StrokesOrderContainTester::Contain( 
		GetComment(wd).GetStrokesOrder().GetAsDigits(),
		GetFilter()	);
}

ChineseInputer::QueryBroker::~QueryBroker()
{
	for ( unsigned int i=0; i<m_vFilters.size(); i++ )
	{
		if	( m_vDeletes[i] )
			delete m_vFilters[i];
	}
}

/*
*	QueryBroker
*/
void	ChineseInputer::QueryBroker::AddFilter( QueryFilter* pFilter, BOOL bAutoDel )
{
	m_vFilters.push_back(pFilter);
	m_vDeletes.push_back( bAutoDel );
}

BOOL	ChineseInputer::QueryBroker::QueryWords( WordEnumerator& enumer )
{
	if	( m_vFilters.size() < 1 ) 
		return	TRUE;

	// 只有一个过滤器
	if ( m_vFilters.size() == 1 )
		return	m_vFilters[0]->QueryWords(enumer);

	// 多个过滤器
	WordEnumerator	wdWhole;
	if ( !m_vFilters[0]->QueryWords(wdWhole) )
		return	FALSE;

	WordEnumerator::iterator	it;
	for ( it=wdWhole.begin(); it!=wdWhole.end(); it++ )
	{
		for ( unsigned int i=1; i<m_vFilters.size(); i++ )
		{
			if ( !m_vFilters[i]->Pass(*it) )
				break;
		}

		if ( i>=m_vFilters.size())
			enumer.push_back( *it );
	}

	return	TRUE;
}

//==================================================================================
//	排序器
//==================================================================================

struct	LessBase
{
	const	ChineseDictionary::WordComment&	GetComment( Word wd ) const
	{
		return	ChineseDictionary::Get(wd).GetComment( );
	}
};

/**
*	拼音比较器
*/
struct	SpellLess2	:	public LessBase, public SpellLess
{
protected :
	/**
	*	拼音前缀
	*/
	CString		m_strPrefix;

	/**
	*	获得拼音
	*/
	const	CString&	GetSpell( Word wd ) const
	{
		const	SpellGroup&	sg	=	GetComment(wd).GetSpellGroup();

		SpellGroup::const_iterator it;
		for ( it=sg.begin(); it!=sg.end(); it++ )
		{
			const	CString&	strSpell	=	*it;
			if ( SpellContainTester::Contain(strSpell, m_strPrefix) )
				return	strSpell;
		}

		return	m_strPrefix;
	}

public :
	SpellLess2( const TCHAR* strPrefix=_T("") ) : m_strPrefix(strPrefix)
	{
	}

	BOOL	operator()( const Word& wd1,
						const Word& wd2 ) const
	{
		// 缺省按照第一个拼音排序
		return	SpellLess::operator()( GetSpell(wd1), 	GetSpell(wd2) );
	}
};

/**
*	笔画比较器
*/
struct	StrokesLess2	:	public LessBase, public StrokesLess
{
	BOOL	operator()( const Word& wd1,
						const Word& wd2 ) const
	{
		return	StrokesLess::operator()( GetComment(wd1).GetStrokes(),
				GetComment(wd2).GetStrokes() );
	} 
};

/**
*	笔顺比较器
*/
struct	StrokesOrderLess2	:	public LessBase, public StrokesOrderLess
{
	BOOL	operator()( const Word& wd1,
						const Word& wd2 ) const
	{
		// 缺省按照第一个拼音排序
		return	StrokesOrderLess::operator()( 
			GetComment(wd1).GetStrokesOrder().GetAsDigits(), 
			GetComment(wd2).GetStrokesOrder().GetAsDigits() );
	}
};

/**
*	部首比较器
*/
struct	BSLess2	:	public LessBase, public BSLess
{
	BOOL	operator()( const Word& wd1,
						const Word& wd2 )
	{
		return	BSLess::operator()( GetComment(wd1).GetBS(), 
			GetComment(wd2).GetBS() );
	} 
};

struct	CompositeLess	:	//public LessBase,
							public BSLess,
							public StrokesOrderLess,
							public SpellLess2,
							public StrokesLess
{
	typedef		vector<int>		Modes;

	CompositeLess(const Modes& vModes ) : m_vModes(vModes) 
	{
	};

	BOOL	operator()( const Word& wd1,
						const Word& wd2 )

	{
		Modes::iterator	it;
		for ( it=m_vModes.begin(); it!=m_vModes.end(); it++ )
		{
			switch ( *it )
			{
			case	ChineseInputer::Sorter::OrderBySpell :
				{
					if ( SpellLess::operator()( GetSpell(wd1),
					 						    GetSpell(wd2) ) )
						return	TRUE;

					return	FALSE;
				}
				break;
			case	ChineseInputer::Sorter::OrderByBS :
				{
					if ( BSLess::operator()( GetComment(wd1).GetBS(),
						GetComment(wd2).GetBS() ) )
						return	TRUE;
				}
				break;
			case	ChineseInputer::Sorter::OrderByStrokes :
				{
					if ( StrokesLess::operator()( GetComment(wd1).GetStrokes(),
												     GetComment(wd2).GetStrokes() ) )
						return	TRUE;
				}
				break;
			case	ChineseInputer::Sorter::OrderByStrokesOrder :
				{
					if ( StrokesOrderLess::operator()( GetComment(wd1).GetStrokesOrder(),
														  GetComment(wd2).GetStrokesOrder() ) )
						return	TRUE;
				}
				break;
			default :
				break;
			}
		}

		return	FALSE;
	}

protected :
	Modes		m_vModes;
};
								


/*
*	按照拼音排序
*/
void	ChineseInputer::SpellSort::Sort( WordEnumerator& enumer )
{
	enumer.sort( SpellLess2( GetPrefix( ) ) );
}

void	ChineseInputer::BSSort::Sort( WordEnumerator& enumer )
{
	enumer.sort( BSLess2() );
}

void	ChineseInputer::StrokesSort::Sort( WordEnumerator& enumer )
{
	enumer.sort( StrokesLess2() );
}

void	ChineseInputer::StrokesOrderSort::Sort( WordEnumerator& enumer )
{
	enumer.sort( StrokesOrderLess2() );
}

/**
*	复合排序器
*/
void	ChineseInputer::CompositeSort::AddMode( int uMode )
{
	if ( find( m_vModes.begin(), m_vModes.end(), uMode ) == m_vModes.end() )
		m_vModes.push_back( uMode );
}

void	ChineseInputer::CompositeSort::ClearModes()
{
	m_vModes.clear();
}

void	ChineseInputer::CompositeSort::Sort(ChineseInputer::WordEnumerator& enumer )
{
	enumer.sort( CompositeLess(m_vModes) );
}

//===================================================================================
//
//	汉字字典
//
//===================================================================================
ChineseDictionary::WordTable	ChineseDictionary::s_WordTable;

/*
*	非法词条
*/
ChineseDictionary::WordItem	ChineseDictionary::NullWordItemRef;


/*
*	查询汉字
*/
ChineseDictionary::WordItemRef		ChineseDictionary::Get( Word wdLookup )
{
	WordTable::iterator	it	=	s_WordTable.find( wdLookup );
	if ( it ==	s_WordTable.end()  )
		return	NullWordItemRef;
	return	WordItem( it->first, &(it->second) );
}

/*
*	清空所有词条
*/
void	ChineseDictionary::Clear( )
{
	s_WordTable.clear( );
}

/*
*	加入汉字
*/
void	ChineseDictionary::AddWord( Word wd, const WordComment& wc )
{
	WordTable::iterator	it	=	s_WordTable.find( wd );

	// 加入新字
	if ( it ==	s_WordTable.end()  )
	{
		s_WordTable[wd]		=	wc;//WordItem( wd, wc );
	}
	else // 加入新得拼音
	{
		WordComment&	wcHave	=	s_WordTable[wd];

		SpellGroup	sg	=	wcHave.GetSpellGroup();
		sg.AddGroup ( wc.GetSpellGroup().GetAsString() );
		
		wcHave.SetSpellGroup( sg );

	}
}

/*
*	从文件中装入字典
*/
BOOL	ChineseDictionary::Load( const TCHAR* szFile )
{
	Clear();

	CFile	file;
	if ( !file.Open( szFile, CFile::modeRead | CFile::typeBinary ) )
		return	FALSE;

	TStreamAdapter<CFile>	os(&file);

	// 读入大小
	int		nSize;
	os >> nSize;

	// 读入所有条目
	Word			wd;
	WordComment		wc;
	for ( int i=0; i<nSize; i++ )
	{
		wd	<<	os;
		wc	<<	os;

		AddWord( wd, wc );
	} // end of all item


	file.Close();
	return	TRUE;
}

ChineseDictionary::WordItem::operator BOOL() const
{
	return	*this != ChineseDictionary::NullWordItemRef;
}


/*
*	将字典写入文件
*/
BOOL	ChineseDictionary::Save( const TCHAR* szFile )
{
	CFile	file;
	if ( !file.Open( szFile, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary ) )
		return	FALSE;

	TStreamAdapter<CFile>	os(&file);

	// write the size 
	int		nSize	=	s_WordTable.size();
	os << nSize;

	WordTable::iterator	it;
	for	( it=s_WordTable.begin(); it!=s_WordTable.end(); it++ )
	{
		// 保存字
		const Word&	wd	=	it->first;
		wd >> os;
		
		// 保存注释
		const WordComment&	wc	=	it->second;
		wc >> os;
	}

	// close the file
	file.Close();

	return	TRUE;
}

/*
* 部首查询器初始化
*/
BOOL	ChineseDictionary::QueryBase::Initialize( WordTable* pWordTbl )
{
	m_pWordTbl	=	pWordTbl;
	return	TRUE;
}

/*
* 部首查询器销毁
*/
void	ChineseDictionary::QueryBase::Uninitialize(  )
{
	m_pWordTbl	=	NULL;
}


/*
*	根据输入部首， 查询汉字
*/
BOOL	ChineseDictionary::BSQuery::QueryWords( const TCHAR* szBuShou, 
												WordEnumerator& enumer )
{
	if ( !m_pWordTbl ) 
		return	FALSE;

	Word	wdBS( szBuShou );

	// 查询满足条件的汉字
	WordTable::iterator it;
	for ( it=m_pWordTbl->begin(); it!=m_pWordTbl->end(); it++ )
	{
		const WordComment&	wc	=	it->second;
		if ( wc.GetBS() == wdBS )
			enumer.push_back(it->first);
	}

	return	TRUE;
}

/*
*	根据输入部首， 查询汉字
*/
BOOL	ChineseDictionary::StrokesQuery::QueryWords( int nStrokes, 
												WordEnumerator& enumer )
{
	if ( !m_pWordTbl ) 
		return	FALSE;

	// 查询满足条件的汉字
	WordTable::iterator it;
	for ( it=m_pWordTbl->begin(); it!=m_pWordTbl->end(); it++ )
	{
		const WordComment&	wc	=	it->second;
		if ( wc.GetStrokes() == nStrokes )
			enumer.push_back(it->first);
	}

	return	TRUE;
}

/*
*	根据输入笔画， 查询汉字
*/
BOOL	ChineseDictionary::StrokesQuery::QueryWords( const TCHAR* szStrokes, 
													 WordEnumerator& enumer )
{
	int	nStrokes	=	_ttoi(szStrokes);