importerbase.h

#ifndef __FDL_IMPORTER_BASE_H
#define __FDL_IMPORTER_BASE_H

#include <string>
#include <set>
#include <exception>
#include <iostream>

//#define TIXML_USE_STL
#include "tinyxml.h"

#include "cg/vecmath/vec3.hpp"
#include "core/common.h"
#include "core/scalars.hpp"

namespace fdl {
        
/*
struct Output {
        std::string format;
        std::string filePrefix;
        std::string filePath;
        
        inline Output(const std::string fmt="", const std::string pre="", const std::string path="")
                : format(fmt), filePrefix(pre), filePath(path) {}
        
};
*/

class ImporterBase {
public:
        ImporterBase();
        ~ImporterBase();
    virtual int load(const std::string& filename);
    virtual int save(const std::string& filename);

        int getLoggerLevel() { return m_logLevel; }
        int getGridWidth() { return m_width; }
        int getGridHeight() { return m_height; }
        int getGridDepth() { return m_depth; }
        int getSolverType() { return m_solverType; }
        int getSolverMaxIterations() { return m_solverMaxIterations; }
        int useGlutWindow() { return m_useGlutWindow; }
        int getGlutWindowWidth() { return m_glutWindowWidth; }
        int getGlutWindowHeight() { return m_glutWindowHeight; }
        double getTimeStep() { return m_timeStep; }
        double getGridCellSize() { return m_gridCellSize; }
        double getSolverTolerance() { return m_solverTolerance; }
        double getDefaultDensity() { return m_defaultDensity; }
        double getDefaultSourceTemperature() { return m_defaultSourceTemperature; }
        double getDefaultSolidTemperature() { return m_defaultSolidTemperature; }
        std::vector<cg::vecmath::Vector3>& getForces() { return *m_forces; }
        std::vector<fdl::ScalarBase<double> >& getSources() { return *m_sources; }

protected:
        int m_logLevel;
        int m_width;
        int m_height;
        int m_depth;
        int m_glutWindowWidth;
        int m_glutWindowHeight;
        bool m_useGlutWindow;
        int m_solverMaxIterations;
        double m_solverTolerance;
        double m_timeStep;
        double m_gridCellSize;
        int m_solverType;
        double m_defaultDensity;
        double m_defaultSourceTemperature;
        double m_defaultSolidTemperature;
        bool m_vorticityConfinement;
        //std::vector<Output>* m_outputs;
        std::vector<fdl::ScalarBase<double> >* m_sources;
        std::vector<cg::vecmath::Vector3>* m_forces;
        
        int intFromChars(const char* word);
        int intFromStr(std::string node);
        double doubleFromChars(const char* word);
        
        void parseSettings(TiXmlElement* ele);
        void parseLogger(TiXmlElement* ele);
        void parseForces(TiXmlElement* ele);
        void parseSources(TiXmlElement* ele);
};

}       // namespace fdl

#endif  // __FDL_IMPORTER_BASE_H