xmlsimplestruct.h

/* libIXAml - IXA Taldea. */

#ifndef _XMLSIMPLESTRUCT_H
#define _XMLSIMPLESTRUCT_H

#include "xmlsimpleprolog.h"
#include "xmlsimplenode.h"
#include "xmlsimpledefs.h"
#include <map>
#include <string>
#include <list>
#include <fstream>
#include <iconv.h>

typedef enum EncodingType {
  
  UTF_8       = 0,              
  ISO_8859_15 = 1,              
  IXAENC_OTHER = 2              
};

typedef enum ValidationMode {
  
  NO_VALIDATION   = 0,         
  CUSTOM_DTD      = 1,         
  DOCUMENT_DTD    = 2          
};

/*

validationMode ---------->  dokumentua irakurtzen edo idazten denean
                            balioztatu behar al da? hiru aukera:
                            
                            NO_VALIDATION ----> ez balioztatu
                            CUSTOM_DTD -------> gure DTDa erabili
                            DOCUMENT:DTD -----> dokumentuaren goiburuko DTDa erabili

workingEncoding --------->  Zein kodeketa erabili behar du liburutegiko _funtzioen_ sarrera/irteera

outputEncoding ---------->  Dokumentua idazterakoan zein kodeketa erabili
  
*/

class XMLSimpleStruct {
  
  static ValidationMode defaultValidationMode;
  static EncodingType defaultWorkingEncoding;
  static EncodingType defaultOutputEncoding;  

  static std::map<EncodingType,const char*> enc2enc;            // EncodingType -> libxml++ formatura
  static std::map<EncodingType,const char*> enc2encInit();
  static iconv_t * converters;
  static iconv_t * initConverters();

 protected:
  
  XMLSimpleProlog prolog;                   
  bool prologWrite;                         
  XMLSimpleNode* root;                      
  std::list<XMLSimpleNode*> addresses;      
  ValidationMode validationMode;            
  EncodingType workingEncoding;             
  EncodingType outputEncoding;              
  std::string dtdFilePath;                  
 public:

  XMLSimpleStruct();
  
  XMLSimpleStruct(const XMLSimpleStruct & xss);

  XMLSimpleStruct(const XMLSimpleProlog & xsp, bool wp, XMLSimpleNode* xsn, const std::list<XMLSimpleNode*> & xsnLis, ValidationMode val, EncodingType enc, EncodingType enc2, const std::string & dtd);

  void putProlog(const XMLSimpleProlog & p);

  void putPrologWrite(bool w);

  void putRoot(XMLSimpleNode* n);

  void putValidationMode(ValidationMode val);

  void putWorkingEncoding(EncodingType enc);

  void putOutputEncoding(EncodingType enc);
  
  XMLSimpleProlog getProlog() const;

  bool getPrologWrite() const;

  XMLSimpleNode* getRoot() const;

  ValidationMode getValidationMode() const;                                     

  EncodingType getWorkingEncoding() const;
   
  EncodingType getOutputEncoding() const;

  XMLSimpleNode* createNode();
  
  XMLSimpleNode* createNode(const std::string & name);

  XMLSimpleNode* createNode(const std::string & name, const std::string & text);
  
  virtual void readFile(const std::string & fname) throw (char*) = 0;

  virtual void readFile(std::istream & file) throw (char*) = 0;
  
  virtual void readString(const std::string & inputstr) throw (char*) = 0;
  
  virtual void writeFile(const std::string & fname) const throw (char*) = 0;
  
  virtual void writeFile(std::ostream & file) const  throw (char*) = 0;

  virtual void writeCompressedFile(const std::string & fname) const throw (char*) = 0;

  virtual std::string writeString() const throw (char*) = 0;

  virtual ~XMLSimpleStruct();
  
  static ValidationMode getDefaultValidationMode();
 
  static void putDefaultValidationMode(ValidationMode vm);

  static EncodingType getDefaultWorkingEncoding();
  
  static void putDefaultWorkingEncoding(EncodingType enc);
  
  static EncodingType getDefaultOutputEncoding();
  
  static void putDefaultOutputEncoding(EncodingType enc);
 
  static std::string convert(const std::string & inputstr, EncodingType inputenc, EncodingType outputenc);
 
};


#endif // _XMLSIMPLESTRUCT_H

---