mi32/serializer.h

Go to the documentation of this file.

#ifndef  INC_MI32_SERIALIZER_H
#define  INC_MI32_SERIALIZER_H

#ifndef  INC_MI32_SERIALIZERITEM_H
#include <mi32/serializeritem.h>
#endif

#ifndef  INC_RVC_OBJITEMLIST_H
#include <rvc/objitemlist.h>
#endif

#ifndef  INC_RVC_SERIALIZE_H
#include <rvc/serialze.h>
#endif

#ifndef  INC_MI32_RANGE_H
#include <mi32/range.h>
#endif

#ifdef WIN32
#pragma warning (disable:4996)   // Disable warning about deprecated declaration within header
#endif

// Forward declarations
#ifndef GENERATING_DOXYGEN_OUTPUT
class FILE_TEXT;
struct OLDPROJPARM;
struct COLOR;
struct DPOINT2D;
struct DPOINT3D;
struct DRECT2D;
struct DRECT3D;
class MISTATUSCONTEXT;
namespace SPATREF {
   class COORDREFSYS;
   }
#endif

//=====================================================================================================================

class SERIALIZER {
   public:

      SERIALIZER (
         );

      virtual ~SERIALIZER (
         );

      ERRVALUE Append (
         const FILEPATH& filepath         
         );

      void Close (
         );

      const FILEPATH& GetFilePath (
         ) const { return (m_filepath); }

      bool GetIgnoreSkippable (
         ) const { return (m_IgnoreSkippable); }

      const char* GetItemName (
         ) const { return (m_itemname); }

      const MIUNICODE* GetItemValue (
         ) const { return (m_parmvalue); }

      bool GetItemValue (
         double& value                    
         ) const;

      // Get log text.
      const MISTRING& GetLog (
         ) const { return (m_Log); }

      // Get log text (non-const).
      MISTRING& GetLog (
         ) { return (m_Log); }

      const MIUNICODE* GetObjectName (
         ) const { return (m_Descriptor.GetFullName()); }

      void GetScanListMissing (
         RVC::OBJITEMLIST& MissingList
         ) { MissingList.Merge(m_ScanFileObjListMissing); }

      void GetScanListUsed (
         RVC::OBJITEMLIST& UsedList
         ) { UsedList.Merge(m_ScanFileObjListUsed); }

      UINT16 GetVersion (
         ) const { return (m_Version[m_depth]); }

      bool IsScanOnly (
         ) const { return (m_ScanOnly); }

      void LogClear (
         ) { m_Log.Clear(); }

      void LogError (
         ERRVALUE err
         );

      void LogText (
         const MISTRING& text
         ) { m_Log << text; }

      ERRVALUE Make (
         RVC::OBJITEM& objitem,           
         const RVC::SERIALIZE::MAKEPARMS& makeparms
         );

      ERRVALUE Make (
         RVC::OBJECT& parent,             
         RVC::OBJTYPE objtype,            
         RVC::DESCRIPTOR& descriptor,     
         const RVC::SERIALIZE::MAKEPARMS& makeparms
         );

      ERRVALUE Make (
         const FILEPATH& filepath,        
         int version = 1                  
         );

      ERRVALUE Open (
         const RVC::OBJITEM& objitem      
         );

      ERRVALUE Open (
         const FILEPATH& filepath         
         );

      ERRVALUE PutBegin (
         const char *tagname,             
         UINT16 version = 0               
         );

      ERRVALUE PutDouble (
         const char *tagname,             
         double value                     
         );

      ERRVALUE PutEnd (
         );

      ERRVALUE PutInt (
         const char *tagname,             
         int value                        
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const COLOR& color               
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const DPOINT2D& point2d          
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const DPOINT3D& point3d          
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const DRECT2D& rect              
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const DRECT3D& rect              
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const LPOINT2D& point2d          
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const LRECT2D& rect              
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const DOUBLE_RANGE& value        
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const OLDPROJPARM& oldprojparm   
         );

      ERRVALUE PutItem (
         const char *tagname,             
         const SPATREF::COORDREFSYS& crs  
         );

      ERRVALUE PutStr (
         const char *tagname,             
         const MIUNICODE *str             
         );

      ERRVALUE PutStrML (
         const char *tagname,             
         const MIUNICODE *str             
         );

      ERRVALUE PutUnsigned (
         const char *tagname,             
         unsigned int value               
         );

