Subversion Repositories DevTools

//## begin module%1.7%.codegen_version preserve=yes

//   Read the documentation to learn more about C++ code generator

//   versioning.

//## end module%1.7%.codegen_version

//## begin module%420AC16002C1.cm preserve=no

//## end module%420AC16002C1.cm

//## begin module%420AC16002C1.cp preserve=no

//	C O P Y R I G H T   N O T I C E

//	This material is confidential to ERG and may not be disclosed in whole

//	or in part to any third party nor used in any manner whatsoever other

//	than for the purposes expressly consented to by ERG in writing.

//

//	This material is also copyright and may not be reproduced, stored in a

//	retrieval system or transmitted in any form or by any means in whole or

//	in part without the express written consent of ERG.

//## end module%420AC16002C1.cp

//## Module: FieldExpression%420AC16002C1; Pseudo Package specification

//## Subsystem: MASS::Dev::Tools::TxnTestManager::src%41F5A79001E4

//## Source file: Z:\MASS_Dev\Tools\TxnTestManager\src\FieldExpression.h

#ifndef FieldExpression_h

#define FieldExpression_h 1

//## begin module%420AC16002C1.additionalIncludes preserve=no

//## end module%420AC16002C1.additionalIncludes

//## begin module%420AC16002C1.includes preserve=yes

//## end module%420AC16002C1.includes

class TransactionSpecification;

class EvaluationContext;

class DefinedVariable;

class DefinedVariableTable;

//## begin module%420AC16002C1.additionalDeclarations preserve=yes

#include <vector>

//## end module%420AC16002C1.additionalDeclarations

//## begin FieldExpression%420AC16002C1.preface preserve=yes

//## end FieldExpression%420AC16002C1.preface

//## Class: FieldExpression%420AC16002C1; private

//	A class for representing expressions.

//## Category: TransactionTestManager::Symbol Table%4209C5C30033

//## Subsystem: MASS::Dev::Tools::TxnTestManager::src%41F5A79001E4

//## Persistence: Transient

//## Cardinality/Multiplicity: n

//## Uses: <unnamed>%420AC4EA00CD;TransactionSpecification { -> F}

//## Uses: <unnamed>%420AD933029C;DefinedVariableTable { -> F}

//## Uses: <unnamed>%420AE38300AF;DefinedVariable { -> F}

//## Uses: <unnamed>%421176AC0366;EvaluationContext { -> F}

//## Uses: <unnamed>%421177FE00AB;Sequence { -> }

//## Uses: <unnamed>%42117819031C;SequenceCollection { -> }

//## Uses: <unnamed>%4211D98E031E;IMessageDigest { -> }

//## Uses: <unnamed>%42130E850275;XMLSchema::IXmlSchemaWrapperElement { -> }

class FieldExpression 

{

  //## begin FieldExpression%420AC16002C1.initialDeclarations preserve=yes

  //## end FieldExpression%420AC16002C1.initialDeclarations

  public:

    //## Constructors (generated)

      FieldExpression();

    //## Constructors (specified)

      //## Operation: FieldExpression%42105AAC0084

      //	A constructor that takes an expression.

      FieldExpression (const std::string &expression	// The expression.

      );

    //## Destructor (generated)

      virtual ~FieldExpression();

    //## Other Operations (specified)

      //## Operation: evaluate%420456630303

      //	Evaluate the expression of this field, and evaluate to true, or to false

      //	when any expression cannot be evaluated.

      const bool evaluate (std::string &value, 	// The resulting value.

      const bool &sideEffect, 	// When true, evaluation is allowed to have side effects, otherwise side

      	// effects must be suppressed.  For example, when true, a call to a sequence

      	// generator may allocate a new number from the sequence: when false, the call

      	// must not change the sate of the sequence generator.

      	// 

      	// One usage of this: when generating a transaction side effects are allowed,

      	// when rendering the hint to display for a field value side effects are not

      	// allowed.

      EvaluationContext& evaluationContext, 	// The evaluation context.

      std::vector< DefinedVariable * > &path, 	// The evaluation path.

      bool &postponed	// Set the actual argument to true when evaluation is postponed, and to false

      	// otherwise.

      );

      //## Operation: getExpression%420AC68F02E4

      //	Evaluate to the expression of this instance.

      const std::string & getExpression () const;

      //## Operation: isFunctor%4209B773036F

      //	Evaluate to true when the given string is a functor, and to false when it is

      //	not.

      static const bool isFunctor (const std::string &string	// The string.

      );

      //## Operation: setExpression%420AC68F02F3

