rvc/object.h

Go to the documentation of this file.

#ifndef INC_RVC_OBJECT_H
#define INC_RVC_OBJECT_H

#ifndef INC_RVC_OTYPESET_H
   #include <rvc/otypeset.h>
#endif

#ifndef INC_RVC_OBJECTNAME_H
   #include <rvc/objectname.h>
#endif

#ifndef INC_MI32_RVCDATETIME_H
   #include <mi32/rvcdatetime.h>
#endif

#ifndef  INC_MI32_OBSERVER_H
   #include <mi32/observer.h>
#endif

#ifndef  INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef  INC_RVC_CREDENTIALS_H
   #include <rvc/credentials.h>
#endif

#ifndef INC_RVC_OBJITEM_H
   #include <rvc/objitem.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
enum BYTESWAP {
   BYTESWAP_LoHi,
   BYTESWAP_HiLo
   };
class MISTRING;
class DATETIME;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
struct ANYCALLBACKSTRUCT;
struct GENINFO;
class OBJITEM;
class OBJITEMLIST;
class FILEHANDLE;
class OBJECTOBSERVER;
class DESCRIPTOR;
class OBJMAKEPARMS;
class OBJOPENPARMS;
#endif // GENERATING_DOXYGEN_OUTPUT
   
#ifdef RVC_CREDENTIALS_MANDATORY
#define RVC_DEFAULT_CREDENTIALS 
#else
#define RVC_DEFAULT_CREDENTIALS = 0
#endif

class OBJECT : public SUBJECT<OBJECTOBSERVER> {
   public:

      enum COPYFLAGS {
         COPYFLAG_None =                  0x00000000, 
         COPYFLAG_DontCopyChildren =      0x00000001, 
         COPYFLAG_CopySpatialFromLink =   0x00000002, 
         COPYFLAG_CopyDBTableFromLink =   0x00000004, 
         COPYFLAG_CopyRVCObjectFromLink = 0x00000008, 
         COPYFLAG_CopyTextFromLink =      0x00000010, 
         COPYFLAG_DontCopyStdAttTables =  0x00000020, 
         COPYFLAG_ReportInvalidParent =   0x00000040, 
         COPYFLAG_ForceOneObjectCopy =    0x00000080, 
         COPYFLAG_CopyIfNotModifiable =   0x00000100, 
         COPYFLAG_CopyToEditFormat =      0x00000200, 
         COPYFLAG_NoUpdateEmbeddedNames = 0x00000400, 
         };
         
      enum DUMPINFOFLAGS {
         DUMPINFOFLAG_Minimal =           0x00000000,       // Default, dumps only minimal information
         DUMPINFOFLAG_Subobjects =        0x00000001,       // Dump sub-object information at the end of the log
         DUMPINFOFLAG_FullHeader =        0x00000002,       // Dump full header information into the log
         DUMPINFOFLAG_ObjectData =        0x00000004,       // Dump object data information into the log
         // Combination flags here
         DUMPINFOFLAG_Standard =          (DUMPINFOFLAG_Subobjects | DUMPINFOFLAG_FullHeader),
         DUMPINFOFLAG_Maximal =           (DUMPINFOFLAG_Subobjects | DUMPINFOFLAG_FullHeader | DUMPINFOFLAG_ObjectData)
         };
         
      enum LINKFILEFLAGS {
         LINKFILEFLAG_None =              0x00000000,       
         LINKFILEFLAG_SearchChildren =    0x00000001        
         };
         
      enum LOCKSTATE {
         LOCKSTATE_Unlocked,                       
         LOCKSTATE_CurrentOpenReadIsWritable,      
         LOCKSTATE_CurrentOpenReadNotWritable,     
         LOCKSTATE_CurrentOpenWrite,               
         LOCKSTATE_ExternalOpenRead,               
         LOCKSTATE_ExternalOpenWrite,              
         LOCKSTATE_ExternalReadLockFile,           
         LOCKSTATE_ExternalWriteLockFile           
         };
         
      enum OPENMODE {               
         OPENMODE_NotOpen = 0,      
         OPENMODE_Read,             
         OPENMODE_Write,            
         OPENMODE_WriteAttempt,     
         OPENMODE_ReadNoLock,       
         OPENMODE_WriteAbsolute,    
         OPENMODE_ReadAbsolute,     
         OPENMODE_WriteNoLock,      
         OPENMODE_ReadNoDialog,     
         OPENMODE_ReadNoScanAutoLink,  
         OPENMODE_WriteNoDialog     
         };

