SXParser.h

#ifndef _SX_SXPARSER_H_
#define _SX_SXPARSER_H_

#include <export/Export.h>
#include <string>
#include <map>
#include <vector>
#include <sx/SXMath.h>
using namespace std;

namespace sx {

    namespace parserInternal {

        enum _XTYPE_ {
            _XTEXT_ ,
            _XTAG_ ,
            _S_ATTRIB_,
            _R_ATTRIB_
        };

        struct _XNODE_ {

            int type;

            string text;

            string name;
            vector<_XNODE_> nodes;

            string strID;
            string strAttrib;

            string rID;
            double rAttrib;

            string eat;

        };

        struct _XMLNODE_ {

            int type;

            string text;

            string name;
            string endname;
            vector<_XMLNODE_> nodes;
            vector<_XMLNODE_> ats;

            string strID;
            string strAttrib;

            string eat;

        };

        enum _TYPE_ {
            T_CHAR,
            T_UCHAR,
            T_SHORT,
            T_USHORT,
            T_INT,
            T_UINT,
            T_LONG,
            T_ULONG,
            T_FLOAT,
            T_DOUBLE
        };

        enum _MULTIPLICITY_ {
            M_SINGLE,
            M_LIST
        };

        struct _PROPERTY_ {

            string name;

            int multiplicity;

            vector<int> types;

        };

        struct _ELEMENT_ {

            string name;

            unsigned int count;

            vector<_PROPERTY_> properties;

        };

        struct _XMESH_ {
            
            vector<_ELEMENT_> elements;

            vector<vector<double>> data;

        };

        void parseNumbers(const string &numberList, vector<double> &numbers);

        void parseStrings(const string &stringList, vector<string> &strings);

        void parseSXdata1(const string &data, string &output);

        void parseSXdata2(string &filteredIterable, parserInternal::_XNODE_ &output);

        void parseXMLdata(const string &data, parserInternal::_XMLNODE_ &output);

        void parsePLYdata1(const string &data, string &output);

        void parsePLYdata2(string &filteredIterable, parserInternal::_XMESH_ &output);

    }

    EXPA vector<double> parseNumbers(const string &numberList);

    EXPA vector<string> parseStrings(const string &stringList);

    EXPA string readFile(string filename);

    struct XNode {
    private:

        XNode(const XNode &);

        XNode &operator = (const XNode &);

    protected:

        EXPA XNode();

    public:

        EXPA virtual ~XNode();

    };

    struct XText: public XNode {
    private:

        XText(const XText &);

        XText &operator = (const XText &);

    public:

        string text;

        EXPA XText();

        EXPA ~XText();

    };

    struct XTag: public XNode {
    private:

        XTag(const XTag &);

        XTag &operator = (const XTag &);

    public:

        string name;

        map<string,string> stringAttribs;

        map<string,double> realAttribs;

        vector<XNode *> nodes;

        EXPA XTag();

        EXPA ~XTag();

        EXPA void getTags(string location, vector<XTag *> &nodes);

        EXPA XTag *getFirst(string location);

        EXPA XTag *getFirst();

        EXPA string getStrAttribute(string ID);

        EXPA double getRealAttribute(string ID);

        EXPA void getDirectTexts(vector<string> &texts);

        EXPA void getTexts(vector<string> &texts);

        EXPA string getDirectTexts();

        EXPA string getTexts();

        EXPA void flattenTag(XTag &tag, map<string,vector<double>> &ambiguousReals, map<string,vector<string>> &ambiguousStrings);

    };

    EXPA XTag *parseSXdata(const string &data);

    EXPA XTag *parseSXFile(const string path);

    EXPA XTag *parseXMLdata(const string &data);

    EXPA XTag *parseXMLFile(const string path);

    struct XBuffer {
    private:

        XBuffer(const XBuffer &);

        XBuffer &operator = (const XBuffer &);

    public:

        string name;

        unsigned int attributeSize;

        vector<double> vertexAttributes;

        EXPA XBuffer();

        EXPA ~XBuffer();
    };

    struct XMesh {
    private:

        XMesh(const XMesh &);

        XMesh &operator = (const XMesh &);

    public:

        unsigned int faceSize;

        map<string,XBuffer *> buffers;

        EXPA XMesh();

        EXPA ~XMesh();
    };

    EXPA XMesh *parsePLYdata(const string &data);

    EXPA XMesh *parsePLYFile(const string path);

    struct Bone {

        string ID;

        Matrix parentTransform;

        Matrix inverseBindPoseMatrix;

        vector<Bone> bones;

        EXPA Bone(const Bone &);

        EXPA Bone();

    };

    EXPA pair<vector<Bone>,Matrix> parseColladaSkeleton(XTag &collada);

    EXPA pair<vector<Bone>,Matrix> parseColladaSkeleton(const string &data);

    EXPA pair<vector<Bone>,Matrix> parseColladaSkeletonFile(const string &path);

    EXPA XMesh *parseColladaData(XTag &data);

    EXPA XMesh *parseColladaData(const string &data);

    EXPA XMesh *parseColladaFile(const string path);

    class Bitmap {
    private:

        unsigned char *data;

        unsigned int width;

        unsigned int height;

        unsigned int bytesPerPixel;

        Bitmap(const Bitmap &);

        Bitmap &operator = (const Bitmap &);

    public:

        EXPA Bitmap(unsigned int width, unsigned int height);

        EXPA Bitmap(unsigned int width, unsigned int height, unsigned int bytesPerPixel);

        EXPA Bitmap(const string filename);

        EXPA ~Bitmap();

        EXPA void save(const string filename);

        EXPA unsigned int getWidth() const;

        EXPA unsigned int getHeight() const;

        EXPA unsigned int getPixelSize() const;

        EXPA unsigned char *getData();

    };

}

#endif