HashFile.h

Go to the documentation of this file.

// BC  1/10/2005  \BobL120\Include\HashFile.h

#define __HASHFILE_H

#ifndef __STRCLASS_H
#include "StrClass.h"
#endif
#include <afxtempl.h>

#define NUMSTATUSSUBDIVISIONS  100

// productversion = 5.0 // original version 5.0 set in constructor
// productversion = 6.0 // bitfields were moved from CP to SegmentCP/ChannelCP to add ZEROSLOPE interpolation
// productversion = 6.1 // 0-based/time-based frame numbering, focallength corrected
// productversion = 7.0 // time written in ticks (1/135000 second)
// productversion = 8.51 // fixed spherical combiner ring sizes scaled by UNIT
// productversion = 9.0 // Um... total rewrite
// productversion = 9.01 // 9.0 now has compact muscle
// productversion = 9.02 // 9.0o stores default pose application on userproperty not relation
// PRODUCTVERSION = 9.03 // stores constdrivers different
// PRODUCTVERSION = 9.04 // loads > 8.5, < 9.04 camera.m_globalambience with correct factor
// PRODUCTVERSION = 9.50 // property drivers that are not in actions now save as regular children of the HashObject instead of embedded in the Property
// PRODUCTVERSION = 9.51 // attempt to fix 9.5o animobjectshortcuts and emptydrivers with m_matchname == ""
// PRODUCTVERSION = 9.52 // ignore defalutvalue and displayposeslider labels on load on constdrivers
// PRODUCTVERSION = 9.53 // destroy bogus (all) constdrivers on object cache property from < 9.53
// PRODUCTVERSION = 10.00 // same as 9.53
// PRODUCTVERSION = 10.01 // matchnames of linked objects contains full path in memory and relative path on disk objects|((char)254)thom((char)255)mdl.property
// PRODUCTVERSION = 10.02 // repairs previous versions bogus emptydrivers under root folders
// PRODUCTVERSION = 10.03 // uses quotes to seperate linked object matchnames objects|"thom.mdl".property
// PRODUCTVERSION = 10.04 // distort boxes are modeled longer if the res is larger.
// PRODUCTVERSION = 10.05 // removed unnecessary leaf level empty drivers from motion files
// PRODUCTVERSION = 10.06 // to fix earlier texture node properties being not set on blobby caches etc
// PRODUCTVERSION = 10.07 // to fix fig cache actionshortcutcontainer being at head instead of tail so it loads constdrivers correctly

// PRODUCTVERSION = 10.50  // Same as 10.05
// PRODUCTVERSION = 10.51  // Same as 10.07
// PRODUCTVERSION = 10.52  // New specularsize calculation
// PRODUCTVERSION = 10.53  // Duplicate constraints are no longer caused by copy/paste, or removed on load.
// PRODUCTVERSION = 10.54  // Fixed lightlist nodes using cache treename in figure::onnotifyendprojectload and save
// PRODUCTVERSION = 10.55  // Moved constraints that are under transforms to be under parent (Poses still had bug and now are fixed)
// PRODUCTVERSION = 10.56  // Changed ambiance to be a color

// PRODUCTVERSION = 11.00  // New release, also rotatedrivers in poses don't save parenttobone
// PRODUCTVERSION = 11.01  // Move chor group container to top of sibling list
// PRODUCTVERSION = 11.02  // Fixed reversed z for XY plane vertical markers (left or right view in horizontal ruler) 
// PRODUCTVERSION = 11.03  // Convert 1DMultiDs to Channels for niels
// PRODUCTVERSION = 11.04  // Convert hair density from density along side to area density (so its linear) 
// PRODUCTVERSION = 11.50  // 
// PRODUCTVERSION = 11.51  // Convert hair density from density along side to area density (so its linear) 
// PRODUCTVERSION = 12.00  // BufferShortcut relative paths to image 08/08/05

#define PRODUCTVERSION  12.00f

class FileStream;
class MemoryStream;
class Time;
class Vector2;
class Vector;
class Vector4;
class RGBFloat;
class ColorBuf;
class TimeRange;
class HashMarker;
class PatchID;
class Rotate;
class Matrix33;
class Matrix34;
class Matrix44;
class Quaternion;
class RenderInfoParms;
class RenderStatusInfo;
class StreamMsg;

class FILEIOEXPORT Label {
public:
   LONG   id;
   char   string[80];
   
   Label() {}
   Label( LONG id );
   Label( char *text );
   char *GetText() { return string; }
};

