form.hpp

Go to the documentation of this file.

 
#ifndef Om_Language_Form_
 
    #define Om_Language_Form_ \
    Om::Language::Form
 
    #include "om/language/operator.hpp"
    #include "om/source/collection_front_source.hpp"
 
namespace Om {
 
    namespace Language {
 
        // MARK: - Om::Language::Form
 
        class Form {
 
        public: // MARK: public (static)
 
            class ElementRange;
 
            template <typename ThisOperand>
            class OperandRange;
 
        public: // MARK: public (non-static)
 
            Form();
 
            bool BackGiveTerm(Consumer &);
 
            bool BackPopTerm();
 
            template <typename TheOperand>
            void BackTakeOperand(TheOperand &);
 
            template <typename TheProducer>
            void BackTakeQuotedProducer(TheProducer &);
 
            bool FrontGiveTerm(Consumer &);
 
            bool FrontPopTerm();
 
            template <typename TheOperand>
            void FrontTakeOperand(TheOperand &);
 
            template <typename TheProducer>
            void FrontTakeQuotedProducer(TheProducer &);
 
            Operator const & GetOperator() const;
 
            void GiveElements(Consumer &);
 
            void GiveElements(Consumer &) const;
 
            bool IsEmpty() const;
 
            void Swap(Form &);
 
            template <typename TheOperator>
            void TakeOperator(TheOperator &);
 
        private: // MARK: private (static)
 
            typedef std::deque<Operand> OperandDeque;
 
            template <
                typename TheOperandIterator,
                typename TheForm
            >
            static void GiveElements(
                TheForm &,
                Consumer &
            );
 
        private: // MARK: private (non-static)
 
            Operator thisOperator;
 
            OperandDeque thisOperandDeque;
 
        };
 
        // MARK: - Om::Language::Form::ElementRange
 
        class Form::ElementRange:
        public Om::Source::DefaultSource<
            Element const,
            ElementRange
        > {
 
        public: // MARK: public (non-static)
 
            explicit ElementRange(Form 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)
 
            OperandDeque::const_iterator thisOperandIterator;
 
            OperandDeque::const_iterator thisOperandEnd;
 
            Element const * thisElement;
 
        };
 
        // MARK: - Om::Language::
 
        bool operator ==(
            Form::ElementRange const &,
            Form::ElementRange const &
        );
 
        bool operator !=(
            Form::ElementRange const &,
            Form::ElementRange const &
        );
 
        // MARK: - Om::Language::Form::OperandRange<Operand>
 
        template <>
        class Form::OperandRange<Operand>:
        public Om::Source::CollectionFrontSource<
            Operand,
            OperandDeque::iterator
        > {
 
        public: // MARK: public (non-static)
 
            explicit OperandRange(Form &);
 
        };
 
        // MARK: - Om::Language::Form::OperandRange<Operand const>
 
        template <>
        class Form::OperandRange<Operand const>:
        public Om::Source::CollectionFrontSource<
            Operand const,
            OperandDeque::const_iterator
        > {
 
        public: // MARK: public (non-static)
 
            explicit OperandRange(Form const &);
 
        };
 
    }
 
}
 
namespace boost {
 
    // MARK: - boost::
 
    template <>
    void swap(
        Om::Language::Form &,
        Om::Language::Form &
    );
 
}
 
    #include "om/language/form.cpp"
 
#endif