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>
#include <string>
//## 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 { -> }
//## Uses: <unnamed>%422EB8C202B5;ICryptographicServerProxy { -> }

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