XMLBinaryFile.cpp

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.
 */
#include<ImLib3D/Image3D.hpp>
#include<ImLib3D/TestPatterns.hpp>
#include<ImLib3D/Display.hpp>
#include<ImLib3D/ConvenienceProcessors.hpp>
#include<stdexcept>
#include <errno.h>

void 
XMLBinaryFile::Error(const char *fmt, ...)
{
    static bool firstTime=true;
    va_list args;
    va_start(args,fmt);
    if(!fmt)
    {
        fprintf(stderr,"format string null\n");
        ThrowError("XMLBinaryFile::Error encountered null format string while already processing error!");
    }
    char msg[1000];
    char msg1[1000];
    vsprintf(msg,fmt,args);
    sprintf(msg1," :For file name:%s\n",fileName.c_str());
    strcat(msg,msg1);
    if(!firstTime){ThrowError(msg);}
    if(exceptionOnFail){throw runtime_error(msg);}
    firstTime=false;
    fprintf(stderr,  "************ File Error ***********\n");
    fprintf(stderr,  "************ Error Message : %s",msg);
    if(errno){perror("************ System Error :");}
    fprintf(stderr,  "************ Dumping XMLTree:\n");
    ShowXML();
    ThrowError(msg);
}

XMLBinaryFile::XMLBinaryFile(const string &_fileName,const string &mode,bool _exceptionOnFail):
    debug(0),
    fileName(_fileName),
    binaryFile(NULL),
    parser(NULL),
    document(NULL),
    binaryCurrentAllocPos(0),
    posInsideCurrentAllocBlock(0),
    currentAllocBlockSize(0),
    binaryBegining(0),
    isOpen(false),
    exceptionOnFail(_exceptionOnFail)
{
    if(mode=="r"){OpenRead(fileName);}
    else
    if(mode=="w"){OpenWrite(fileName);}
    else
    // in memory dud file 
    if(mode=="m"){isWrite=false;fileName="";document=new xmlpp::Document();}
    else
    {
        ThrowError("XMLBinaryFile::XMLBinaryFile unknow mode:\"%s\"",mode);
    }
}
void 
XMLBinaryFile::OpenRead(const string &_fileName)
{
    isWrite=false;
    fileName=_fileName;
    // read the xml header from the image file
    string header=ReadXMLHeader();
    // parse xml header into xml tree
    parser=new xmlpp::DomParser();
    parser->parse_memory(header);
    document=parser->get_document();
    if(debug){cout << "OpenRead:tree:" << endl;ShowXML();}
    binaryFile=fopen(fileName.c_str(),"r");
    if(!binaryFile){Error("XMLBinaryFile::OpenRead can't open:%s",fileName.c_str());}
    isOpen=true;
}
void 
XMLBinaryFile::OpenWrite(const string &_fileName)
{
    isWrite=true;
    fileName=_fileName;
    binFileName=WriteTmpFile("empty");
    mprintf("binFileName:%s fileName:%s\n",binFileName.c_str(),fileName.c_str());
    binaryFile=fopen(binFileName.c_str(),"r+");
    if(!binaryFile){Error("XMLBinaryFile::OpenWrite can't open:%s",binFileName.c_str());}
    document=new xmlpp::Document();
    isOpen=true;
}
void 
XMLBinaryFile::Close()
{
    if(isWrite)
    {
        // ******** write xml tree into file
        if(debug){cout << "Close:tree:" << endl;ShowXML();}
        document->write_to_file(fileName);
        // ********  now append  the binary file to the xml header
        FILE *mainFile=fopen(fileName.c_str(),"a");
        if(!mainFile){Error("XMLBinaryFile::Close could not reopen mainFile:\"%s\"",fileName.c_str());}
        fprintf(mainFile,"::BeginBinary::\n");
        long binarySize=ftell(binaryFile);
        rewind(binaryFile);
        const size_t bufferSize=50*1000*1000;
        char *buffer=new char[bufferSize];
        for(size_t remaining=binarySize;remaining>0;)
        {
            size_t blockSize=min(remaining,bufferSize);
            if(fread(buffer,blockSize,1,binaryFile)!=1)
            {
                Error("XMLBinaryFile::Close failed while reading temporary binary file");
            }
            if(fwrite(buffer,blockSize,1,mainFile)!=1)
            {
                Error("XMLBinaryFile::Close failed while writing final binary file");
            }
            remaining-=blockSize;
        }
        delete [] buffer;
        if(fclose(binaryFile)){Error("XMLBinaryFile::Close failed while closing (read) temproary binary file");}
        binaryFile=NULL;
        if(fclose(mainFile)){Error("XMLBinaryFile::Close failed while closing (write) final binary file");}
//          system(SPrintf("cat %s >> %s",binFileName,fileName).c_str());
        // cleanup temporary binary file
        RemoveFile(binFileName);
    }
    else
    {
        fclose(binaryFile);
        binaryFile=NULL;
    }
    isOpen=false;
}

