expression.hpp

Go to the documentation of this file.

 
#ifndef Om_Language_Expression_
 
    #define Om_Language_Expression_ \
    Om::Language::Expression
 
    #include "om/language/form.hpp"
 
    #ifndef Om_Macro_Precompilation_
 
        #include "boost/optional.hpp"
 
    #endif
 
    #define Om_Language_Expression_GetName_() \
    "expression"
 
namespace Om {
 
    namespace Language {
 
        // MARK: - Om::Language::Expression
 
        class Expression:
        public DefaultProgram<Expression> {
 
        public: // MARK: public (static)
 
            class ElementRange;
 
            template <typename ThisForm>
            class FormRange;
 
            static char const * GetName();
 
        public: // MARK: public (non-static)
 
            Expression();
 
            Expression & operator =(Expression);
 
            void BackGiveForm(Consumer &);
 
            void BackGiveTerm(Consumer &);
 
            void BackPopTerm();
 
            template <typename TheOperand>
            void BackTakeOperand(TheOperand &);
 
            template <typename TheOperator>
            void BackTakeOperator(TheOperator &);
 
            template <typename TheProducer>
            void BackTakeQuotedProducer(TheProducer &);
 
            virtual void Clear();
 
            void FrontGiveForm(Consumer &);
 
            void FrontGiveTerm(Consumer &);
 
            void FrontPopTerm();
 
            template <typename TheOperand>
            void FrontTakeOperand(TheOperand &);
 
            template <typename TheOperator>
            void FrontTakeOperator(TheOperator &);
 
            template <typename TheProducer>
            void FrontTakeQuotedProducer(TheProducer &);
 
            virtual std::auto_ptr<
                Om::Source::Source<Element const>
            > GetElementRange() const;
 
            virtual void GiveElements(Consumer &);
 
            virtual void GiveElements(Consumer &) const;
 
            virtual bool IsEmpty() const;
 
            virtual void ParseElements(Reader &);
 
            virtual void ParseQuotedElements(Reader &);
 
            void Swap(Expression &);
 
            void TakeElements(Expression &);
 
            void TakeElements(Expression const &);
 
            virtual void TakeElements(Producer &);
 
            virtual void TakeElements(Producer const &);
 
            template <typename TheOperand>
            void TakeOperand(TheOperand &);
 
            template <typename TheOperator>
            void TakeOperator(TheOperator &);
 
            template <typename TheProducer>
            void TakeQuotedProducer(TheProducer &);
 
            template <typename TheSeparator>
            void TakeSeparator(TheSeparator &);
 
        private: // MARK: private (static)
 
            typedef std::deque<Form> FormDeque;
 
            template <typename TheFormIterator>
            static void GiveElements(
                Consumer & theConsumer,
                TheFormIterator theCurrent,
                TheFormIterator const theEnd
            );
 
        private: // MARK: private (non-static)
 
            Form & GetBackTaker();
 
            Form & GetFrontTaker();
 
            FormDeque thisFormDeque;
 
        };
 
        // MARK: - Om::Language::Expression::FormRange<Form>
 
        template <>
        class Expression::FormRange<Form>:
        public Om::Source::CollectionFrontSource<
            Form,
            FormDeque::iterator
        > {
 
        public: // MARK: public (non-static)
 
            explicit FormRange(Expression &);
 
        };
 
        // MARK: - Om::Language::Expression::FormRange<Form const>
 
        template <>
        class Expression::FormRange<Form const>:
        public Om::Source::CollectionFrontSource<
            Form const,
            FormDeque::const_iterator
        > {
 
        public: // MARK: public (non-static)
 
            explicit FormRange(Expression const &);
 
        };
 
        // MARK: - Om::Language::Expression::ElementRange
 
        class Expression::ElementRange:
        public Om::Source::DefaultSource<
            Element const,
            ElementRange
        > {
 
        public: // MARK: public (non-static)
 
            explicit ElementRange(Expression const &);
 
            virtual bool operator !() const;
 
            virtual Element const & operator *() const;
 
            using Om::Source::DefaultSource<
                Element const,
                ElementRange
            >::Equals;
 
            bool Equals(ElementRange const &) const;
 
            void End();
 
            virtual void Pop();
 
        private: // MARK: private (non-static)
 
            FormDeque::const_iterator thisFormIterator;
 
            FormDeque::const_iterator thisFormEnd;
 
            boost::optional<Form::ElementRange> thisFormElementRange;
 
        };
 
        // MARK: - Om::Language::
 
        bool operator ==(
            Expression::ElementRange const &,
            Expression::ElementRange const &
        );
 
        bool operator !=(
            Expression::ElementRange const &,
            Expression::ElementRange const &
        );
 
    }
 
}
 
namespace boost {
 
    // MARK: - boost::
 
    template <>
    void swap(
        Om::Language::Expression &,
        Om::Language::Expression &
    );
 
}
 
    #include "om/language/expression.cpp"
 
#endif