tixy2.h

Go to the documentation of this file.

#ifndef GELIB_TIXY_H
#define GELIB_TIXY_H

// There is conflict name XMLDocument in msxml and tinyxml.
// Solution 1:
// This define have to be before first win32 include.
#define WIN32_LEAN_AND_MEAN

#include "gelib.h"
#include "tinyxml2.h"


using namespace tinyxml2;

namespace gelibspace {

// Solution 2:
// #include "gelib.h"
// #include "tinyxml2.h"
//
// namespace TXML = tinyxml2;
// XMLDocument -> TXML::XMLDocument

enum VTKrange { VTKR_void, VTKR_points, VTKR_cells, VTKR_lines, VTKR_polygs, VTKR_pred, VTKR_pd, VTKR_cd, VTKR_data, VTKR_fields };



XMLDocument* openTXdcPN (const char *path, const char *name);
XMLDocument* openTXdcPNSS (const char *path, const char *name, const char *suff, const char *suff2);



enum Stream_type { STRM_void , STRM_file , STRM_tixel , STRM_string };

class Stream
{
  
 protected:
  char state;
  Stream_type type;
  const char *filename;
  
  FILE        *str_file;
  XMLNode     *str_tixel;
  const char  *str_string;
  
 public:
  Stream (void)               { state = '-';  type = STRM_void;   filename = NULL;  str_file = NULL;    str_tixel = NULL;    str_string = NULL;   }
  Stream (Stream_type tp)     { state = '-';  type = tp;          filename = NULL;  str_file = NULL;    str_tixel = NULL;    str_string = NULL;   }
  Stream (FILE       *stream) { state = '-';  type = STRM_file;   filename = NULL;  str_file = stream;  str_tixel = NULL;    str_string = NULL;   }
  Stream (XMLNode    *stream) { state = '-';  type = STRM_tixel;  filename = NULL;  str_file = NULL;    str_tixel = stream;  str_string = NULL;   }
  Stream (const char *stream) { state = '-';  type = STRM_string; filename = NULL;  str_file = NULL;    str_tixel = NULL;    str_string = stream; }
  virtual ~Stream() { delete [] filename; }
  

  void open (Stream_type t, const char *rw, const char *&fn, XMLNode *node=NULL)
  {
    if (state != '-') errol;
    //# only these rw are accepted
    if (rw[1] != '\0')  errol;
    if (*rw != 'r' && *rw != 'w')  errol;
    state = *rw;
    type = t;
    if (filename)  delete [] filename;
    filename = fn;  fn = NULL;
    
    switch (type) {
    case STRM_file:                     this->str_file  = _openFileN (rw, filename, filename);  break;
    case STRM_tixel:
      if      (state == 'w')  this->str_tixel = node;
      else if (state == 'r')  errol;
      else errol;
      break;
    case STRM_void: {
      if (*rw != 'r'  ||  node)  errol;
      
      FILE *in = _openFileN("rb", filename, filename);
      char c = getc(in);  ungetc(c, in);
      
      if      (c=='#') { type = STRM_file;   str_file  = in; }
      else if (c=='<') { type = STRM_tixel;  str_tixel = new XMLDocument(true, COLLAPSE_WHITESPACE);
    XMLError err = ((XMLDocument*)str_tixel)->LoadFile(in);
    if (err!=XML_NO_ERROR && err!=XML_SUCCESS)  _errorr2 ("File %s has not valid syntax", filename);
    fclose (in); }
      else _errorr2 ("File %s doesnot start neither with character '#' nor '<'", filename);
      
      break;
    }
    case STRM_string: errol;                                                                    break;
    default:  _errorr ("unsuported stream type");
    }
  }
  
  void close (void)
  {
    switch (type) {
    case STRM_file:       fclose (str_file);  break;
    case STRM_tixel:
      if      (state == 'w')  str_tixel->GetDocument()->SaveFile(filename);
      else if (state == 'r')  ;
      else errol;
      
      delete str_tixel->GetDocument();
      break;
    case STRM_string: errol;                                                                 break;
    default:  _errorr ("unsuported stream type");
    }
    
    state = '-';
  }
  
  
  //void   initiate (XMLNode *stream) {  checkin_type(STRM_tixel);  if (str_tixel != NULL)  _errorr ("not nul");  str_tixel = stream;  }
  //void reinitiate (XMLNode *stream) {  checkin_type(STRM_tixel);                                               str_tixel = stream;  }
  