xmlpp::Element *
XMLBinaryFile::AddBinaryNode(xmlpp::Element *parent,int size)
{
    if( posInsideCurrentAllocBlock <currentAllocBlockSize)
    {mprintf("WARNING: XMLBinaryFile::AddBinaryNode previous bin node did not fill up it's binary data");}

    AllocInBinary(size);
    xmlpp::Element *dataN=parent->add_child("BinaryData");
    dataN->set_attribute("binoffset" ,SPrintf("%d",binaryCurrentAllocPos));
    dataN->set_attribute("binsize" ,SPrintf("%d",size));

    if(debug)
    {
        mprintf("AddBinaryNode:: xxxxxxxxxxxxxxx created BinaryData xml node:\n");
        ShowXML(dataN);
        mprintf("AddBinaryNode:: xxxxxxxxxxxxxxx created BinaryData xml node from parent:\n");
        ShowXML(parent);
        mprintf("AddBinaryNode:: xxxxxxxxxxxxxxx from root:\n");
        string all=document->write_to_string();
        mprintf("%s\n",all.c_str());
    }
    return dataN;
}
void 
XMLBinaryFile::BinaryWrite(void *data,size_t size)
{
    if(!binaryFile){Error("XMLBinaryFile::BinaryWrite binaryFile was not open");}
    if( posInsideCurrentAllocBlock+size >currentAllocBlockSize)
    {Error("XMLBinaryFile::BinaryWrite attempt to write past end of alloc block");}
//      mprintf("BinaryWrite: %x: at:%d size:%d\n",data,posInsideCurrentAllocBlock,size);
    posInsideCurrentAllocBlock+=size;
    if(fwrite(data,size,1,binaryFile)!=1)
    {
        Error("XMLBinaryFile::BinaryWrite failed while writing temp binary file");
    }
}
void 
XMLBinaryFile::BinaryWrite(xmlpp::Element *binNode,void *data,size_t size)
{
    if(!binaryFile){Error("XMLBinaryFile::BinaryWrite binaryFile was not open");}
    if(fwrite(data,size,1,binaryFile)!=1)
    {
        Error("XMLBinaryFile::BinaryWrite failed while writing temp binary file");
    }
    posInsideCurrentAllocBlock+=size;
}
void 
XMLBinaryFile::EndBinaryWrite(xmlpp::Element *binNode)
{
    xmlpp::Attribute *attribute=binNode->get_attribute("binsize");
    if(!attribute){Error("XMLBinaryFile::EndBinaryWrite no binsize in binNode ");}
    if(currentAllocBlockSize==0){currentAllocBlockSize=posInsideCurrentAllocBlock;}
    attribute->set_value(SPrintf("%d",currentAllocBlockSize));
}
void 
XMLBinaryFile::ReadBinaryNode(xmlpp::Element *parent)
{
    xmlpp::Element::NodeList nodeList;
    if((nodeList=parent->get_children("BinaryData")).size()!=1)
    {Error("XMLBinaryFile::ReadBinaryNode: no binary data child node in xml node");}
    xmlpp::Element *dataN=dynamic_cast<xmlpp::Element*>(*nodeList.begin());

    binaryCurrentAllocPos   = LongInt(dataN->get_attribute("binoffset" )->get_value());
    currentAllocBlockSize   = LongInt(dataN->get_attribute("binsize"   )->get_value());
    posInsideCurrentAllocBlock=0;

    fseek(binaryFile,binaryCurrentAllocPos+binaryBegining,SEEK_SET);
}

