literal.hpp

Go to the documentation of this file.

 
#ifndef Om_Language_Literal_
 
    #define Om_Language_Literal_ \
    Om::Language::Literal
 
    #include "om/language/default_program.hpp"
    #include "om/source/collection_front_source.hpp"
 
    #ifndef Om_Macro_Precompilation_
 
        #include "boost/ptr_container/ptr_deque.hpp"
        #include "boost/swap.hpp"
 
    #endif
 
    #define Om_Language_Literal_GetName_() \
    "literal"
 
namespace Om {
 
    namespace Language {
 
        // MARK: - Om::Language::Literal
 
        class Literal:
        public DefaultProgram<Literal> {
 
        public: // MARK: public (static)
 
            template <typename ThisLiteral>
            class ElementRange;
 
            static char const * GetName();
 
        public: // MARK: public (non-static)
 
            virtual ~Literal();
 
            Literal();
 
            Literal & operator =(Literal);
 
            template <typename TheElement>
            void BackGive(Consumer &);
 
            void BackGiveElement(Consumer &);
 
            virtual void Clear();
 
            template <typename TheElement>
            void FrontGive(Consumer &);
 
            void FrontGiveElement(Consumer &);
 
            std::auto_ptr<
                Om::Source::Source<Element>
            > GetElementRange();
 
            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(Literal &);
 
            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 boost::ptr_deque<Element> ElementDeque;
 
            template <typename TheElementIterator>
            static void GiveElements(
                Consumer & theConsumer,
                TheElementIterator theCurrent,
                TheElementIterator const theEnd
            );
 
        private: // MARK: private (non-static)
 
            template <typename TheAtom>
            void TakeAtom(TheAtom &);
 
            ElementDeque thisElementDeque;
 
        };
 
        // MARK: - Om::Language::Literal::ElementRange<Literal>
 
        template <>
        class Literal::ElementRange<Literal>:
        public Om::Source::CollectionFrontSource<
            Element,
            ElementDeque::iterator
        > {
 
        public: // MARK: public (non-static)
 
            explicit ElementRange(Literal &);
 
        };
 
        // MARK: - Om::Language::Literal::ElementRange<Literal const>
 
        template <>
        class Literal::ElementRange<Literal const>:
        public Om::Source::CollectionFrontSource<
            Element const,
            ElementDeque::const_iterator
        > {
 
        public: // MARK: public (non-static)
 
            explicit ElementRange(Literal const &);
 
        };
 
    }
 
}
 
namespace boost {
 
    // MARK: - boost::
 
    template <>
    void swap(
        Om::Language::Literal &,
        Om::Language::Literal &
    );
 
}
 
    #include "om/language/literal.cpp"
 
#endif