      enum TEMPFILE {
         TEMPFILE_DeleteOnClose = 0x00000100,
         TEMPFILE_DeleteOnExit =  0x00000200
         };
      
      // NESTED CLASSES
      // FORWARD Declarations
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class CONST_ITERATOR;
      friend class CONST_ITERATOR;
      class ITERATOR;
      friend class ITERATOR;
      class FILTER;
      class FILTER_OBJTYPESET;
      class FILTER_NEWERTHANPARENT;
      class TOPLEVELNAMECHANGE;
      friend class TOPLEVELNAMECHANGE;
      class UNIQUENAMEFILTER;
      class UNIQUECHILDNAMEFILTER;
      #endif // GENERATING_DOXYGEN_OUTPUT

      class AUTOFILECACHE {
         public:
            AUTOFILECACHE ()
               { OBJECT::CacheEnable(); }
            ~AUTOFILECACHE ()
               { OBJECT::CacheDisable(); }
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            // Not allowed.
            AUTOFILECACHE (const AUTOFILECACHE&);
            AUTOFILECACHE& operator= (const AUTOFILECACHE&);
            #endif
         };

      class LINKITEM {
         public:
            const FILEPATH& GetFilename (
               ) const { return (m_Filename); }
         
            const MISTRING& GetObjName (
               ) const { return (m_ObjName); }
         
            const OBJITEM& GetSrcObjItem (
               ) const { return (m_SrcObjItem); }
               
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            FILEPATH m_Filename;
            MISTRING m_ObjName;
            OBJITEM m_SrcObjItem;            
            
            friend class OBJECT;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
      typedef MILIST<LINKITEM> LINKITEMLIST;

      OBJECT (                   
         );

      OBJECT (                   
         const RVC::OBJECT& obj
         );

      virtual ~OBJECT (
         );

      RVC::OBJECT& operator= (               
         const RVC::OBJECT& rhs
         );

      operator RVC::OBJITEM (
         ) const;