void 
XMLBinaryFile::BinaryRead(void *data,size_t size)
{
    if(!binaryFile){Error("XMLBinaryFile::BinaryRead binaryFile was not open");}
//      mprintf("BinaryRead: %x: at:%d size:%d (block size:%d)\n",data,posInsideCurrentAllocBlock,size,currentAllocBlockSize);
    if( posInsideCurrentAllocBlock+size >currentAllocBlockSize)
    {Error("XMLBinaryFile::BinaryRead attempt to read past end of alloc block");}
    posInsideCurrentAllocBlock+=size;
    if(fread(data,size,1,binaryFile)!=1)
    {
        Error("XMLBinaryFile::BinaryRead error reading");
    }
}
bool 
XMLBinaryFile::CheckBinaryReadComplete()
{
    return posInsideCurrentAllocBlock==currentAllocBlockSize;
}

int 
XMLBinaryFile::AllocInBinary(size_t size)
{
    binaryCurrentAllocPos+=currentAllocBlockSize;
    currentAllocBlockSize=size;
    posInsideCurrentAllocBlock=0;
    if(binaryFile)
    {
        fseek(binaryFile,binaryCurrentAllocPos,SEEK_SET);
    }
    return binaryCurrentAllocPos;
}

string 
XMLBinaryFile::ReadXMLHeader()
{
//          int filesize=FileSize(fileName);
    // open the file
    FILE *F=fopen(fileName.c_str(),"r");
    if(!F)
    {
        Error("XMLBinaryFile::ReadXMLHeader: Open file failed : filename:\"%s\"",fileName.c_str());
    }
    char buff[10000];
    // look for the the end of the xml/ begining of binary
    // end is defined by either ::BeginBinary::
    // or just ("</ImLib3DFileDescription>")
    int headerSize;
    for(;;)
    {
        int pos=ftell(F);
        char *cline=fgets(buff,10000,F);
        if(!cline){Error("XMLBinaryFile::ReadXMLHeader: bad file could not find:\"</ImLib3DFileDescription>\"");}
        string line=cline;

        if(line==SPrintf("::BeginBinary::\n"))
        {// found end of header
            headerSize=pos;
            binaryBegining=ftell(F);
            break;
        }

        // support for deprecated "</ImLib3DFileDescription>" without "::BeginBinary::"
        if(line.find("</ImLib3DFileDescription>")!=line.npos)
        {
            headerSize=ftell(F);
            binaryBegining=ftell(F);
            // read ahead one line to see if there is a "::BeginBinary::"
            string nline=fgets(buff,10000,F);
            if(nline!=SPrintf("::BeginBinary::\n"))
            {// argh no "::BeginBinary:: deprecated!
                break;
            }
            binaryBegining=ftell(F);
            break;
        }
    }
//      mprintf("headerSize:%d binaryBegining:%d\n",headerSize,binaryBegining);
    // re-read the header into a string
    fseek(F,0,SEEK_SET);
    char *cheader=new char[headerSize+1];
    fread(cheader,headerSize,1,F);
    cheader[headerSize]='\0';
    if(debug){mprintf("cheader:\"%s\"\n",cheader);}
    string header=cheader;
    delete [] cheader;

//  // test
//          int binsize=filesize-header.size();
//          fseek(F,header.size(),SEEK_SET);
//          char binb[10000];
//          fread(binb,binsize,1,F);
//          binb[binsize]=0;
//          mprintf("readbin:%s\n",binb);

        // close file
    fclose(F);
    return header;
}