  void redefine (FILE       *stream) { type = STRM_file;   str_file = stream;  str_tixel = NULL;    str_string = NULL;   }
  void redefine (XMLNode    *stream) { type = STRM_tixel;  str_file = NULL;    str_tixel = stream;  str_string = NULL;   }
  void redefine (const char *stream) { type = STRM_string; str_file = NULL;    str_tixel = NULL;    str_string = stream; }
  
  FILE       * file(void)   {  check_type(STRM_file);   return str_file;  }
  XMLNode    * tixnod(void) {  check_type(STRM_tixel);  return str_tixel; }
  XMLElement * tixel(void)  {  check_type(STRM_tixel);  return str_tixel->ToElement(); }
  //XMLDocument* tixdoc(void) {  check_type(STRM_tixel);  return str_tixel->ToDocument(); }
  XMLDocument* tix_doc(void) {  check_type(STRM_tixel);  return str_tixel->GetDocument(); }
  
  const char   * string(void) {  check_type(STRM_string); return str_string;}
  const char  ** pstring(void){  check_type(STRM_string); return &str_string;}
  
  Stream_type give_type (void) { return type; }
  
  bool isFile   (void) { return (type == STRM_file); }
  bool isTixel  (void) { return (type == STRM_tixel); }
  bool isString (void) { return (type == STRM_string); }
  
  bool relink_downF (void) {  check_type(STRM_tixel);  str_tixel = this->str_tixel->FirstChild();  return (str_tixel) ? true : false; }
  bool relink_downL (void) {  check_type(STRM_tixel);  str_tixel = this->str_tixel->LastChild();   return (str_tixel) ? true : false; }
  bool relink_up    (void) {  check_type(STRM_tixel);  str_tixel = this->str_tixel->Parent();      return (str_tixel) ? true : false; }
  bool relink_next  (void) {  check_type(STRM_tixel);  if (str_tixel->NextSibling())     { str_tixel = str_tixel->NextSibling();      return true; } else return false; }
  bool relink_prev  (void) {  check_type(STRM_tixel);  if (str_tixel->PreviousSibling()) { str_tixel = str_tixel->PreviousSibling();  return true; } else return false; }
  
  void skip_commnet (void) {  check_type(STRM_tixel);  while (true)  if (str_tixel->ToComment() != NULL)  str_tixel = str_tixel->NextSibling();  else break; }
  
 private:
  void check_type   (Stream_type tp) {           
                                if (type != tp)
  _errorr ("wrong type of Stream");  }
  void checkin_type (Stream_type tp) {  if (type == STRM_void)  type = tp;  else if (type != tp)  _errorr ("wrong type of Stream");  }
};




bool ST_scan_number (Stream *src, int    &dest);
bool ST_scan_number (Stream *src, long   &dest);
bool ST_scan_number (Stream *src, double &dest);
//
bool ST_scan_array (Stream *src, int n, int    *dest);
bool ST_scan_array (Stream *src, int n, long   *dest);
bool ST_scan_array (Stream *src, int n, double *dest);

bool ST_scan_expected_number (Stream *src, long expctd);

template <class ArgType>
void ST_scan_expected_number_FL (const char* file, int line, Stream *src, ArgType expctd, const char *msg)
{
  if (!ST_scan_expected_number (src, expctd))
    errorr_expected (file, line, msg, expctd, ""); // misto "" by tam mel byt retezec s prectenym cislem, casem to dodelej, asi budes muset predelat errorr_expected
}
#define ST_scan_expected_number_exit(_1,_2,_3) ST_scan_expected_number_FL (__FILE__, __LINE__, _1,_2,_3)

long GP_scan_line (Stream * stream, char *dest);
long GP_scan_word (Stream * stream, char *dest);
long GP_scan_line_alloc (Stream * stream, char *&dest);


//*  ********************************************************************************************
//*  *** *** *** ***                       docasne XML FCES                       *** *** *** ***
//*  ********************************************************************************************
const XMLElement * XP_give_unique_expected_elem (const XMLNode *xelem, const char * name, bool uniq=true);
void XP_check_expected_attribute (const XMLNode *xelem, const char *name, const char *value);
const char * XP_giveDAtext (const XMLNode *xelem, int n, bool last, const char *format, const char *type, const char *name, int *noc=NULL);


} // namespace gelibspace

#endif // GELIB_TIXY_H