      ERRVALUE Read (
         SERIALIZABLE& object             
         );

      ERRVALUE Read (
         const char *tagname,             
         SERIALIZABLE& object             
         );

      ERRVALUE Read (
         const SERIALIZERITEM *itemdef,   
         void *data                       
         );

      ERRVALUE Read (
         const char *tagname,             
         const SERIALIZERITEM *itemdef,   
         void *data                       
         );

      ERRVALUE Read (
         OLDPROJPARM& oldprojparm
         );

      ERRVALUE Rewind (
         );

      void SetIgnoreSkippable (
         bool IgnoreSkippable = true      
         ) { m_IgnoreSkippable = IgnoreSkippable; }

      void SetScanOnly (
         bool ScanOnly                    
         ) { m_ScanOnly = ScanOnly; }

      void SetVersion (
         UINT16 Version                   
         ) { m_Version[m_depth] = Version; }

      ERRVALUE SkipStruct (
         );

      ERRVALUE StatusTextUpdate (
         const MISTRING& string
         );

      ERRVALUE Write (
         const SERIALIZERITEM *itemdef,   
         const void *data                 
         );

      ERRVALUE Write (
         const char *tagname,             
         const SERIALIZERITEM *itemdef,   
         const void *data,                
         UINT16 version = 0               
         );

      ERRVALUE Write (
         const SERIALIZABLE& object,      
         const char *tagname = 0          
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      FILEPATH m_filepath;                // Path to file
      RVC::DESCRIPTOR m_Descriptor;       // Descriptor to open RVC text object
      FILE_TEXT *m_pFileText;             // Text file instance if non-RVC
      RVC::SERIALIZE m_SerialObj;         // RVC Serialize instance if Text object
      int m_depth;                        // Current depth
      UINT16 m_Version[128];              // Version at current depth
      char m_itemname[128];
      MISTRING m_parmvalue;               // Last parameter value
      MISTATUSCONTEXT *m_pStatusContext;
      INT32 m_filesize;                   // Size of file/object being read for status update
      INT32 m_filepos;                    // Position in file/object for status update
      bool m_IgnoreSkippable;
      bool m_ScanOnly;
      RVC::OBJITEMLIST m_ScanFileObjListUsed;
      RVC::OBJITEMLIST m_ScanFileObjListMissing;
      MISTRING m_Log;
      RVC::OBJECT::AUTOFILECACHE m_AutoFileCache;

      static const SERIALIZERITEM* GetItemDefREGION2D ();
      static const SERIALIZERITEM* GetItemDefSUBREGION2D ();

      // Call callback for item if necessary.
      ERRVALUE CallItemCB (
         const SERIALIZERITEM *itemdef,
         void *data,                      // Callback data
         SERIALIZERITEM::ACTION action          // Callback action
         );

      // Find link file, add to missing file list if can't find it.
      ERRVALUE FindLinkFile (
         const SERIALIZERITEM *parmdp,
         const UINT8* data,
         FILEPATH& linkfilepath,
         bool OriginalFirst = false
         );

      // Find object.
      int FindObject (
         const SERIALIZERITEM *parmdp,
         const SERIALIZERITEM *startdp,
         UINT8 *data
         );

      // Get multi-line string (Unicode).
      ERRVALUE GetStrML (
         MIUNICODE **str                     // XXX change to MISTRING&
         );

      // Get multi-line string (ASCII or RAW).
      ERRVALUE GetStrML (
         char **str,
         bool raw = false  
         );

      // 
      ERRVALUE PutStr (
         const char *tagname,
         const char *str
         );

      // 
      ERRVALUE PutStrML (
         const char *tagname,
         const char *str
         );

      // 
      ERRVALUE ReadLine (
         MISTRING& string,
         bool raw = false
         );

      // Write single-line MIUNICODE string.
      ERRVALUE WriteText (
         const MIUNICODE *str             // String to write
         );

      // Write ASCII string.
      ERRVALUE WriteText (
         const char *str                  // String to write
         );

      SERIALIZER (const SERIALIZER&);
      SERIALIZER& operator= (const SERIALIZER&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//=====================================================================================================================

#ifdef WIN32
#pragma warning (default:4996)   // Restore warning about deprecated declaration
#endif

#endif   // INC_MI32_SERIALIZER_H

---