xml.h

Go to the documentation of this file.

/*
 *              xml.h
 *
 *      Copyright 2001 - 2016 Brenton Ross
 *
 *      This file is part of VICI.
 *
 *   VICI 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 3 of the License, or
 *   (at your option) any later version.
 *
 *   VICI 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 VICI.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CFI_XML_H
#define CFI_XML_H

#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "stringy.h"
#include <vector>

#define VICI_RELEASE "V0.1"

namespace VICI
{

namespace cfi
{


class XmlBuffer
{
public:
        virtual ~XmlBuffer(){}                  
        virtual char *addr() = 0;               
        virtual int len() = 0;                  
        virtual void addr(char *) = 0;  
        virtual void len(int) = 0;              
};


class Xml
{
protected:

        static const int UMASK_RW_RW_R = 0664 ^ 0777;

        Path mFilename; 
        struct stat xmlStat;    
        xmlDocPtr mDoc;                 

        //
        // Support for XPath and namespaces
        //
        xmlXPathContextPtr mCtx;                
        static bool xpathinit;                  

        void createXPathContext();

        void registerNamespace( const std::string &prefix, csr uri );

protected:
        Xml();


        void open( const Path &fname );


        void create( const Path &fname, csr root_element );

        void unpack( XmlBuffer & );

        bool mDirty;    
        bool mIsOpen;   

        int mCompression;       

        void freeDoc();         


        void setProp( xmlNodePtr node, csr prop, csr val );


        void setProp( xmlNodePtr node, csr prop, int val );


        void setProp( xmlNodePtr node, csr prop, double val );


        void setContent( xmlNodePtr node, csr text );


        void setCDATAContent( xmlNodePtr node, csr text );



        void getPropString( xmlNodePtr node, csr prop, std::string & val );


        void getPropInt( xmlNodePtr node, csr prop, int & val );


        void getPropShort( xmlNodePtr node, csr prop, short & val );


        void getPropDouble( xmlNodePtr node, csr prop, double & val );



        std::string getNodeContent( xmlNodePtr p, int expand=1) const;


        std::string getNodeName( xmlNodePtr p ) const;

        xmlNodePtr getRoot();


        xmlNodePtr getChild( xmlNodePtr node, csr name ) const;


        int getChildren( xmlNodePtr node, std::vector< xmlNodePtr > & nodes ) const;


        xmlNodePtr newNode( xmlNodePtr node, csr name );


        static xmlNodePtr newTextChild( xmlNodePtr node, csr name, csr text );


        void deleteNode( xmlNodePtr  node);  // does a deep free

        // searches for nodes that match the XPath expression.
        // returns the number found.


        int find( csr xpath_expression, std::vector< xmlNodePtr > & nodes );

public:

        virtual ~Xml();


        void setDtd( csr name, const Path &dtd );


        void setDtd( csr name, csr ident, csr url );



        void getDtdIdentifiers(csr dtdName, std::string & publicId, std::string & systemId);

        // set compression - valid values are 0 to 9, where 0 is none, 9 is max


        void setCompression( int rate );

        // save the xml back to disk

        void save();


        void save( const Path &fname ); //associate a (possibly new)
                                                //file with this

        void pack( XmlBuffer & );


        bool dirty() { return mDirty; }


        void setDirty( bool dt ) { mDirty = dt; };


        bool safeToSave();

        void reload();
};

} // namespace cfi
} // end namespace VICI

#endif /* XML_H_ */