XMLBinaryFile.hpp

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#ifndef _XMLBinaryFile_hpp
#define _XMLBinaryFile_hpp

//  #ifndef _Image3D_hpp
//  #error "FileParser_hpp must be included from _Image3D_hpp"
//  #endif // _Image3D_hpp

#include <stdio.h>
#include<ImLib3D/XMLTools.hpp>
#include<ImLib3D/CppTools.hpp>
#include<ImLib3D/Vect3D.hpp>


// ********************** FileParser ********************
class XMLBinaryFile
{
public:
    // Create XMLBinaryFile. If mode is set, it will also open the file.
    XMLBinaryFile(const string &_fileName="",const string &mode="",bool _exceptionOnFail=false);
    // Closes the file (if necesary)
    ~XMLBinaryFile(){if(isOpen){Close();}}
    void OpenRead(const string &_fileName);
    void OpenWrite(const string &_fileName);
    void Close();
    
    xmlpp::Element *AddBinaryNode(xmlpp::Element *parent,int size=-1);

    template<class T,class iterator>
    void BinaryWrite(iterator begin,iterator end);
    template<class T,class iterator>
    void BinaryRead(iterator begin,iterator end);
    void BinaryWrite(void *data,size_t size);
    void BinaryWrite(xmlpp::Element *binNode,void *data,size_t size);
    void ReadBinaryNode(xmlpp::Element *parent);
    void EndBinaryWrite(xmlpp::Element *binNode);
    // Write some binary data. Use this only after ReadBinaryNode.
    void BinaryRead(void *data,size_t size);
    bool CheckBinaryReadComplete();

    xmlpp::Element *AddChild(xmlpp::Element *parent,const string &name,const string &a1="",const string &a2="",const string &a3="",const string &a4="");
    xmlpp::Element *GetChild(xmlpp::Element *parent,const string &name);
    bool   HasChild(xmlpp::Element *parent,const string &name);
    int    GetIntAttribute   (xmlpp::Element *node,const string &name){return (int)LongInt(GetAttribute(node,name));}
    double GetDoubleAttribute(xmlpp::Element *node,const string &name){return       Double(GetAttribute(node,name));}
    string GetAttribute      (xmlpp::Element *node,const string &name);
    bool   HasAttribute      (xmlpp::Element *node,const string &name);
    static string Quote(const string &src);
    static string UnQuote(const string &src);


protected:

    int    AllocInBinary(size_t size);
    string GetBinFileName(){return binFileName;}
    string GetFileName(){return fileName;}
    int    GetBinaryBegining(){return binaryBegining;}
public:
    xmlpp::Element *GetRoot(const string &rootName="");
    xmlpp::Element *SetRoot(const string &rootName)
    {
        return document->create_root_node(rootName);
    }

public:
    void   ShowXML(xmlpp::Element *node=NULL,int depth=0);

    int debug;
protected:

    string fileName;
    string binFileName;
    FILE *binaryFile;

    xmlpp::DomParser *parser;
    xmlpp::Document  *document;
    size_t binaryCurrentAllocPos;
    size_t posInsideCurrentAllocBlock;
    size_t currentAllocBlockSize;

    size_t binaryBegining;


    bool isWrite;
    bool isOpen;
    bool exceptionOnFail;

    string ReadXMLHeader();
    void Error(const char *fmt, ...);

public:
    void ExceptionOnFail();
    

};


template<class T,class iterator>
void 
XMLBinaryFile::BinaryWrite(iterator begin,iterator end)
{
    uint size=end-begin;
    if(IsSmallEndian() || sizeof(*begin)==1)
    {
        BinaryWrite((void *)&(*begin),size*sizeof(T));
    }
    else
    if(typeid(T) == typeid(Vect3Df))
    {
        float *data0=(float *)(void *)&(*begin);
        for(uint i=0;i<size;i++)
        {
            for(int j=0;j<3;j++)
            {
                float p;
                ReverseEndian(data0[i*3+j],p);
                BinaryWrite(&p,sizeof(float));
            }
        }
    }
    else
    {       
        T v;
        for(iterator p=begin;p!=end;++p)
        {
            ReverseEndian(*p,v);
            BinaryWrite(&v,sizeof(T));
        }
    }
}
template<class T,class iterator>
void 
XMLBinaryFile::BinaryRead(iterator begin,iterator end)
{
    uint size=end-begin;

    if(IsSmallEndian() || sizeof(T)==1)
    {
        BinaryRead(begin,size*sizeof(T));
    }
    else
    if(typeid(T) == typeid(Vect3Df))
    {
        float *data0=(float *)(void *)begin;
        for(uint i=0;i<size;i++)
        {
            for(int j=0;j<3;j++)
            {
                float p;
                BinaryRead(&p,sizeof(float));
                ReverseEndian(p,data0[i*3+j]);
            }
        }
    }
    else
    {
        T v;
        for(iterator p=begin;p!=end;++p)
        {
            BinaryRead(&v,sizeof(T));
            ReverseEndian(v,*p);
        }
    }
}

#endif // _XMLBinaryFile_hpp

---