evaluator.hpp

Go to the documentation of this file.

 
#ifndef Om_Language_Evaluator_
 
    #define Om_Language_Evaluator_ \
    Om::Language::Evaluator
 
    #include "om/language/default_consumer.hpp"
    #include "om/language/producer.hpp"
 
    #ifndef Om_Macro_Precompilation_
 
        #include "boost/ptr_container/ptr_vector.hpp"
 
    #endif
 
namespace Om {
 
    namespace Language {
 
        class Evaluation;
 
        namespace Operation {
 
            class IncompleteOperation;
 
        }
 
        class Translator;
 
        // MARK: - Om::Language::Evaluator
 
        class Evaluator:
        public DefaultConsumer<Evaluator>,
        public Producer {
 
        public: // MARK: public (non-static)
 
            virtual ~Evaluator();
 
            explicit Evaluator(
                Consumer & theOutput,
                Translator const & theTranslator
            );
 
            virtual void Clear();
 
            Translator const & GetTranslator() const;
 
            virtual void GiveElements(Consumer &);
 
            virtual void GiveElements(Consumer &) const;
 
            virtual std::auto_ptr<Program> GiveProgram();
 
            virtual std::auto_ptr<Program> GiveProgram() const;
 
            virtual bool IsEmpty() const;
 
            virtual void ParseElements(Reader &);
 
            virtual void ParseQuotedElements(Reader &);
 
            void ParseQuotedElements(
                Evaluation &,
                Reader &
            );
 
            template <typename TheOperand>
            void TakeOperand(TheOperand &);
 
            template <typename TheOperand>
            void TakeOperand(
                Evaluation &,
                TheOperand &
            );
 
            template <typename TheOperation>
            void TakeOperation(
                std::auto_ptr<TheOperation>
            );
 
            template <typename TheOperator>
            void TakeOperator(TheOperator &);
 
            template <typename TheOperator>
            void TakeOperator(
                Evaluation &,
                TheOperator &
            );
 
            template <typename TheProducer>
            void TakeQuotedProducer(TheProducer &);
 
            template <typename TheProducer>
            void TakeQuotedProducer(
                Evaluation &,
                TheProducer &
            );
 
            template <typename TheSeparator>
            void TakeSeparator(TheSeparator &);
 
        private: // MARK: private (static)
 
            typedef boost::ptr_vector<Operation::IncompleteOperation> IncompleteOperationVector;
 
            template <typename TheIterator>
            static void GiveElements(
                TheIterator,
                TheIterator const,
                Consumer &
            );
 
            template <typename TheEvaluator>
            static std::auto_ptr<Program> GiveProgram(TheEvaluator &);
 
        private: // MARK: private (non-static)
 
            Evaluator(Evaluator const &);
 
            Evaluator const & operator =(Evaluator const &);
 
            void Evaluate(Evaluation &);
 
            Consumer & thisOutput;
 
            Translator const & thisTranslator;
 
            IncompleteOperationVector thisIncompleteOperationVector;
 
            bool thisGaveElementToOutput;
 
        };
 
    }
 
}
 
    #include "om/language/evaluator.cpp"
 
#endif