OpenPaperOpt/XMLParser.h

Go to the documentation of this file.

#ifndef XMLPARSER_H
#define XMLPARSER_H

// INCLUDES
#include <exception>
#include <string>
#include <stack>
#include <vector>
#include <map>
#include <fstream>
#include <sstream>
#include <complex>

#include "Array2D.h"
#include "irrXML.h"
#include "Fluorescence.h"
#include "Distribution.h"
#include "DistributionTable.h"
#include "DistributionElliptic.h"
#include "DistributionConstant.h"
#include "DistributionComponents.h"
#include "ScatteringParameters.h"
#ifdef ENABLEHDF
#include "hdf5.h"
#include "h5cpp.h"
#endif

using namespace irr;
using namespace io;
using namespace std;
using namespace Distributions;


//Global variables defined in Input.cpp
extern std::string gBinaryDirectory;
extern bool gIsBigendian;

namespace IO{
        //Forward declarations.
        class File;
        class BinaryFile;
        class TextFile;

#ifdef ENABLEHDF
        class HDFFile;
#endif

        class XMLParser
        {

        public:
                XMLParser();

                ~XMLParser();

                void init(string xmlFile);

                bool readNextTag();

                string getNextText(void);


                string getElementName();

                void pushEndTag(string s){mTagStack.push(s);};

                void popEndTag(){mTagStack.pop();};

                string getAttribute(string s);

                float getAttributeAsFloat(string s);

                int getAttributeAsInt(string s);

                bool isCurElement(char* elm);

                Array2D<float>* parseFloatArray();

                Array2D<float>* parseHeightMap(float& sizeX, float& sizeY);

                Array2D< V2<float> >* parseV2FloatArray();


                Array2D< V3<float> >* parseV3FloatArray();


                int parseFloatList(vector<float> &list);

                float parseFloat();

                int parseInt();

                bool parseBool();


                string parseString();

                Distribution* parseDistribution();

                DistributionTable* parseTableDistribution();

                DistributionElliptic* parseEllipticDistribution();

                DistributionConstant* parseConstantDistribution();

                DistributionComponents* parseComponentsDistribution();

                ScatteringParameters* parseScatteringProperties(vector<float>& rLambda);

                Fluorescence* parseFluorescence(vector<float>& rLambda);


                reflectanceParameters* parseReflectance(vector<float>& rLambda);


                XMLParser::BinaryFile* parseBinaryFile();

                XMLParser::TextFile* parseTextFile();   

#ifdef ENABLEHDF

                XMLParser::HDFFile* parseHDFFile();
#endif
                
        private:
                IrrXMLReader* mIrrXMLReader;
                bool mInitialized;
                stack<string> mTagStack;
        };



        class File{
        public:
                File(void);
                virtual double readDouble() = 0;
                virtual float readFloat() = 0;
                virtual int readInt() = 0;
                virtual bool eof() = 0;
        };

        class BinaryFile: public File{
        public:

                BinaryFile(const string& rFilename, int offset, bool isBigEndian);                              
                ~BinaryFile();
                double readDouble(void);
                float readFloat(void);
                int readInt (void);
                bool eof();
        private:
                double (*readDoublePtr) (fstream& _mfile);
                float (*readFloatPtr)(fstream& _mfile);
                int (*readIntPtr) (fstream& _mfile);
                static double readDoubleNoSwap(fstream& _mfile);
                static float readFloatNoSwap(fstream& _mfile);
                static int readIntNoSwap(fstream& _mfile);
                static double readDoubleSwap(fstream& _mfile);
                static float readFloatSwap(fstream& _mfile);
                static int readIntSwap(fstream& _mfile);
                bool mIsBigEndian;
                int mOffset;
                fstream mFile;
        };

        class TextFile: public File{
        public:
                TextFile(const string& rFilename, char delim);                          
                ~TextFile();
                double readDouble();
                float readFloat();
                int readInt();
                bool eof();
        private:
                ifstream mFile;
                char mDelim;
        };

#ifdef ENABLEHDF

        class HDFFile: public File{
        public:
                HDFFile(H5::H5File* pFile,const string& rDataset, const string& rGroup);                                
                ~HDFFile();
                
                double readDouble();
                float readFloat();
                int readInt();
                bool eof();

                H5::DataSpace* getDataSpace();
        private:
                char* mBuf;   //Whole dataset is read into this buffer in constructor.
                long mOffset;  //keeps track of which byte to read from.
                long mSize;   //Size in bytes of data.
                H5::DataSet mDataset;
                H5::Group mGroup;
                H5::H5File* mFile;
        };
#endif
}
#endif //XMLPARSER