src/felib/fesave.h

   1 /*
   2  *
   3  *  Iter Vehemens ad Necem (IVAN)
   4  *  Copyright (C) Timo Kiviluoto
   5  *  Released under the GNU General
   6  *  Public License
   7  *
   8  *  See LICENSING which should be included
   9  *  along with this file for more details
  10  *
  11  */
  12 #ifndef __FELIB_SAVE_H__
  13 #define __FELIB_SAVE_H__
  14
  15 #include <ctime>
  16 #include <cstdio>
  17 #include <vector>
  18 #include <stack>
  19 #include <deque>
  20 #include <list>
  21 #include <map>
  22 #include <set>
  23
  24 #ifdef USE_ZLIB
  25 # include <zlib.h>
  26 #endif
  27
  28
  29 #include "feerror.h"
  30 #include "festring.h"
  31 #include "fearray.h"
  32
  33
  34 // ////////////////////////////////////////////////////////////////////////// //
  35 #define RAW_SAVE_LOAD(type) \
  36 inline outputfile &operator << (outputfile &SaveFile, type Value) { \
  37   SaveFile.Write(reinterpret_cast<char *>(&Value), sizeof(Value)); \
  38   return SaveFile; \
  39 } \
  40  \
  41 inline inputfile &operator >> (inputfile &SaveFile, type &Value) { \
  42   SaveFile.Read(reinterpret_cast<char *>(&Value), sizeof(Value)); \
  43   return SaveFile; \
  44 }
  45
  46
  47 // ////////////////////////////////////////////////////////////////////////// //
  48 class inputfile;
  49 class outputfile;
  50
  51
  52 typedef std::map<festring, sLong> valuemap;
  53
  54
  55 // ////////////////////////////////////////////////////////////////////////// //
  56 class outputfile {
  57 public:
  58   outputfile (cfestring &FileName, truth maxcomp, truth AbortOnErr=true);
  59   ~outputfile ();
  60
  61   void Put (char What);
  62   void Write (cchar *Offset, sLong Size);
  63   truth IsOpen () { return (Buffer != 0); }
  64   void Close ();
  65   void Flush ();
  66   sLong TellPos ();
  67
  68 private:
  69 #ifdef USE_ZLIB
  70   gzFile Buffer;
  71 #else
  72   FILE *Buffer;
  73 #endif
  74   festring FileName;
  75 };
  76
  77
  78 // ////////////////////////////////////////////////////////////////////////// //
  79 class inputfile {
  80 public:
  81   inputfile ();
  82   inputfile (cfestring &aFileName, truth AbortOnErr=true);
  83   virtual ~inputfile ();
  84
  85   bool Open (cfestring &aFileName, truth AbortOnErr=true);
  86
  87   int Get (); // returns EOF on eof
  88   void Read (char *Offset, sLong Size);
  89   truth IsOpen () { return (Buffer != 0); }
  90   truth Eof ();
  91   void ClearFlags ();
  92   void SeekPosBegin (sLong Offset);
  93   void SeekPosCurrent (sLong Offset);
  94   void SeekPosEnd (sLong Offset);
  95   sLong TellPos ();
  96   cfestring &GetFileName () const { return mRetFName; }
  97   void Close ();
  98
  99   static truth fileExists (const festring &fname);
 100   static festring GetMyDir ();
 101   static festring buildIncludeName (cfestring &basename, cfestring incname);
 102
 103 protected:
 104 #ifdef USE_ZLIB
 105   gzFile Buffer;
 106 #else
 107   FILE *Buffer;
 108 #endif
 109   festring FileName;
 110   festring mRetFName; // with `GetMyDir()` stripped
 111 #ifdef USE_ZLIB
 112   int mFileSize;
 113 #endif
 114 };
 115
 116
 117 // ////////////////////////////////////////////////////////////////////////// //
 118 /* Reads a binary form variable of type type and returns it.
 119  * An inputfile template member function would be far more elegant,
 120  * but VC doesn't seem to understand it. */
 121 template <class type> inline type _ReadType_ (inputfile &SaveFile, const char *tag) {
 122   type Variable;
 123   //
 124   //fprintf(stderr, "ReadType: [%s]\n", tag);
 125   SaveFile >> Variable;
 126   return Variable;
 127 }
 128
 129 #define ReadType(typename,fl)  _ReadType_<typename>(fl, #typename)
 130
 131
 132 // ////////////////////////////////////////////////////////////////////////// //
 133 inline outputfile &operator << (outputfile &SaveFile, char Value) {
 134   SaveFile.Put(Value);
 135   return SaveFile;
 136 }
 137
 138
 139 inline inputfile &operator >> (inputfile &SaveFile, char &Value) {
 140   Value = SaveFile.Get();
 141   return SaveFile;
 142 }
 143
 144
 145 inline outputfile &operator << (outputfile &SaveFile, uChar Value) {
 146   SaveFile.Put(Value);
 147   return SaveFile;
 148 }
 149
 150
 151 inline inputfile &operator >> (inputfile &SaveFile, uChar &Value) {
 152   Value = SaveFile.Get();
 153   return SaveFile;
 154 }
 155
 156
 157 inline outputfile &operator << (outputfile &SaveFile, short Value) {
 158   SaveFile.Put(Value);
 159   SaveFile.Put(Value >> 8);
 160   return SaveFile;
 161 }
 162
 163
 164 inline inputfile &operator >> (inputfile &SaveFile, short &Value) {
 165   int LowWord = SaveFile.Get();
 166   Value = SaveFile.Get() << 8 | LowWord;
 167   return SaveFile;
 168 }
 169
 170
 171 inline outputfile &operator << (outputfile &SaveFile, uShort Value) {
 172   SaveFile.Put(Value);
 173   SaveFile.Put(Value >> 8);
 174   return SaveFile;
 175 }
 176
 177
 178 inline inputfile &operator >> (inputfile &SaveFile, uShort &Value) {
 179   int LowWord = SaveFile.Get();
 180   Value = SaveFile.Get() << 8 | LowWord;
 181   return SaveFile;
 182 }
 183
 184
 185 //RAW_SAVE_LOAD(sLong); //k8:64
 186 //RAW_SAVE_LOAD(feuLong); //k8:64
 187 RAW_SAVE_LOAD(int);
 188 RAW_SAVE_LOAD(uInt);
 189 RAW_SAVE_LOAD(double);
 190 RAW_SAVE_LOAD(packv2);
 191 RAW_SAVE_LOAD(v2);
 192 RAW_SAVE_LOAD(rect);
 193 RAW_SAVE_LOAD(time_t);
 194
 195
 196 outputfile &operator << (outputfile &, cfestring &);
 197 inputfile &operator >> (inputfile &, festring &);
 198 outputfile &operator << (outputfile &, cchar *);
 199 inputfile &operator >> (inputfile &, char *&);
 200
 201
 202 template <class type1, class type2> inline outputfile &operator << (outputfile &SaveFile, const std::pair<type1, type2> &Pair) {
 203   SaveFile << Pair.first << Pair.second;
 204   return SaveFile;
 205 }
 206
 207 template <class type1, class type2> inline inputfile &operator >> (inputfile &SaveFile, std::pair<type1, type2> &Pair) {
 208   SaveFile >> Pair.first >> Pair.second;
 209   return SaveFile;
 210 }
 211
 212 template <class type> inline outputfile &operator << (outputfile &SaveFile, const std::vector<type> &Vector) {
 213   SaveFile << feuLong(Vector.size());
 214   for (feuLong c = 0; c < Vector.size(); ++c) SaveFile << Vector[c];
 215   return SaveFile;
 216 }
 217
 218 template <class type> inline inputfile &operator >> (inputfile &SaveFile, std::vector<type> &Vector) {
 219   Vector.resize(ReadType(feuLong, SaveFile), type());
 220   for (feuLong c = 0; c < Vector.size(); ++c) SaveFile >> Vector[c];
 221   return SaveFile;
 222 }
 223
 224 template <class type> inline outputfile &operator << (outputfile &SaveFile, const std::deque<type> &Deque) {
 225   SaveFile << feuLong(Deque.size());
 226   for (feuLong c = 0; c < Deque.size(); ++c) SaveFile << Deque[c];
 227   return SaveFile;
 228 }
 229
 230 template <class type> inline inputfile &operator >> (inputfile &SaveFile, std::deque<type> &Deque) {
 231   Deque.resize(ReadType(feuLong, SaveFile), type());
 232   for (feuLong c = 0; c < Deque.size(); ++c) SaveFile >> Deque[c];
 233   return SaveFile;
 234 }
 235
 236 template <class type> inline outputfile &operator << (outputfile &SaveFile, const std::list<type> &List) {
 237   SaveFile << feuLong(List.size());
 238   for (typename std::list<type>::const_iterator i = List.begin(); i != List.end(); ++i) SaveFile << *i;
 239   return SaveFile;
 240 }
 241
 242 template <class type> inline inputfile &operator >> (inputfile &SaveFile, std::list<type> &List) {
 243   List.resize(ReadType(feuLong, SaveFile), type());
 244   for (typename std::list<type>::iterator i = List.begin(); i != List.end(); ++i) SaveFile >> *i;
 245   return SaveFile;
 246 }
 247
 248 template <class type1, class type2> inline outputfile &operator << (outputfile &SaveFile, const std::map<type1, type2> &Map) {
 249   SaveFile << feuLong(Map.size());
 250   for (typename std::map<type1, type2>::const_iterator i = Map.begin(); i != Map.end(); ++i) SaveFile << i->first << i->second;
 251   return SaveFile;
 252 }
 253
 254 template <class type1, class type2> inline inputfile &operator >> (inputfile &SaveFile, std::map<type1, type2> &Map) {
 255   Map.clear();
 256   type1 First;
 257   feuLong Size;
 258   SaveFile >> Size;
 259   typename std::map<type1, type2>::iterator i;
 260   for (feuLong c = 0; c < Size; ++c) {
 261     SaveFile >> First;
 262     i = Map.insert(Map.end(), std::make_pair(First, type2()));
 263     SaveFile >> i->second;
 264   }
 265   return SaveFile;
 266 }
 267
 268 template <class type> inline outputfile &operator << (outputfile &SaveFile, const std::set<type> &Set) {
 269   SaveFile << feuLong(Set.size());
 270   for (typename std::set<type>::const_iterator i = Set.begin(); i != Set.end(); ++i) SaveFile << *i;
 271   return SaveFile;
 272 }
 273
 274 template <class type> inline inputfile &operator >> (inputfile &SaveFile, std::set<type> &Set) {
 275   Set.clear();
 276   feuLong Size;
 277   SaveFile >> Size;
 278   for (feuLong c = 0; c < Size; ++c) {
 279     type Value;
 280     SaveFile >> Value;
 281     Set.insert(Value);
 282   }
 283   return SaveFile;
 284 }
 285
 286 template <class type> inline outputfile &operator << (outputfile &SaveFile, const fearray<type> &Array) {
 287   typename fearray<type>::sizetype c, Size = Array.Size;
 288   SaveFile << Size;
 289   for (c = 0; c < Size; ++c) SaveFile << Array[c];
 290   return SaveFile;
 291 }
 292
 293 template <class type> inline inputfile &operator >> (inputfile &SaveFile, fearray<type> &Array) {
 294   typename fearray<type>::sizetype c, Size;
 295   SaveFile >> Size;
 296   Array.Allocate(Size);
 297   for (c = 0; c < Size; ++c) SaveFile >> Array[c];
 298   return SaveFile;
 299 }
 300
 301 template <class type> inline outputfile &SaveLinkedList (outputfile &SaveFile, const type *Element) {
 302   for (const type* E = Element; E; E = E->Next) {
 303     SaveFile.Put(true);
 304     SaveFile << E;
 305   }
 306   SaveFile.Put(false);
 307   return SaveFile;
 308 }
 309
 310 template <class type> inline inputfile &LoadLinkedList(inputfile &SaveFile, type *&Element) {
 311   if (SaveFile.Get()) {
 312     SaveFile >> Element;
 313     type *E;
 314     for (E = Element; SaveFile.Get(); E = E->Next) SaveFile >> E->Next;
 315     E->Next = 0;
 316   } else {
 317     Element = 0;
 318   }
 319   return SaveFile;
 320 }
 321
 322 template <class type> inline outputfile &SaveArray (outputfile &SaveFile, const type *Array, int Count) {
 323   for (int c = 0; c < Count; ++c) SaveFile << Array[c];
 324   return SaveFile;
 325 }
 326
 327 template <class type> inline inputfile &LoadArray (inputfile &SaveFile, type *Array, int Count) {
 328   for (int c = 0; c < Count; ++c) SaveFile >> Array[c];
 329   return SaveFile;
 330 }
 331
 332
 333 #endif