      //	Set the expression of this instance, and evaluate to the resulting value.

      const std::string & setExpression (const std::string &value	// The value.

      );

    // Additional Public Declarations

      //## begin FieldExpression%420AC16002C1.public preserve=yes

      //## end FieldExpression%420AC16002C1.public

  protected:

    // Additional Protected Declarations

      //## begin FieldExpression%420AC16002C1.protected preserve=yes

      //## end FieldExpression%420AC16002C1.protected

  private:

    //## Constructors (generated)

      FieldExpression(const FieldExpression &right);

    //## Assignment Operation (generated)

      FieldExpression & operator=(const FieldExpression &right);

    //## Other Operations (specified)

      //## Operation: evaluateFunction%4208AE9D0216

      //	Evaluate the given function.

      const bool evaluateFunction (std::istream &is, 	// The input stream.

      std::string &value, 	// The resulting value.

      std::string &symbol, 	// The variable.

      const bool &sideEffect, 	// When true, evaluation is allowed to have side effects, otherwise side

      	// effects must be suppressed.  For example, when true, a call to a sequence

      	// generator may allocate a new number from the sequence: when false, the call

      	// must not change the sate of the sequence generator.

      	// 

      	// One usage of this: when generating a transaction side effects are allowed,

      	// when rendering the hint to display for a field value side effects are not

      	// allowed.

      EvaluationContext& evaluationContext, 	// The evaluation context.

      std::vector< DefinedVariable * > &path, 	// The evaluation path.

      bool &postponed	// Set the actual argument to true when evaluation is postponed, and to false

      	// otherwise.

      );

      //## Operation: evaluateVariable%420AE22101D7

      //	Evaluate the given variable.

      const bool evaluateVariable (std::istream &is, 	// The input stream.

      std::string &value, 	// The resulting value.

      std::string &symbol, 	// The variable.

      const bool &sideEffect, 	// When true, evaluation is allowed to have side effects, otherwise side

      	// effects must be suppressed.  For example, when true, a call to a sequence

      	// generator may allocate a new number from the sequence: when false, the call

      	// must not change the sate of the sequence generator.

      	// 

      	// One usage of this: when generating a transaction side effects are allowed,

      	// when rendering the hint to display for a field value side effects are not

      	// allowed.

      EvaluationContext& evaluationContext, 	// The evaluation context.

      std::vector< DefinedVariable * > &path, 	// The evaluation path.

      bool &postponed	// Set the actual argument to true when evaluation is postponed, and to false

      	// otherwise.

      );

      //## Operation: readIdentifier%42102FB70219

      //	Read an identifier from the input stream and evaluate to true, or to false

      //	when an identifier cannot be read.

      static const bool readIdentifier (std::istream &is, 	// The input stream.

      std::string &identifier	// The identifier.

      );

      //## Operation: readTerm%420B0EB603D2

      //	Read a term from the input stream and evaluate to true, or to false when a

      //	term cannot be read.

      static const bool readTerm (std::istream &is, 	// The input stream.

      std::string &term	// The term.

      );

      //## Operation: skipCharacter%420B100701E7

      //	Skip the given character from the input stream and evaluate to true, or to

      //	false when the given character is not found next in the input stream.

      static const bool skipCharacter (std::istream &is, 	// The input stream.

      const char &character	// The character.

      );

    // Data Members for Class Attributes

      //## Attribute: cachedValue%420B24A402FC

      //	The evaluated value of this expression.  We can cache some expressions

      //	because their value is deterministic, so we do to speed up generation.

      //## begin FieldExpression::cachedValue%420B24A402FC.attr preserve=no  private: std::string {VA} 

      std::string m_cachedValue;

      //## end FieldExpression::cachedValue%420B24A402FC.attr

      //## Attribute: expression%420AC5F30189

      //	The expression.

      //## begin FieldExpression::expression%420AC5F30189.attr preserve=no  private: std::string {VA} 

      std::string m_expression;

      //## end FieldExpression::expression%420AC5F30189.attr

    // Additional Private Declarations

      //## begin FieldExpression%420AC16002C1.private preserve=yes

      //## end FieldExpression%420AC16002C1.private

  private: //## implementation

    // Additional Implementation Declarations

      //## begin FieldExpression%420AC16002C1.implementation preserve=yes

      //## end FieldExpression%420AC16002C1.implementation

};

//## begin FieldExpression%420AC16002C1.postscript preserve=yes

//## end FieldExpression%420AC16002C1.postscript

// Class FieldExpression 

//## begin module%420AC16002C1.epilog preserve=yes

//## end module%420AC16002C1.epilog

#endif