      ERRVALUE Attach (
         const FILEPATH& FilePath,        
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE Attach (
         const RVC::OBJITEM& ObjItem,        
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE Attach (
         const FILEPATH& FilePath,        
         const MISTRING& ObjectPath,         
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE Attach (
         const RVC::OBJECT& parent,          
         const RVC::OBJTYPE ObjType,         
         const RVC::OBJECTNAME& ShortName,      
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE Attach (
         const RVC::OBJECT& parent,          
         const RVC::OBJTYPE ObjType,         
         const RVC::DESCRIPTOR& Descriptor,  
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE Attach (
         const RVC::OBJECT& source,       
         const MIUNICODE *filename,       
         const MISTRING& ObjectPath,         
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE Attach (
         const RVC::OBJECT& twin,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE AttachToParent (
         const RVC::OBJITEM& ObjItem,        
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      bool CanOpenForWrite (                 
         ) const;

      ERRVALUE ChangeDescriptor (
         const DESCRIPTOR& NewDescriptor,       
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE ChangeObjectLink (
         const FILEPATH& Filename,
         const MISTRING& ObjName,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS   
         );

      ERRVALUE ChangeSource (
         const RVC::OBJECTSOURCE& NewSource,    
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE ChangeTempFileMode (
         TEMPFILE flags
         );
         
      CONST_ITERATOR ChildListBegin (        
         RVC::OBJTYPE m_ObjType                 
         ) const;
      
      ITERATOR ChildListBegin (           
         RVC::OBJTYPE m_ObjType                 
         );

      CONST_ITERATOR ChildListEnd (       
         ) const;

      ITERATOR ChildListEnd (             
         );

      ERRVALUE Close (                 
         );

      INT64 ComputeProjectFileFreeSpace (
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         ) const;
         
      ERRVALUE CopyTo (
         RVC::OBJECT& DestParentObj,         
         RVC::OBJECT& DestObj,               
#ifdef RVC_CREDENTIALS_MANDATORY
         COPYFLAGS CopyFlags,
#else
         COPYFLAGS CopyFlags = COPYFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         ) const;

      ERRVALUE CopyTo (
         RVC::OBJECT& DestParentObj,         
         RVC::OBJECT& DestObj,               
         const DESCRIPTOR& Descriptor,       
#ifdef RVC_CREDENTIALS_MANDATORY
         COPYFLAGS CopyFlags,
#else
         COPYFLAGS CopyFlags = COPYFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         ) const;

      ERRVALUE CopyTo (
         RVC::OBJECT& DestParentObj,         
         RVC::OBJECT& DestObj,               
         FILTER& filter,                     
#ifdef RVC_CREDENTIALS_MANDATORY
         COPYFLAGS CopyFlags,
#else
         COPYFLAGS CopyFlags = COPYFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         ) const;

      ERRVALUE CopyTo (
         RVC::OBJECT& DestParentObj,         
         RVC::OBJECT& DestObj,               
         FILTER& filter,                     
         const DESCRIPTOR& Descriptor,       
#ifdef RVC_CREDENTIALS_MANDATORY
         COPYFLAGS CopyFlags,
#else
         COPYFLAGS CopyFlags = COPYFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         ) const;

      ERRVALUE CopyChildrenTo (
         RVC::OBJECT& DestParentObj,         
#ifdef RVC_CREDENTIALS_MANDATORY
         COPYFLAGS CopyFlags,
#else
         COPYFLAGS CopyFlags = COPYFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         ) const;

      ERRVALUE CopyChildrenTo (
         RVC::OBJECT& DestParentObj,         
         FILTER& filter,                     
#ifdef RVC_CREDENTIALS_MANDATORY
         COPYFLAGS CopyFlags,
#else
         COPYFLAGS CopyFlags = COPYFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         ) const;

      ERRVALUE Delete (                
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      void Detach (                    
         );

      ERRVALUE DumpObjectInfo (
         MISTRING& LogString,
#ifdef RVC_CREDENTIALS_MANDATORY
         DUMPINFOFLAGS DumpInfoFlags,
#else
         DUMPINFOFLAGS DumpInfoFlags = DUMPINFOFLAG_Minimal,   
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         );

      static void DumpOpenFileList (
         MISTRING& result,
         bool IncludeOpenObjects = true
         );
         
      bool FindChild (                 
         RVC::OBJECT& Child,                 
         const RVC::OBJECTNAME& name            
         ) const;

      bool FindChild (                 
         RVC::OBJECT& Child,                 
         const RVC::OBJECTNAME& name,        
         FILTER& filter                      
         ) const;

      bool FindChild (                 
         RVC::OBJECT& Child,                 
         const MISTRING& ObjectPath       
         ) const;

      bool FindChild (
         RVC::OBJECT& Child,                 
         const RVC::DESCRIPTOR& Descriptor
         ) const;

      bool FindChild (
         RVC::OBJECT& Child,                 
         const RVC::DESCRIPTOR& Descriptor,
         FILTER& filter                      
         ) const;

      bool FindChildLastUsed (            
         RVC::OBJECT& Child                  
         ) const;

      bool FindChildLastUsed (         
         RVC::OBJECT& Child,           
         FILTER& filter                
         ) const;

      ERRVALUE FlushFile (
         );

      static ERRVALUE GenerateLockNames (
         const FILEPATH& SourceFile,         
         FILEPATH& lokfilepath,              
         FILEPATH* kolfilepath = 0           
         );

      static ERRVALUE GenerateUniqueDescriptor (
         RVC::DESCRIPTOR& Descriptor,
         UNIQUENAMEFILTER& filter
         );

      static ERRVALUE GenerateUniqueName (
         RVC::OBJECTNAME& name,
         UNIQUENAMEFILTER& filter
         );

      static ERRVALUE GetAutoLinkCachePath (
         FILEPATH& rvcfilepath,
         const FILEPATH& extfilepath
         );
         
      static void GetAutoLinkLocalPath (
         FILEPATH& rvcfilepath,
         const FILEPATH& extfilepath
         );

      static void GetAutoLinkPatternList (
         const OBJTYPESET& objtypeset,       
         MISTRINGLIST& patternlist           
         );
   
      INT32 GetChildCount (
         RVC::OBJTYPE otype = RVC::OBJTYPE_All           
         ) const;

      INT32 GetChildCount (
         RVC::OBJTYPE otype,              
         FILTER& filter                   
         ) const;

      INT32 GetChildList (
         RVC::OBJTYPE ObjType,            
         RVC::OBJITEMLIST& ObjItemList,   
         FILTER* filter = 0               
         ) const;

      static char GetChildSeparator (
         ) { return (' '); }

      const CREDENTIALS& GetCredentials (
         ) const { return (m_Credentials); }
      
      ERRVALUE GetDescriptor (
         RVC::DESCRIPTOR& Descriptor,        
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         ) const;

      RVC::OBJTYPE GetDftObjectType (
         ) const;

      static ERRVALUE GetExternalFileDescription (
         const FILEPATH& extfilepath,        
         MISTRING& description               
         );
      
      static ERRVALUE GetExternalProjectFileLink (
         const FILEPATH& extfilepath,        
         FILEPATH& ProjectFileLink           
         );

      static ERRVALUE GetFileObjItem (
         const FILEPATH& Filename, 
         RVC::OBJITEM& ObjItem,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         );
         
      const FILEPATH& GetFilePath (
         ) const;

      const FILEPATH& GetFilePathLink (
         ) const;

   #ifndef NO_DEPRECATED
      DEPRECATED RVCINODENUM GetInodeNum (            
         ) const { return (GetInodeNumPro()); }
   #endif
   
      ERRVALUE GetLinkedFiles (
         LINKITEMLIST& LinkFileList,
#ifdef RVC_CREDENTIALS_MANDATORY
         LINKFILEFLAGS LinkFileFlags,
#else
         LINKFILEFLAGS LinkFileFlags = LINKFILEFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         ) const;

      // Get the metadata for this object
      ERRVALUE GetMetadata (
         SIMPLE_ARRAY<UINT8>& buffer,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         ) const;
         
      static const char* GetObjectIconName (
         OBJTYPE ObjType
         );

      DEPRECATED ERRVALUE GetObjectItem (
         RVC::OBJITEM& ObjectItem            
         ) const;

      ERRVALUE GetObjectPath (
         MISTRING& ObjectPath          
         ) const;

      static const char* GetObjectTagFromObjectType (
         RVC::OBJTYPE ObjType
         );

      RVC::OBJTYPE GetObjectType (
         ) const;
      
      static RVC::OBJTYPE GetObjectTypeFromTag (
         const char* tag
         );

      static RVC::OBJTYPE GetObjectTypeFromTag (
         const MIUNICODE* tag
         );

      ERRVALUE GetObjItem (
         RVC::OBJITEM& ObjectItem            
         ) const;

      ERRVALUE GetParent (
         RVC::OBJECT& ObjParent              
         ) const { return (v_GetParent(ObjParent)); }

      ERRVALUE GetParentStack (
         RVC::OBJITEMLIST& ParentStack             
         ) const;

      ERRVALUE GetProductVersion (
         UINT16& ProductVersion           
         ) const;

      static LOCKSTATE GetProjectFileLockState (
         const FILEPATH& ProjectFile,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         );

      ERRVALUE GetSize (
         UINT64& size                  
         ) const;

      ERRVALUE GetSource (
         RVC::OBJECTSOURCE& Source           
         ) const;
         
      static TEXTID GetTextIDFromObjectType (
         OBJTYPE ObjType
         );

      void GetTimeCreate (
         DATETIME& Create              
         ) const;

      ERRVALUE GetTimeLastMod (
         DATETIME& LastMod             
         ) const;

      ERRVALUE GetTimeLastUsed (
         DATETIME& LastUsed               
         ) const;
         
      static char GetTypeSeparator (
         ) { return ('.'); }
         
      INT32 GetUndoNumLevels (
         ) const;

      bool IsAttached (
         ) const;
         
      bool IsChildOf (
         const RVC::OBJECT& parent           
         ) const;

      static bool IsCopyable (
         RVC::OBJTYPE ObjType
         );

      bool IsEqual (
         const RVC::OBJECT& rhs           
         ) const;
         
      bool IsFileLinked (
         ) const;

      bool IsFileObject (
         ) const;

      bool IsLiteCreated (
         ) const;

      bool IsObjectLinked (
         ) const;

      bool IsOlderThan (
         const RVC::OBJECT& Object
         ) const;

      bool IsOpen (
         ) const;
         
      static bool IsSystemInitialized (
         );

      bool IsTempFile (
         ) const;
      
      bool IsTopObject (
         ) const;             

      ERRVALUE IsValidParent (
         const RVC::OBJECT& DestParentObj
         ) const;
      
      static bool IsValidProjectFile (
         const FILEPATH& filename
         );
      
      bool IsWritable (
         ) const;

      ERRVALUE MakeFile (
         const FILEPATH& FilePath,        
         const MISTRING& desc             
         );

      ERRVALUE MakeLink (
         const RVC::OBJECT& LinkToObject,
         RVC::OBJECT& NewLinkObject,         
#ifdef RVC_CREDENTIALS_MANDATORY
         bool LinkToSubobjects,
#else
         bool LinkToSubobjects = false,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         );

      ERRVALUE MakeLink (
         const RVC::OBJECT& LinkToObject,
         RVC::OBJECT& NewLinkObject,         
         const DESCRIPTOR& Descriptor,
#ifdef RVC_CREDENTIALS_MANDATORY
         bool LinkToSubobjects,
#else
         bool LinkToSubobjects = false,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         );

      ERRVALUE MakeTempFile (
         TEMPFILE flags = TEMPFILE_DeleteOnClose      
         );

      ERRVALUE MoveTo (
         RVC::OBJECT& DestParentObj,         
#ifdef RVC_CREDENTIALS_MANDATORY
         COPYFLAGS CopyFlags,
#else
         COPYFLAGS CopyFlags = COPYFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         );

      ERRVALUE MoveTo (
         RVC::OBJECT& DestParentObj,         
         FILTER& filter,                     
#ifdef RVC_CREDENTIALS_MANDATORY
         COPYFLAGS CopyFlags,
#else
         COPYFLAGS CopyFlags = COPYFLAG_None,
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         );

      bool NeedNewerThanParent (
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS                     
         );

      ERRVALUE Open (
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,
         MDLGPARENT widget,
         const CREDENTIALS* Credentials      
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT widget = 0,              
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE Open (
         const RVC::OBJECT& twin,            
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT widget,            
         const CREDENTIALS* Credentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT widget = 0,           
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE Open (
         const RVC::OBJECT& parent,       
         const RVC::OBJTYPE ObjType,            
         const RVC::DESCRIPTOR& Descriptor,
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT widget,            
         const CREDENTIALS* Credentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT widget = 0,           
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE Open (
         const FILEPATH& FilePath,        
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT widget,            
         const CREDENTIALS* Credentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT widget = 0,           
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE Open (
         const RVC::OBJITEM& ObjItem,        
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT widget,            
         const CREDENTIALS* Credentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT widget = 0,           
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE Open (
         const FILEPATH& FilePath,        
         const MISTRING& ObjectPath,         
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT widget,            
         const CREDENTIALS* Credentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT widget = 0,           
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE Open (
         const RVC::OBJECT& source,       
         const MIUNICODE *filename,       
         const MISTRING& ObjectPath,         
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT widget,            
         const CREDENTIALS* Credentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT widget = 0,           
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE OpenParent (
         const RVC::OBJITEM& ObjItem,        
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT widget,            
         const CREDENTIALS* Credentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT widget = 0,           
         const CREDENTIALS* Credentials = 0  
#endif
         );
         
      static ERRVALUE PackProjectFile (
         const FILEPATH& ProjectFile,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE RecoverProjectFileTo (
         RVC::OBJECT& OutputObject,
         MISTRING& LogString,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS   
         );
   
      ERRVALUE RedoChanges (
         );
         
      ERRVALUE SaveObjectTo (
         RVC::OBJITEM& DestObjItem,                   
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         ) const;

      ERRVALUE SearchForInvalidChildObjects (
         bool SearchAllSubLevels,                     
         OBJITEMLIST& InvalidChildList,               
         OBJITEMLIST& SingletonChildList,             
         OBJITEMLIST& OutOfDateChildList,             
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         ) const;

      static void SetDisableCredentialQuery (
         bool value
         );
         
      // Get the metadata for this object
      ERRVALUE SetMetadata (
         const SIMPLE_ARRAY<UINT8>& buffer,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );
         
      ERRVALUE SetMinimumTNTVersion (
#ifdef RVC_CREDENTIALS_MANDATORY
         UINT16 Version,            
#else
         UINT16 Version = 0,        
#endif
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      static void SetMultiThreadMode (
         bool value
         );

      ERRVALUE SetTimeLastUsed (
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      ERRVALUE SetTimeLastUsed (
         const DATETIME& NewTime,            
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      ERRVALUE SetTimeLastMod (
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      ERRVALUE SetTimeLastMod (
         const DATETIME& NewTime,            
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      ERRVALUE SetUndoMaxLevel (
         INT32 NewLevel
         );

      static int TestUsableForLimit (
         const RVC::OBJITEM& objitem,
         UINT32 limitmode
         );
         
      static ERRVALUE TestUsableInLite (
         const RVC::OBJITEM& objitem
         );
   
      ERRVALUE TraverseLink (
         RVC::OBJECT& TraversedObject
         );
         
      ERRVALUE UndoChanges (
         bool SetRedo = false             
         );

      ERRVALUE UndoClear (
         );
         
      ERRVALUE UndoMark (
         );
      
      ERRVALUE UpdateFile (
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      ERRVALUE UpdateTimeLastUsed (
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );
         
      ERRVALUE ValidateFileMapping (
         MISTRING& LogString
         );
         
   protected:

      virtual ERRVALUE v_CopyObject (
         RVC::OBJECT& DestParentObj,         
         RVC::OBJECT& DestObj,               
         FILTER* filter,                     
         COPYFLAGS CopyFlags,
         const CREDENTIALS* Credentials      
         ) const;

      virtual ERRVALUE v_GetDescriptor (DESCRIPTOR& Descriptor, const CREDENTIALS* Credentials) const;

      void AssignInfo (const GENINFO& info);
      void AssignInode (RVCINODENUM inode);
      ERRVALUE AttachLow (const FILEPATH& FilePath, RVCINODENUM InodeNum, OPENMODE OpenMode, MDLGPARENT parent, const RVC::CREDENTIALS* Credentials);

      #ifndef GENERATING_DOXYGEN_OUTPUT
      void CallOnACLChanged ();
      void CallOnAttach ();
      void CallOnChildClosing (const OBJECT& object);
      void CallOnChildCreate (const OBJECT& object);
      void CallOnChildDestroying (const OBJECT& object);
      void CallOnChildOpen (const OBJECT& object);
      void CallOnClose ();
      void CallOnDecendentDescriptorChanged (const OBJECT& object);
      void CallOnDescriptorChanged ();
      void CallOnDestroy ();
      void CallOnDetach ();
      void CallOnNotifyRaw (UINT32 reason, void *data = 0);
      void CallOnUndoBegin ();
      void CallOnUndoEnd ();
      void CallOnUndoPossible ();
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      ERRVALUE CloseFile (             
         );

      void CopyObject (
         const RVC::OBJECT& rhs
         );
         
      RVC::FILEHANDLE* GetFileInstance (                 
         ) const;
      
      static RVCINODENUM GetInodeNum (          
         const RVC::OBJITEM& ObjItem            
         );
      
      RVCINODENUM GetInodeNumPro (
         ) const;
      
      ERRVALUE GetObjItem (
         RVCINODENUM InodeNum,         
         OBJITEM& ObjectItem           
         ) const;

      static ERRVALUE GetObjItem (
         const FILEPATH& FilePath,
         RVCINODENUM InodeNum,
         OBJITEM& ObjectItem           
         );

      OPENMODE GetOpenMode (           
         ) const;
      
      bool IsFileOpen (                
         ) const;
         
      bool IsObjectOpen (
         const OBJECT& Object
         ) const;

      ERRVALUE OpenFile (                 
         OPENMODE OpenMode,
         MDLGPARENT parent,
         const CREDENTIALS* Credentials                  
         );

      ERRVALUE OpenRVCFile (const FILEPATH& filepath, OPENMODE OpenMode, MDLGPARENT parent, const CREDENTIALS* Credentials);
      ERRVALUE ReadObjectHeader (GENINFO* ginfo, int HeaderSize, int HeaderType, const CREDENTIALS* Credentials) const;

      void SetInodeNum (   
         RVCINODENUM inode
         ) { m_InodeNum = inode; }

      void SetMakeObject (const RVC::OBJECT& rhs);

      void SetMakeParms (
         OBJMAKEPARMS& ObjMakeParms,
         const RVC::OBJECT& parent,
         const RVC::DESCRIPTOR& Descriptor, 
         GENINFO* newinfo, 
         int HeaderSize, 
         int HeaderType,
         const CREDENTIALS* Credentials
         ); 

      void SetOpenParms (
         OBJOPENPARMS& ObjOpenParms,
         const RVC::OBJECT& object,
         OPENMODE OpenMode,
         const CREDENTIALS* Credentials
         ); 

      ERRVALUE SetParent (const OBJITEM& ObjItem);
         
      UINT32 TranslateOpenFlags (            
         OPENMODE flags
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      FILEPATH m_FilePath;    
      FILEHANDLE *m_FileHandle;
      bool m_Attached;
      bool m_IsWritable;
      bool m_CanWrite;
      CREDENTIALS m_Credentials;

      // Members listed below are the members of GENINFO that are inmutable for multi-threading purposes
      RVCDATETIME m_Create;
      OBJTYPE m_ObjectType;
      RVCINODENUM m_InodeNum;
      
      class TEMPOPENOBJECT;
      friend class TEMPOPENOBJECT;
      class FILTERTYPE;
      friend class FILTERTYPE;
      class FILTERFUNC;
      friend class FILTERFUNC;

      OBJECT (                   
         const FILEHANDLE* FileHandle,
         RVCINODENUM InodeNum
         );

      bool operator== (const OBJECT& rhs) const;

      ERRVALUE AttachLow (const OBJITEM& ObjItem, OPENMODE OpenMode, MDLGPARENT parent, const RVC::CREDENTIALS* Credentials);
      ERRVALUE AttachLow (const FILEPATH& FilePath, const MISTRING& ObjectPath, OPENMODE OpenMode, MDLGPARENT parent, const RVC::CREDENTIALS* Credentials);
      ERRVALUE AttachLow (const OBJECT& parent, const OBJTYPE ObjType, const DESCRIPTOR& Descriptor, OPENMODE OpenMode, MDLGPARENT widget, const RVC::CREDENTIALS* Credentials);
      ERRVALUE AttachLow (const OBJECT& parent, const OBJTYPE ObjType, const OBJECTNAME& Name, OPENMODE OpenMode, MDLGPARENT widget, const RVC::CREDENTIALS* Credentials);
      ERRVALUE AttachLow (const OBJECT& source, const MIUNICODE *filename, const MISTRING& ObjectPath, OPENMODE OpenMode, MDLGPARENT parent, const RVC::CREDENTIALS* Credentials);

      static void CacheAdd (const FILEPATH& filepath, const CREDENTIALS *pCredentials);
      static void CacheDisable ();
      static void CacheEnable ();

      static void CallbackFunc (ANYCALLBACKSTRUCT* cb, void *data);

      #endif // GENERATING_DOXYGEN_OUTPUT
      
      virtual ERRVALUE v_CloseObject (
         );

      virtual RVC::OBJTYPE v_GetDftObjectType (
         ) const;

      virtual FILTER* v_GetObjectFilter (
         ) const;

      virtual ERRVALUE v_GetParent (
         RVC::OBJECT& ObjParent
         ) const;

      virtual bool v_IsMultiObject (
         ) const;

      virtual bool v_IsObjectOpen (
         ) const;             

      virtual ERRVALUE v_OpenObject (
         OPENMODE OpenMode,
         MDLGPARENT parent,
         const CREDENTIALS* Credentials
         );

      virtual bool v_ValidateObjectType (
         const RVC::OBJTYPE otype
         ) const;

   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(OBJECT::COPYFLAGS)
#endif


class OBJECT::CONST_ITERATOR {
   public:

      CONST_ITERATOR (
         ) : 
         m_Iterator(0),
         m_CurrentObj(0),
         m_ObjType(OBJTYPE_All)
         {}

      explicit CONST_ITERATOR (
         int
         ) : 
         m_Iterator(0),
         m_CurrentObj(0),
         m_ObjType(OBJTYPE_All)
         {}

      CONST_ITERATOR (
         const CONST_ITERATOR& rhs
         );

      CONST_ITERATOR (
         const RVC::OBJECT* parent,
         RVC::OBJTYPE m_ObjType
         );

      virtual ~CONST_ITERATOR (
         );

      CONST_ITERATOR& operator= (
         const CONST_ITERATOR& rhs
         );

      const RVC::OBJECT& operator* (
         ) const {return (*m_CurrentObj);}

      const RVC::OBJECT* operator-> (
         ) const {return (&**this);}

      CONST_ITERATOR& operator++ (
         );

      bool operator== (
         const CONST_ITERATOR& rhs
         ) const {return (m_Iterator == rhs.m_Iterator);}

      bool operator!= (
         const CONST_ITERATOR& rhs
         ) const {return (!(*this == rhs));}

   protected:
      void *m_Iterator;
      OBJECT *m_CurrentObj;
      OBJTYPE m_ObjType;
   };


class OBJECT::ITERATOR : public OBJECT::CONST_ITERATOR {
   public:
      ITERATOR (
         ) : CONST_ITERATOR() {}

      explicit ITERATOR (
         int
         ) : CONST_ITERATOR() {}

      ITERATOR (
         CONST_ITERATOR& rhs
         ) : CONST_ITERATOR(rhs) {}

      ITERATOR (
         const RVC::OBJECT* parent,
         RVC::OBJTYPE ObjType
         ) : CONST_ITERATOR(parent, ObjType) {}

      RVC::OBJECT& operator* (
         ) const {return (*m_CurrentObj);}

      RVC::OBJECT* operator-> (
         ) const {return (&**this);}

      ITERATOR& operator++ (
         ) {
         CONST_ITERATOR::operator++();
         return (*this);
         }

      bool operator== (
         const ITERATOR& rhs
         ) const {return (m_Iterator == rhs.m_Iterator);}

      bool operator!= (
         const ITERATOR& obj
         ) const {return (!(*this == obj));}

   };

      
class OBJECTOBSERVER : public OBSERVER_BASE {
   public:

      explicit OBJECTOBSERVER (
         OBJECT& object                         
         ) :
         OBSERVER_BASE(object)
         {}
         
      virtual ~OBJECTOBSERVER (
         ) {}

      virtual void OnACLChanged (
         ) {return;}
         
      virtual void OnAttach (
         ) { return;}
      
      virtual void OnChildClosing (
         const OBJECT&                          
         ) {return;}
         
      virtual void OnChildCreate (
         const OBJECT&                          
         ) {return;}
         
      virtual void OnChildDestroying (
         const OBJECT&                          
         ) {return;}
         
      virtual void OnChildOpen (
         const OBJECT&                          
         ) {return;}
         
      virtual void OnClose (
         ) {return;}
         
      virtual void OnDecendentDescriptorChanged (
         const OBJECT&                          
         ) {return;}
         
      virtual void OnDescriptorChanged (
         ) {return;}
         
      virtual void OnDestroy (
         ) { return;}
      
      virtual void OnDetach (
         ) { return;}
      
      virtual void OnUndoBegin (
         ) {return;}
         
      virtual void OnUndoEnd (
         ) {return;}
         
      virtual void OnUndoPossible (
         ) {return;}
         
   protected:     

      virtual void OnNotifyRaw (
         UINT32,                    
         void *                     
         ) {return;}
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      OBJECTOBSERVER (const OBJECTOBSERVER& rhs);
      OBJECTOBSERVER& operator= (const OBJECTOBSERVER& rhs);

      friend class OBJECT;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
   };



class OBJECT::FILTER {
   public:
      FILTER () {};

      virtual ~FILTER () {};

      virtual bool Filter (
         const RVC::OBJECT& obj
         ) = 0;
   };


class OBJECT::UNIQUENAMEFILTER {
   public:
   
      virtual int Filter (
         const RVC::OBJECTNAME& name
         ) = 0;
   };
   

class OBJECT::UNIQUECHILDNAMEFILTER : public OBJECT::UNIQUENAMEFILTER {
   public:
      UNIQUECHILDNAMEFILTER (
         const RVC::OBJECT& ParentObj,
         RVC::OBJTYPE ObjType
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      const RVC::OBJECT& m_ParentObj;
      RVC::OBJTYPE m_ObjType;
   
      virtual int Filter (const RVC::OBJECTNAME& name);
      
      UNIQUECHILDNAMEFILTER& operator= (const UNIQUECHILDNAMEFILTER&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   

class OBJECT::TOPLEVELNAMECHANGE {
   public:
      TOPLEVELNAMECHANGE (
         const OBJECT& TopSrcObject,
         const OBJECT& TopDestObject
         );
   
      ~TOPLEVELNAMECHANGE (
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      const OBJECT& m_TopSrcObject;

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


class OBJECT::FILTER_NEWERTHANPARENT : public OBJECT::FILTER {
   public:

      virtual bool Filter (
         const OBJECT& obj
         ) {
         OBJECT parent;
         return (obj.GetParent(parent) >= 0 && !obj.IsOlderThan(parent));
         }
   };

class OBJECT::FILTER_OBJTYPESET : public OBJECT::FILTER {
   public:
      FILTER_OBJTYPESET (
         const OBJTYPESET& ObjTypes
         ) : m_ObjTypes(ObjTypes) { }

      virtual bool Filter (
         const OBJECT& obj
         ) { return (m_ObjTypes.Contains(obj.GetObjectType())); }

      void SetTypes (
         const OBJTYPESET& ObjTypes
         ) { m_ObjTypes = ObjTypes; }
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      OBJTYPESET m_ObjTypes;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     // End of RVC namespace

#endif      // INC_RVC_OBJECT_H

---