class FILEIOEXPORT Header {
public:
   LONG   id;
   char   string[80];
   
   Header() {}
   Header( LONG id );
   Header( LONG pid, const char *buffer )
   {
      id = pid;
      strcpy( string, buffer );
   }
   int operator == ( const Header &header ) const { return (id == header.id); }
   char *GetText() { return string; }
};

class FILEIOEXPORT StreamBOOL {
public:
   BOOL m_bool;

   StreamBOOL() {}
   StreamBOOL( BOOL pbool ) { m_bool = pbool; }
};

LONG GetLabelIDFromString( char *string );
LONG GetHeaderIDFromString( char *string );
BOOL GetLabelStringFromID( LONG pid, char *string );
void GetHeaderStringFromID( LONG pid, char *string );
FILEIOEXPORT BOOL IsFileOfType( const String &filename, LONG headerid );
FILEIOEXPORT BOOL IsFileOfTypeHash( String &filename );
FILEIOEXPORT void FreeHashFileToken();

class FILEIOEXPORT HashStream {
protected:
   LONG       filesize, mode;
   LONG       nextstatuspos, statusposincrement;
   String     m_prevprogresstext;
   BOOL       m_bwasprogressinitializedbyme;

public:
   String filename;
   float      m_productversion;

   enum { HS_STORE=0, HS_LOAD=1, HS_ASCII=0, HS_BINARY=2, HS_BYTESWAP=4, HS_APPEND=8, 
               HS_FAILED=16, HS_HASH=32 };

   enum SeekMode { HS_BEGINNING, HS_END, HS_OFFSET };
   
   HashStream() { m_bwasprogressinitializedbyme = FALSE; }
   virtual ~HashStream();

#if _MEMDEBUG
   void *operator new( size_t size, char *file, const int line ) { return ALLOCEXT( size, file, line ); }
#else
   void *operator new( size_t size ) { return AllocExt( size ); }
#endif   
   void  operator delete( void *ptr ) { FreeExt( ptr ); }

// Attributes
   BOOL IsLoading() const { return mode & HS_LOAD; }
   BOOL IsStoring() const { return !IsLoading(); }
   BOOL IsAppend() const { return mode & HS_APPEND; }
   BOOL IsBinary() const { return mode & HS_BINARY; }
   void OnBinary() { mode |= HS_BINARY; }
   BOOL IsAscii() const { return !IsBinary(); }
   void OnAscii() { mode |= HS_ASCII; }
   BOOL IsHash() const { return mode & HS_HASH; }
   BOOL IsByteSwap() const { return mode & HS_BYTESWAP; }
   void OnFailed() { mode |= HS_FAILED; }
   void OffFailed() { mode &= ~HS_FAILED; }
   BOOL IsFailed() { BOOL rval = mode&HS_FAILED; OffFailed(); return rval; }
   void SetMode( LONG pmode ) { mode = pmode; }
   LONG GetMode() { return mode; }
   BOOL SkipPast( UINT id );

   CRuntimeClass* PASCAL LoadRuntimeClass(UINT* pwSchemaNum);
   void StoreRuntimeClass(CRuntimeClass *rtc);

// Operations
   // PURE VIRTUALS
   virtual UINT ReadC( void* buf, LONG count ) = 0;
   virtual void Read( void* buf, LONG count ) = 0;
   virtual void Write( const void* buf, LONG count ) = 0;
   virtual void Flush() = 0;
   virtual void Close() = 0;
   virtual BOOL ReadLine( String &line ) = 0;           // READS UP TO nl, STORES IN STRING
   virtual BOOL ReadLine( MemoryStream &stream ) = 0;   // READS UP TO nl, STORES IN MemoryStream (BINARY OR ASCII matches this)
   virtual void ParseString( String &token ) = 0;
   virtual void ParseToken( String &token ) = 0;
   virtual void ParseToken( char *token, char delim ) = 0;
   virtual void Seek( int pos, SeekMode seekmode ) = 0;
   virtual LONG GetPos() = 0;

   // reading and writing strings
   void WriteLine( String &line );          // AUTOMATICALLY APPENDS A nl AT END OF STRING (BINARY OR ASCII)
   void SetStatusMeter();
   BOOL SkipHeader(Header &header);
   String ReadString( char delimit );
   void ParseToken( String &token, char delim );

public:
   // Object I/O is pointer based to avoid added construction overhead.
   // Use the Serialize member function directly for embedded objects.
/*   friend HashStream&  operator<<(HashStream& hs, const HashObject* hob);
   friend HashStream& AFXAPI operator>>(HashStream& hs, HashObject*& hob);
   friend HashStream& AFXAPI operator>>(HashStream& hs, const HashObject*& hob);*/

