Hosting courtesy of Sourceforge

               

---

ListParser.h

Go to the documentation of this file.

//
//      Copyright (C) 2002 Robert Renaud
//
//      This program is free software; you can redistribute it and/or
//      modify it under the terms of the GNU General Public License
//      as published by the Free Software Foundation; either version 2
//      of the License, or (at your option) any later version.
//
//      This program is distributed in the hope that it will be useful,
//      but WITHOUT ANY WARRANTY; without even the implied warranty of
//      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
//
//      See the GNU General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program; if not, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef LIST_PARSER_H_
#define LIST_PARSER_H_

#include "../Config.h"

#include <list>
#include <vector>

#include "ParseDebug.h"
#include "ParseAction.h"
#include "Parse.h"

using namespace std;

namespace Parse {
        
        class Parseable {
        public:
                virtual Parser* makeParserToParseMe(istream &inputFile)=0;
                virtual ~Parseable() { }
        };
        
        template <class T>      class ParserGenerator {
        public:
                virtual Parser* generateParser(istream &inputFile, T& item)=0;
                virtual ~ParserGenerator() { }
        };


        template <class Base, class Derived> class NaturalParser : public ParseAction {
        public:
                NaturalParser(Base*& pointerRef) :
                        containerPtr(pointerRef)
                { }
                
                void getValue(std::istream& in) {
                        containerPtr = new Derived();
                        Parser* p = containerPtr->makeParserToParseMe(in);
                        p->read();
                        delete p;
                }                                       
        private:
                Base*& containerPtr;
        };
        template <class Base> class ListParser : public ParseAction {
        public:
                ListParser(list<Base*> & listToAddTo) :
                  listOfBaseptr(listToAddTo) { }

        protected:
                /* reference to external list of Base* passed to it, used in ctor */
                list<Base*>& listOfBaseptr;
        }; // class ListParser

        template <class Base> class GeneratedListParser : public ListParser<Base> {
        public:
                GeneratedListParser(list<Base*>& listToAddTo, ParserGenerator<Base>* dynPtrParseGen)
                        :         ListParser<Base>(listToAddTo),
                        pg(dynPtrParseGen)
                {   }

                virtual void getValue(istream& input) {
                        Base* basePtr = new Base();
                        Parser* p= pg->generateParser(input, *basePtr);
                        p->read();
                        listOfBaseptr.push_back(basePtr);
                        delete p;
                }

                virtual ~GeneratedListParser() {
                        delete pg;
                }
        protected:
                ParserGenerator<Base>* pg;
        }; // class GeneratedListParser<T>

        template <class Base> class NaturalListParser : public ListParser<Base> {
        public:
                NaturalListParser(list<Base*>& listToAddTo) :
                  ListParser<Base>(listToAddTo)   { }
                  
                  virtual void getValue(istream& input) {
                          Base* basePtr = new Base();
                          Parser* p = basePtr->makeParserToParseMe(input);      
                          p->read();
                          listOfBaseptr.push_back(basePtr);
                          delete p;
                  }
        }; // class GeneratedListParser<T>
        
        template <class Base> class VectorParser : public ParseAction {
        public:
                VectorParser(vector<Base*> & vectorToAddTo) :
                  vectorOfBaseptr(vectorToAddTo) { }
                  
        protected:              
                /* reference to external vector of T* passed to it, used in ctor */
                vector<Base*>& vectorOfBaseptr;
        }; // class VectorParser
        
        
        template <class Base, class Derived = Base> class NaturalVectorParser : public VectorParser<Base> {
        public:
                NaturalVectorParser(vector<Base*>& vectorToAddTo) :
                  VectorParser<Base>(vectorToAddTo)   { }
                  
                virtual void getValue(istream& input) {
                        Base* basePtr = new Derived;
                        Parser* p = basePtr->makeParserToParseMe(input);                                

                        size_t index;
                        bool indexWasRead=false;
                        p->addAction("index", new ReadAndCheck<size_t>(index, indexWasRead));

                        p->read();

                        if (indexWasRead) {
                                if (index >= vectorOfBaseptr.size()) vectorOfBaseptr.resize(index+1, NULL);
                                vectorOfBaseptr[index] = basePtr;
                        } else {
                                vectorOfBaseptr.push_back(basePtr);
                        }
                          
                        delete p;
                }
        }; // class GeneratedListParser<Base, Derived>  
        
        template <class Base, class Derived=Base> class GeneratedVectorParser : public VectorParser<Base> {
        public:
                GeneratedVectorParser(vector<Base*>& vectorToAddTo, ParserGenerator<Derived>* dynPtrParseGen)
                        :         VectorParser<Base>(vectorToAddTo),    
                        pg(dynPtrParseGen)
                {   }
                
                virtual void getValue(istream& input) {
                        Derived* derivedPtr = new Derived();
                        Parser* p= pg->generateParser(input, *derivedPtr);
                        int index;
                        bool indexWasRead=false;
                        p->addAction("index", new ReadAndCheck<int>(index, indexWasRead));
                        p->read();
                        if (indexWasRead) {
                                vectorOfBaseptr[index] = derivedPtr;
                        } else {
                                vectorOfBaseptr.push_back(derivedPtr);
                        }
                        delete p;
                }       
                
                ~GeneratedVectorParser() {
                        delete pg;
                }
        protected:
                ParserGenerator<Derived>* pg;
        }; // class GeneratedVectorParser

        
}; // namespace Parse

#endif // ifndef LIST_PARSER_H_

---