Tokenizer and analyzer package supporting precedence prioritized rules

/*********************************************************************
	Copyright (C) 2001/2 by

		Alexander Berthold, alexander-berthold@web.de.
		Hoegestr. 54
		79108 Freiburg i. Breisgau
		Germany

    -- This file is part of cxAnalyzer --

    "cxAnalyzer" is free software; you can redistribute it and/or 
	modify it under the terms of the GNU Lesser General Public 
	License as published by the Free Software Foundation; either 
	version 2 of the License, or any later version.

    "cxAnalyzer" is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
	License along with "cxAnalyzer"; if not, write to the Free 
	Software  Foundation, Inc., 59 Temple Place, Suite 330, 
	Boston, MA  02111-1307  USA

    ---------------------------------------------------------------
      If you find any bugs or if you make other corrections/
	  enhancements, i'd appreciate if you'd let me know about 
	  that. My email is
  
       alexander-berthold@web.de
  
      If you share this code, do not remove this text.
    ---------------------------------------------------------------

Class:      cxaRuleCache
Author:     Alexander Berthold
Copyright:  Alexander Berthold
Date:       2001/12/19
Version:	0.2.01
Purpose:    Helper class for caching failed/succeeded tests.
			Currently only succeeded sub-expressions are cached,
			and only if they are designated as being cacheable
			(ex.: "C{.expr}=100:{.expr}{$+}{.expr}")

Version history:

	-	2001/12/15
		Implemented current version

	-	2001/12/19
		Labeled 0.2.01

ToDo:
	-	Add support for caching failed sub-expressions.
		Expected speed improvement >50% in complex constellations

	-	Implement an algorithm for automatically determining
		which expressions of the ruleset can be cached efficiently.
		Currently, this has to be done by marking rules explicitly
		as cacheable.

*********************************************************************/

// cxaRuleCache.h: interface for the cxaRuleCache class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_CXARULECACHE_H__E1BFD93D_72A6_4F36_85AA_F6EB72841F23__INCLUDED_)
#define AFX_CXARULECACHE_H__E1BFD93D_72A6_4F36_85AA_F6EB72841F23__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

struct cxaRuleCacheBase : public std::multimap<cxaRuleCacheElement::hashvalue_type,const cxaRuleCacheElement*>  {};

class cxaRuleCache : public cxaRuleCacheBase
{
public:
//	cxaRuleCache();
	virtual ~cxaRuleCache()
		{ clear(); };

public:
	void			clear()
		{
		iterator it; for(it=begin();it!=end();it++) delete it->second;
		cxaRuleCacheBase::clear();
		};

	const cxaRuleCacheElement* find(int nIDValue, int nAtmTypeFirst, const cxaToken* patFirstToken, cxaTokenStream::const_iterator start) const
		{
		cxaRuleCacheElement	arcEl(nIDValue, nAtmTypeFirst,patFirstToken,false,start,start);
		const_iterator it = cxaRuleCacheBase::find(arcEl.hvGetHashValue());
		for(;it!=end() && it->first==arcEl.hvGetHashValue();it++)
			if( *it->second==arcEl )
				return it->second;
		return NULL;
		}
};

#endif // !defined(AFX_CXARULECACHE_H__E1BFD93D_72A6_4F36_85AA_F6EB72841F23__INCLUDED_)