void 
XMLBinaryFile::ShowXML(xmlpp::Element *node,int depth)
{
    if(!node)
    {
        mprintf("ShowXML from root for:%s:\n",fileName.c_str());        
        node=document->get_root_node();
    }
    if(!node){mprintf("WARNING:ShowXML no xml tree yet\n");return;}
    int nspaces=depth*4;
    char *spaces=new char[nspaces+1];
    for(int ll=0;ll<nspaces;ll++)spaces[ll]=' ';
    spaces[nspaces]=0;
    
//      cout << "node:" << node->get_name() << " : " << node->get_children().size() << " children" <<  endl;
    mprintf("%sNODE:\"%s\"   children:",spaces,node->get_name().c_str());

    vector<xmlpp::Element *>  children=ChildElements(node);
    for(vector<xmlpp::Element *>::iterator p=children.begin();p!=children.end();++p)
    {
        mprintf("%s,",(*p)->get_name().c_str());
    }
    mprintf("\n");
    xmlpp::Element::AttributeList attributes=node->get_attributes();
    xmlpp::Element::AttributeList::iterator ip;

    mprintf("%snode attributes:",spaces);
    if(attributes.size()==0){mprintf("(none)");}
    for(ip=attributes.begin();ip!=attributes.end();++ip)
    {
        mprintf("%s:%s , ",(*ip)->get_name().c_str(),(*ip)->get_value().c_str());
    }
    mprintf("\n");
    for(vector<xmlpp::Element *>::iterator p=children.begin();p!=children.end();++p)
    {
        ShowXML(*p,depth+1);
    }
    delete [] spaces;
}


xmlpp::Element *
XMLBinaryFile::GetRoot(const string &rootName)
{
    xmlpp::Element *root=document->get_root_node();
    if(!root){Error("XMLBinaryFile::GetRoot (\"%s\" ) no root!\n",rootName.c_str());}
    if(rootName!="" && root->get_name()!=rootName){Error("XMLBinaryFile::GetRoot (\"%s\" ) names dont match:\"%s\"\n",
                                                     rootName.c_str(),root->get_name().c_str());}   
    return root;
}

xmlpp::Element *
XMLBinaryFile::AddChild(xmlpp::Element *parent,const string &name,const string &a1,const string &a2,const string &a3,const string &a4)
{
    vector<string> args=Strings(a1,a2,a3,a4);
    xmlpp::Element *child=parent->add_child(name);
    for(uint i=0;i<args.size();i+=2)
    {
        if (args[i] =="")continue;
        child->set_attribute(args[i],args[i+1]);
    }
    return child;
}

bool
XMLBinaryFile::HasChild(xmlpp::Element *parent,const string &name)
{
    xmlpp::Element::NodeList nodeList=parent->get_children(name);
    return nodeList.size()!=0;
}
xmlpp::Element *
XMLBinaryFile::GetChild(xmlpp::Element *parent,const string &name)
{
    xmlpp::Element::NodeList nodeList=parent->get_children(name);
    int n=nodeList.size();
    if(n>1){Error("XMLBinaryFile::GetChild: found more than one child:\"%s\":%d",name.c_str(),n);}
    if(!n ){Error("XMLBinaryFile::GetChild: could not find child:\"%s\"",name.c_str());}
    xmlpp::Element *child=dynamic_cast<xmlpp::Element*>(*nodeList.begin());
    return child;
}
string 
XMLBinaryFile::GetAttribute      (xmlpp::Element *node,const string &name)
{
    if(!node)
    {
        Error("XMLBinaryFile::GetAttribute(%s): node==NULL!\n",name.c_str());
    }
    xmlpp::Attribute *attribute=node->get_attribute(name);
    if(!attribute)
    {
        Error("XMLBinaryFile::GetAttribute attribute \"%s\" of node \"%s\" not found",
              name.c_str(),node->get_name().c_str());
    }
                           
    return attribute->get_value();
}
bool
XMLBinaryFile::HasAttribute      (xmlpp::Element *node,const string &name)
{
    return node->get_attribute(name)!=NULL;
}
string
XMLBinaryFile::Quote(const string &src)
{
    string res=src;
    Replace(res,"\n","\\n");
    return res;
}
string
XMLBinaryFile::UnQuote(const string &src)
{
    string res=src;
    Replace(res,"\\n","\n");
    return res;
}

---