   // insertion operations
   HashStream& operator<<(SBYTE sb);
   HashStream& operator<<(UBYTE ub);
   HashStream& operator<<(SWORD w);
   HashStream& operator<<(UWORD w);
   HashStream& operator<<(LONG l);
   HashStream& operator<<(ULONG ul);
   HashStream& operator<<(float f);
   HashStream& operator<<(double d);
   HashStream& operator<<(int i);
   HashStream& operator<<(UINT i);
   HashStream& operator<<(char ch);
   HashStream& operator<<(char *text);
   HashStream& operator<<(const String &st);
   HashStream& operator<<(Time time);
   HashStream& operator<<(const Vector2 &v);
   HashStream& operator<<(const Vector &v);
   HashStream& operator<<(const RGBFloat &cv);
   HashStream& operator<<(const ColorBuf &cb);
   HashStream& operator<<(const BITMAPINFO &bi);
   HashStream& operator<<(const BITMAPINFOHEADER &h);
   HashStream& operator<<(const BITMAPFILEHEADER &h);
   HashStream& operator<<(const HICON &hicon);
   HashStream& operator<<(const TimeRange &fr);
   HashStream& operator<<(const HashMarker *fr);
   HashStream& operator<<(const PatchID &patchid);
   HashStream& operator<<(const Label &lb);
   HashStream& operator<<(const Header &hd);
   HashStream& operator<<(const StreamBOOL& obj);
   HashStream& operator<<(const Rotate &rot);
   HashStream& operator<<(const Vector4 &v );
   HashStream& operator<<(const Matrix33 &m );
   HashStream& operator<<(const Matrix34 &m );
   HashStream& operator<<(const Matrix44 &m );
   HashStream& operator<<(const Quaternion &q );
   HashStream& operator<<(const COleDateTime &dateSrc);
   HashStream& operator<<(const CTime &dateSrc);
   
   HashStream& operator<<( HashStream& (__cdecl * function)(HashStream&))
    { (*function)(*this); return *this; }

   // extraction operations
   HashStream& operator>>(SBYTE &sb);
   HashStream& operator>>(UBYTE &ub);
   HashStream& operator>>(SWORD &sw);
   HashStream& operator>>(UWORD &uw);
   HashStream& operator>>(LONG &l);
   HashStream& operator>>(ULONG &ul);
   HashStream& operator>>(float &f);
   HashStream& operator>>(double &d);
   HashStream& operator>>(int &i);
   HashStream& operator>>(UINT &i);
   HashStream& operator>>(char &ch);
   HashStream& operator>>(String &st);
   HashStream& operator>>(Time &time);
   HashStream& operator>>(Vector2 &v);
   HashStream& operator>>(Vector &v);
   HashStream& operator>>(RGBFloat &cv);
   HashStream& operator>>(ColorBuf &cb);
   HashStream& operator>>(HICON &hicon);
   HashStream& operator>>(TimeRange &fr);
   HashStream& operator>>(HashMarker *fr);
   HashStream& operator>>(PatchID &patchid);
   HashStream& operator>>(Label &lb);
   HashStream& operator>>(Header &hd);
   HashStream& operator>>(StreamBOOL &obj);
   HashStream& operator>>(Rotate &rot);
   HashStream& operator>>(Vector4& v);
   HashStream& operator>>(Matrix33& m);
   HashStream& operator>>(Matrix34& m);
   HashStream& operator>>(Matrix44& m);
   HashStream& operator>>(Quaternion& q);
   HashStream& operator>>(BITMAPINFOHEADER &h);
   HashStream& operator>>(BITMAPFILEHEADER &h);
   HashStream& operator>>(COleDateTime& dateSrc);
   HashStream& operator>>(CTime& dateSrc);
};

FILEIOEXPORT HashStream& sp( HashStream& hs );
FILEIOEXPORT HashStream& spb( HashStream& hs );
FILEIOEXPORT HashStream& nl( HashStream& hs );
FILEIOEXPORT HashStream& nlb( HashStream& hs );
FILEIOEXPORT HashStream& tab( HashStream& hs );
FILEIOEXPORT HashStream& tabb( HashStream& hs );

class PathAlias;
class FileAlias;

