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:      cxaRuleCacheElement
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 data on failed sub-expressions.

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

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

#if !defined(AFX_CXARULECACHEELEMENT_H__3F3485A3_C0E8_4066_A382_DA59EC815587__INCLUDED_)
#define AFX_CXARULECACHEELEMENT_H__3F3485A3_C0E8_4066_A382_DA59EC815587__INCLUDED_

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

class cxaRuleCacheElement  
{
public:
	cxaRuleCacheElement(int _nRuleIDValue, int _nAtmTypeFirst, const cxaToken* _patFirstToken,
						bool fCheckFirstIs,
						cxaTokenStream::const_iterator _start,
						cxaTokenStream::const_iterator _end);
	virtual ~cxaRuleCacheElement();

// Typedefs
public:
	typedef unsigned long			hashvalue_type;

// Attributes
protected:
	bool							fCheckFirstIs;
	int								nRuleIDValue;
	int								nAtmTypeFirst;
	const cxaToken*					patFirstToken;
	cxaTokenStream::const_iterator	start;
	cxaTokenStream::const_iterator	end;
	cxAnalyzerTree::log_vec_type	data;
	hashvalue_type					hashValue;

// Operations
public:
	bool							fIsCheckFirstIs() const { return fCheckFirstIs; };
	int								nGetRuleIDValue() const { return nRuleIDValue; };
	hashvalue_type					hvGetHashValue() const { return hashValue; };
	void							vSetContents(
										const cxAnalyzerTree* patTree,
										cxAnalyzerTree::chkpoint_type cpStart,
										cxAnalyzerTree::chkpoint_type cpEnd);
	void							vUnloadTo(
										cxAnalyzerTree* patTree,
										cxaTokenStream::const_iterator& end) const;

	bool							operator==(
										const cxaRuleCacheElement& other) const
										{
										if(nRuleIDValue!=other.nRuleIDValue)
											return false;
										if(nAtmTypeFirst!=other.nAtmTypeFirst)
											return false;
										if(patFirstToken!=other.patFirstToken)
											return false;
										if(start!=other.start)
											return false;
										return true;
										}
};

#endif // !defined(AFX_CXARULECACHEELEMENT_H__3F3485A3_C0E8_4066_A382_DA59EC815587__INCLUDED_)