class FILEIOEXPORT FileStream : public HashStream
{
protected:
   static  CList<String, String &> failedloadlist;
   static  PathAlias *pathaliashead;
   static  FileAlias *filealiashead;
   static  BOOL       m_bCancelAll;
   CStdioFile         file;
   String             m_tempname;

public:
   FileStream();
   
   virtual ~FileStream();

   
   BOOL    Open( const String &filename, LONG mode=0 ); // DEFAULT IS 0, WHICH IS STORING, ASCII NOBYTESWAP, NOTAPPENDING
   BOOL    Open( String &filename, LONG mode=0 );//Keep for backward compat w/ plugins
   BOOL    Open( int filenumber );
   BOOL    Eof();
   long GetLength() {return filesize;}

   virtual UINT ReadC(void* buf, LONG count );
   virtual void Read(void* buf, LONG count );
   virtual void Write(const void* buf, LONG count );
   virtual void Flush();
   virtual void Close();
   virtual BOOL ReadLine( String &line );           // READS UP TO nl, STORES IN STRING
   virtual BOOL ReadLine( MemoryStream &stream );   // READS UP TO nl, STORES IN MemoryStream (BINARY OR ASCII matches this)
   virtual void ParseString( String &token );
   virtual void ParseToken( String &token );
   virtual void ParseToken( char *token, char delim );
   virtual void Seek( int pos, SeekMode seekmode );
   virtual LONG GetPos();

   static BOOL FindAliasAsk( String &filename );
   static BOOL FindFileAlias( String &filename );
   static BOOL FindFileAliasNameOnly( String &filename );
   static BOOL FindPathAlias( String &pathname );
   static void AddFileAlias( const String &oldfilename, const String &newfilename );
   static void AddPathAlias( const String &oldpathname, const String &newpathname );
   static void FreeFileAliases();
   static void FreePathAliases();
   static BOOL FindAlias( String &filename );
   static BOOL IsInFailedList(String &filename);
   static void ClearFailedList();
   static void ResetCancelAll();
};

class StreamError
{
public:
   StreamError() {}
};

class FILEIOEXPORT MemoryStream : public HashStream
{
public:
   char *buf;
   LONG pos;
   LONG len;
   LONG blocklen;

   MemoryStream() { Init(); mode = HS_ASCII; }
   MemoryStream( int size );
   MemoryStream( LONG mode ) { Init(); Open(mode); }
   MemoryStream( const MemoryStream &ms ) { Init(); Open( ms.buf, ms.len, ms.mode ); }
   virtual ~MemoryStream();
   void Init();
   void SetSize(int size);

   MemoryStream &operator = ( const MemoryStream &other ) {
      Empty();
      Open( other.buf, other.len, other.mode );
      return *this;
   }

   BOOL Open( LONG mode );
   BOOL Open( String &filename, LONG mode=0 ); // DEFAULT IS 0, WHICH IS STORING, ASCII NOBYTESWAP, NOTAPPENDING
   BOOL Open( char *initbuf, LONG count, LONG mode );
   BOOL Eof() { return pos >= len; }
   void Empty();
   LONG GetLength() { return len; }

   void SetStatusMeter();

   virtual UINT ReadC(void* buf, LONG count );
   virtual void Read(void* buf, LONG count );
   virtual void Write(const void* buf, LONG count );
   virtual void Flush() {}
   virtual void Close() {}
   virtual BOOL ReadLine( String &line );           // READS UP TO nl, STORES IN STRING
   virtual BOOL ReadLine( MemoryStream &stream );   // READS UP TO nl, STORES IN MemoryStream (BINARY OR ASCII matches this)
   virtual void ParseString( String &token );
   virtual void ParseToken( String &token );
   virtual void ParseToken( char *token, char delim );
   virtual void Seek( int pos, SeekMode seekmode );
   virtual LONG GetPos() { return pos; }

   BOOL MemoryStream::IsLabel()
   {
      char *ch;
      for (ch=buf+pos; ch < buf+len-1 && *ch != '='; ch++);
      return *ch == '=';
   }
   BOOL MemoryStream::IsHeader()
   {
      return (buf[pos] == '[');
   }
   BOOL MemoryStream::IsHeaderAt0()
   {
      return (buf[0] == '[');
   }
   BOOL IsEndHeaderAt0() { return len>=4 && buf[0]=='[' && buf[1]=='E' && buf[2]=='n' && buf[3]=='d'; }
};

inline Header LabelAsHeader( const Label &label )
{
   return Header( label.id, label.string );
}

inline Header LabelAsEndHeader( const Label &label )
{
   return Header( label.id, (String("End") + label.string).Get());
}

---