object.h

Go to the documentation of this file.

/**
 * \file rvc/object.h 
 * \brief Interface for the RVCOBJECT class.
 *
 * \if NODOC
 * $Id: object.h_v 1.84 2004/09/01 22:16:07 scowan Exp $
 *
 * $Log: object.h_v $
 * Revision 1.84  2004/09/01 22:16:07  scowan
 * Added copy to edit format flag.
 *
 * Revision 1.83  2004/05/14 17:15:39  scowan
 * Added method to get invalid children.
 *
 * Revision 1.82  2004/05/03 19:26:59  scowan
 * Added class to inform copy of name change.
 *
 * Revision 1.81  2004/03/23 23:03:24  scowan
 * Added child observer support.
 *
 * Revision 1.80  2004/03/19 18:48:06  scowan
 * Added more things to observe.
 *
 * Revision 1.79  2003/12/18 14:24:14  mju
 * Remove deprecated filter typedefs.
 *
 * Revision 1.78  2003/12/03 23:31:02  scowan
 * Added new set make object method.
 *
 * Revision 1.77  2003/11/25 18:42:41  scowan
 * Added get child list method.
 *
 * Revision 1.76  2003/11/21 23:10:03  scowan
 * Added new copy flag.
 *
 * Revision 1.75  2003/11/19 22:35:13  scowan
 * Added more open flags.
 *
 * Revision 1.74  2003/11/19 20:14:37  scowan
 * Added new copy flag.
 *
 * Revision 1.73  2003/11/04 22:29:27  scowan
 * Added copy flag and make link method.
 *
 * Revision 1.72  2003/10/30 18:27:47  scowan
 * Added is older than method.
 *
 * Revision 1.71  2003/10/08 22:30:22  scowan
 * Added method for object info dump.
 *
 * Revision 1.70  2003/10/07 17:32:18  scowan
 * Object virtual method changes.
 *
 * Revision 1.69  2003/10/02 19:02:19  scowan
 * Added another statis method.
 *
 * Revision 1.68  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.67  2003/09/25 21:56:58  dwilliss
 * doxygen
 *
 * Revision 1.66  2003/09/22 19:55:29  scowan
 * Added recover project file call.
 *
 * Revision 1.65  2003/09/19 22:27:03  scowan
 * Moved get name and get desc to virtual methods.
 *
 * Revision 1.64  2003/09/15 23:13:31  scowan
 * Added yet another fine method.
 *
 * Revision 1.63  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.62  2003/09/08 15:30:59  scowan
 * Added multiple is... methods.
 *
 * Revision 1.61  2003/08/28 15:25:24  scowan
 * Added methods to determine and get linked file paths.
 *
 * Revision 1.60  2003/08/27 21:26:54  scowan
 * Support new copy object methods.
 *
 * Revision 1.59  2003/06/05 15:19:44  scowan
 * Changed filter name for newer than parent.
 *
 * Revision 1.58  2003/05/06 23:07:44  scowan
 * Added no_ deprecated around old typedef.
 *
 * Revision 1.57  2003/05/06 23:05:04  scowan
 * Added Mike's suggested changes.
 *
 * Revision 1.56  2003/04/09 22:03:48  scowan
 * Added protected method to get the file handle.
 *
 * Revision 1.55  2003/03/19 23:07:00  scowan
 * Forgot to inherit.
 *
 * Revision 1.54  2003/03/19 23:00:05  scowan
 * Added unique child name filter.
 *
 * Revision 1.53  2003/03/14 21:30:17  scowan
 * Added compute free file space method.
 *
 * Revision 1.52  2003/03/06 23:12:47  scowan
 * Added methods to flush and change temp file modes.
 *
 * Revision 1.51  2002/11/25 15:18:39  scowan
 * Added new change source method.
 *
 * Revision 1.50  2002/11/19 22:13:46  scowan
 * In newer than parent, assume equal is newer.
 *
 * Revision 1.49  2002/10/25 20:34:08  scowan
 * nc.
 *
 * Revision 1.48  2002/09/10 15:06:43  scowan
 * Added docs for Open .
 *
 * Revision 1.47  2002/08/27 20:53:43  scowan
 * Additional docs.
 *
 * Revision 1.46  2002/08/05 17:31:20  scowan
 * Doc changes.
 *
 * Revision 1.45  2002/06/12 22:12:06  scowan
 * Added more comments.
 *
 * Revision 1.44  2002/06/07 16:56:44  scowan
 * Added update time last used method.
 *
 * Revision 1.43  2002/05/23 23:07:46  scowan
 * Added traverse method.
 *
 * Revision 1.42  2002/04/30 20:49:30  scowan
 * Uses new file handle class
 *
 * Revision 1.34  2002/01/14 15:56:04  scowan
 * *** empty log message ***
 *
 * Revision 1.33  2002/01/14 15:49:25  scowan
 * Forgot one filehandle to comment out.
 *
 * Revision 1.32  2002/01/09 22:47:39  scowan
 * Removed const from filter calls.
 *
 * Revision 1.31  2001/09/28 15:45:10  scowan
 * Added protected method.
 *
 * Revision 1.30  2001/09/19 20:39:08  scowan
 * Moved iterator copy constructor to rvcobjct.c.
 *
 * Revision 1.29  2001/09/17 14:04:08  scowan
 * Added static methods.
 *
 * Revision 1.28  2001/09/07 22:00:37  scowan
 * Added on close observer method.
 *
 * Revision 1.27  2001/09/06 19:31:36  scowan
 * Comment int attach method
 *
 * Revision 1.26  2001/08/31 15:14:54  scowan
 * Removed deprecated tags from methods to better incorporate wrapper classes.
 *
 * Revision 1.25  2001/07/26 16:43:26  scowan
 * Added new get object count method.
 *
 * Revision 1.24  2001/07/25 15:16:55  scowan
 * Added new openmode flag.
 *
 * Revision 1.23  2001/07/12 22:15:18  scowan
 * Added class to temp open file if needed.
 *
 * Revision 1.22  2001/06/25 20:48:07  scowan
 * Added new virtual method.
 *
 * Revision 1.21  2001/06/18 14:55:03  scowan
 * Added protected method.
 *
 * Revision 1.20  2001/06/14 16:01:45  scowan
 * Changed source parameter to pass in.
 *
 * Revision 1.19  2001/06/13 21:24:20  scowan
 * Added rvc to method parameters.
 *
 * Revision 1.18  2001/06/13 17:07:44  scowan
 * Moved to RVC namespace.
 * Created OBJTYPESETFILTER class.
 *
 * Revision 1.17  2001/06/13 14:39:52  scowan
 * Remove default inode number from deprecated mathod, causing ambiguity.
 *
 * Revision 1.16  2001/06/13 14:21:09  scowan
 * Moved object type enum to its own include file.
 *
 * Revision 1.14  2001/05/30 16:34:18  scowan
 * Added get object item method.
 *
 * Revision 1.13  2001/05/23 21:59:53  scowan
 * Added observers and Make Link method.
 *
 * Revision 1.12  2001/01/26 14:59:44  mju
 * Add default of OPENMODE_Read for all object Open() methods.
 *
 * Revision 1.11  2001/01/16 17:45:36  scowan
 * Deprecated more code.
 *
 * Revision 1.10  2001/01/16 17:03:11  scowan
 * Added low loevel inode retrieval system.
 *
 * Revision 1.9  2000/12/01 17:45:00  scowan
 * Changed name of object type.
 *
 * Revision 1.8  2000/11/28 17:41:30  scowan
 * Changed name of qtree object type.
 *
 * Revision 1.7  2000/11/24 21:08:45  scowan
 * Added update file method.
 *
 * Revision 1.5  2000/11/06 20:08:22  scowan
 * Changed return types of filter fiunctions.
 *
 * Revision 1.4  2000/10/19 19:08:49  fileserver!dwilliss
 * Can't leave dangling comma on last item of an enum
 *
 * Revision 1.3  2000/10/19 17:44:23  scowan
 * Checked in for vacation.
 *
 * Revision 1.2  2000/09/29 21:41:09  scowan
 * Added is child of method.
 *
 * Revision 1.1  2000/09/28 22:24:17  scowan
 * Initial revision
 *
 * \endif
**/

//!   \class RVC::OBJECT rvc/object.h
//!   \brief The base class for all RVC objects
//!
//!   <b> Defined contract of the RVC Object API system.</b>
//!   
//!   The RVC Object API is designed with multiple goals, the goals are defined below
//!   
//!   -#  Support for thread safe use of RVC objects.  This goal is met using these conditions:
//!         -  RVC Object classes do not allow direct access to information that was previously in rvc object header information.  Since data
//!            can change in a multi-threaded environment, methods are used to gain information.  The removal of access to rvc object headers
//!            causes some desirable design changes including:
//!            -# A base level open method for rvc objects that support an open paradigm.  All open functions previously took a header pointer 
//!               thereby requiring a different open function for each rvc object.  This has been rendered moot.
//!            -# A base level close method for most rvc objects.  All close functions took an optional header pointer thereby requiring a
//!               different close function for each open rvc object type.
//!         -  Read/Write access must be explicitly defined when opening an rvc object.  This allows a multi-threaded implementation to
//!            generate 'locks' on rvc objects based on the access requirement.
//!         -  Each instance of a rvc object gets a unique handle to the rvc object that the class represents.  Handle management is class based.
//!   -# Strict hierarchy level of classes to limit errors.  This goal is met using these conditions:
//!      -  RVC Object classes determine what rvc object types they can deal with.  API's cannot be mixed with this check.
//!      -  Class hierarchies with base classes that support common functionality.
//!   -# Eliminating the use of RVCINODENUM's to manage RVC objects.
//!      -  RVCINODENUM's are not type safe and can be intermixed between open rvc objects, causing errors.
//!      -  The tendancy of programmers to store RVCINODENUM's in reference files is to be RETIRED.  Hiding RVCINODENUM's from 
//!            code will prevent this action.
//!   
//!   <b>Attaching and opening rvc objects.</b>
//!   
//!   The construct of attachment and opening comes from the fact that we do not handle exceptions.  Therefore error handling is done
//!   through return values.  Since constructors do not have return values, the constructor set is kept to a minimum.  In addition, 
//!   the concept of closing an rvc object while maintaining knowledge of where the rvc object is needs to be implemented.  Therefore two
//!   methodologies have been introduced to deal with the requirements:
//!
//!   
//!      -# The concept of attaching the instance to an rvc object using Attach() methods.  These methods will validate the attachment
//!         by opening the file and locating the rvc object and validate that the derived class is appropriate for the rvc object.  The method
//!         will close the file after it has accomplished its goal.
//!
//!      -# Opening the rvc object will perform the same checks as the Attach() method as well as keeping the file open and if possible,
//!         opening the derived class rvc object.
//!
//!   
//!   <b>Use of the 'const' keyword</b>
//!   
//!   The 'const' keyword is used to define methods that do not modify the rvc object.  "Const" methods for RVC::OBJECT will open the object using
//! RVC::OBJECT::OPENMODE_Read and perform the operation.  Attempting to use a non-open RVC::OBJECT instance for non-const methods will result
//! in the method returning an R_WriteInvalid error.


#ifndef INC_RVC_OBJECT_H
#define INC_RVC_OBJECT_H

#ifndef INC_MI32_STDDEFNS_H
   #include <mi32/stddefns.h>
#endif

#ifndef INC_RVC_OBJTYPE_H
   #include <rvc/objtype.h>
#endif

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

#ifndef INC_MI32_RVCDEFNS_H
   #include <mi32/rvcdefns.h>
#endif

#ifndef INC_MI32_FILEPATH_H
   #include <mi32/filepath.h>
#endif

#ifndef INC_MI32_DATETIME_H
   #include <mi32/datetime.h>
#endif

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

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

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class FILEHANDLE;
class OBJECTOBSERVER;
#endif // GENERATING_DOXYGEN_OUTPUT
   
class OBJECT : public SUBJECT<OBJECTOBSERVER> {
   public:

      enum COPYFLAGS {
         COPYFLAG_None =                  0x00000000,       //!< Default, copy subobjects and links
         COPYFLAG_DontCopyChildren =      0x00000001,       //!< Do not copy child objects
         COPYFLAG_CopySpatialFromLink =   0x00000002,       //!< Copy data from spatial link, not the link itself
         COPYFLAG_CopyDBTableFromLink =   0x00000004,       //!< Copy data from DB table link, not the link itself
         COPYFLAG_CopyRVCObjectFromLink = 0x00000008,       //!< Copy data from RVC object link, not the link itself
         COPYFLAG_CopyTextFromLink =      0x00000010,       //!< Copy data from text link, not the link itself
         COPYFLAG_DontCopyStdAttTables =  0x00000020,       //!< Do not copy standard attrib tables
         COPYFLAG_ReportInvalidParent  =  0x00000040,       //!< Report invalid parent errors
         COPYFLAG_ForceOneObjectCopy   =  0x00000080,       //!< Force the copy of the most recently used object if the singleton rule is violated
         COPYFLAG_CopyIfNotModifiable  =  0x00000100,       //!< Copy data from the link, not the link itself, if the data is not modifiable through the link
         COPYFLAG_CopyToEditFormat     =  0x00000200        //!< Copy data from the source to an editable format, used for CAD currently
         };
         
      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,       //!< Get only the link information for the object
         LINKFILEFLAG_SearchChildren =    0x00000001        //!< Get link information for the object and children
         };
         
      enum OPENMODE {               //! Mode for opening rvc files and objects, mutually exclusive
         OPENMODE_NotOpen = 0,      //!< Returned by GetOpenMode() if the rvc file / object is not open
         OPENMODE_Read,             //!< Open file with 'read' access
         OPENMODE_Write,            //!< Open file with 'write' access
         OPENMODE_WriteAttempt,     //!< Attempt to open the file for writing, if failed, open for reading only
         OPENMODE_ReadNoLock,       //!< Open file generating no lock files, used for system resource files
         OPENMODE_WriteAbsolute,    //!< Override ReadAbsolute system flag for a specific file
         OPENMODE_ReadAbsolute,     //!< File is to be opened read-only, no lock file and no possibility of change
         OPENMODE_WriteNoLock       //!<  Open file generating no lock files, used for system resource files
         };

      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

      //! Default constructor
      OBJECT (                   //! Empty constructor, must attach to an object using Attach()
         );

      //! Copy constructor
      OBJECT (                   //! Copy Constructor
         const RVC::OBJECT& obj
         );

      //! Destructor
      virtual ~OBJECT (
         );

      //! Assignment.  Will close if necessary and reopen if 'rhs' is open
      RVC::OBJECT& operator= (               //! Assignment operator
         const RVC::OBJECT& rhs
         );

      //! Attach an OBJECT instance to a rvc file root folder using a FILEPATH
      //!
      //! This will open the file to determine parameter correctness.
      //! If the class is derived, this function will fail and return an error.
      ERRVALUE Attach (
         const FILEPATH& FilePath         //!< Location of file to attach to
         );

      //! Attach an OBJECT instance to a file using the FILEPATH and inode number
      //!
      //! This will open the file to determine parameter correctness.
      //! If the derived class cannot handle the rvc object type, the rvc object is not attached and an error is returned
   //!   #ifndef NO_DEPRECATED
      ERRVALUE Attach (
         const FILEPATH& FilePath,        //!< Location of file to attach to
         const RVCINODENUM InodeNum       //!< RVC inode to attach to
         );
   //!   #endif

      //! Attach an OBJECT instance to a file using an OBJITEM
      //!
      //! This will open the file to determine parameter correctness
      //! If the derived class cannot handle the rvc object type, the rvc object is not attached and an error is returned
      ERRVALUE Attach (
         const RVC::OBJITEM& ObjItem         //!< Item containing file and rvc object location to attach to
         );

      //! Attach an OBJECT instance to a file using the FilePath and an rvc object path
      //!
      //! This will open the file to determine parameter correctness and locate the correct rvc object.
      //! If the derived class cannot handle the rvc object type, the rvc object is not attached and an error is returned
      ERRVALUE Attach (
         const FILEPATH& FilePath,        //!< Location of project file to open
         const MISTRING& ObjectPath       //!< Location of rvc object in project file to open
         );

      //! Attach an OBJECT instance to a file using a parent rvc object, child rvc object type and child name
      //!
      //! This will open the file to determine parameter correctness and locate the correct rvc object.
      //! If the derived class cannot handle the rvc object type, the rvc object is not attached and an error is returned
      ERRVALUE Attach (
         const RVC::OBJECT& parent,       //!< Parent object to look for the correct child
         const RVC::OBJTYPE ObjType,            //!< Child rvc object type to attach to
         const RVC::OBJECTNAME& name         //!< Name of child rvc object to attach to
         );

      //! Attach an RVC::OBJECT instance to a file using a source rvc object, possible relative path, and rvc object path
      //!
      //! This will open the file to determine parameter correctness and location of the correct rvc object.
      //! If the derived class cannot handle the rvc object type, the rvc object is not attached and an error is returned
      ERRVALUE Attach (
         const RVC::OBJECT& source,       //!< If 'filename' is relative, this specifies the source path
         const UNICODE *filename,         //!< Location of rvc file, can be a relative path
         const MISTRING& ObjectPath       //!< Location of rvc object in the rvc file
         );

      //! Attach an RVC::OBJECT instance to a file using its twin.
      //!
      //! This will open the file if the twin's file is open
      //! If the derived class cannot handle the rvc object type, the rvc object is not attached and an error is returned
      ERRVALUE Attach (
         const RVC::OBJECT& twin
         );

      //! Attach an OBJECT instance to an OBJITEM's parent
      //!
      //! This will open the file to determine parameter correctness
      //! If the derived class cannot handle the rvc object type, the rvc object is not attached and an error is returned
      ERRVALUE AttachToParent (
         const RVC::OBJITEM& ObjItem         //!< Item containing file and rvc object location to attach to
         );

      //! Determine if the rvc file can be opened for writing, irregardless of its current open state
      //!
      //! Object must be attached or false is returned
      //! This function does not check if another process or thread has a write lock on the file, it
      //! determines that the file \b CAN be opened for writing.
      //! @return true if file is writable and the RVC system allows writing, false if cannot open for write
      bool CanOpenForWrite (                 //! Is file read-only?  (Object cannot be opened for writing)
         ) const;

      //! Change the rvc object description
      //! Object must be open with OPENMODE_Write
      ERRVALUE ChangeDesc (
         const RVC::OBJECTDESC& NewDesc         //!< New description for the object
         );

      //! Change the rvc object name
      //! Object must be open with OPENMODE_Write
      ERRVALUE ChangeName (
         const RVC::OBJECTNAME& NewName         //!< New name for the object
         );

      //! Change the rvc object that this object is linked to
      //! Object must be open with OPENMODE_Write
      ERRVALUE ChangeObjectLink (
         const RVC::LINKITEM& LinkItem
         );

      //! Change the rvc object source
      //! Object must be open with OPENMODE_Write
      ERRVALUE ChangeSource (
         const RVC::OBJECTSOURCE& NewSource     //!< New source name for the object
         );

      //! Change the temp file mode to TEMPFILE_DeleteOnClose or TEMPFILE_DeleteOnExit 
      ERRVALUE ChangeTempFileMode (
         TEMPFILE flags
         );
         
      //! Obtain a const rvc child object iterator given an rvc object type.  This iterator can be used to step through 
      //! all of the children of 'this'.
      //! @return A constant iterator to the first child that meets the specifications
      CONST_ITERATOR ChildListBegin (        //! Get iterator to the beginning of the child list
         RVC::OBJTYPE m_ObjType                 //!< Object type of children to search for
         ) const;
      
      //! Obtain a rvc child object iterator given an rvc object type.  This iterator can be used to step through 
      //! all of the children of 'this'.
      //! @return An iterator to the first child that meets the specifications
      ITERATOR ChildListBegin (           //! Get iterator to the beginning of the child list
         RVC::OBJTYPE m_ObjType                 //!< Object type of children to search for
         );

      //! Obtain a const rvc child object iterator that points to the end of the list.
      //! @return A constant iterator to the end of the child list
      CONST_ITERATOR ChildListEnd (       //! Get iterator to the child list end
         ) const;

      //! Obtain a rvc child object iterator that points to the end of the list.
      //!
      //! @return An iterator to the end of the child list
      ITERATOR ChildListEnd (             //! Get iterator to the child list end
         );

      //! Close the rvc object
      //!
      //! Will close the file and the rvc object if the derived class supports the paradigm.  The instance is still considered attached.
      ERRVALUE Close (                 //! Close the open file/object
         );

      //! Compute project file free space
      //! @return Amount of project file free space
      INT64 ComputeProjectFileFreeSpace (
         ) const;
         
      //! Make a copy of the rvc object, and its children, to another place specified by the destination parent object.
      //! Does not copy DBTABLE objects.  Use RVC::DBASE::CopyTableTo() method.
      ERRVALUE CopyTo (
         RVC::OBJECT& DestParentObj,         //!< Parent object to copy object and children to
         RVC::OBJECT& DestObj,               //!< Attached instance to destination object
         COPYFLAGS CopyFlags = COPYFLAG_None
         ) const;

      //! Make a copy of the rvc object, and its children, to another place specified by the destination parent object.
      //! Does not copy DBTABLE objects.  Use RVC::DBASE::CopyTableTo() method.
      ERRVALUE CopyTo (
         RVC::OBJECT& DestParentObj,         //!< Parent object to copy object and children to
         RVC::OBJECT& DestObj,               //!< Attached instance to destination object
         const RVC::OBJECTNAME& name,        //!< New name of copied object
         const RVC::OBJECTDESC& desc,        //!< New description of copied object
         COPYFLAGS CopyFlags = COPYFLAG_None,
         const char *Source = 0              //!< New source of copied object, default is GetAppName()
         ) const;

      //! Make a copy of the rvc object, and its children, to another place specified by the destination parent object.
      //! Does not copy DBTABLE objects.  Use RVC::DBASE::CopyTableTo() method.
      ERRVALUE CopyTo (
         RVC::OBJECT& DestParentObj,         //!< Parent object to copy object and children to
         RVC::OBJECT& DestObj,               //!< Attached instance to destination object
         FILTER& filter,                     //!< Method called with an rvc object to determine fitness to copy
         COPYFLAGS CopyFlags = COPYFLAG_None
         ) const;

      //! Make a copy of the rvc object, and its children, to another place specified by the destination parent object.
      //! Does not copy DBTABLE objects.  Use RVC::DBASE::CopyTableTo() method.
      ERRVALUE CopyTo (
         RVC::OBJECT& DestParentObj,         //!< Parent object to copy object and children to
         RVC::OBJECT& DestObj,               //!< Attached instance to destination object
         FILTER& filter,                     //!< Method called with an rvc object to determine fitness to copy
         const RVC::OBJECTNAME& name,        //!< New name of copied object
         const RVC::OBJECTDESC& desc,        //!< New description of copied object
         COPYFLAGS CopyFlags = COPYFLAG_None,
         const char *Source = 0              //!< New source of copied object, default is GetAppName()
         ) const;

      //! Copy rvc object's children to the given destination parent object
      ERRVALUE CopyChildrenTo (
         RVC::OBJECT& DestParentObj,         //!< Parent to copy children to.
         COPYFLAGS CopyFlags = COPYFLAG_None
         ) const;

      //! Copy rvc object's children to the given destination parent object with filter
      ERRVALUE CopyChildrenTo (
         RVC::OBJECT& DestParentObj,         //!< Parent to copy children to.
         FILTER& filter,                     //!< Method called with an rvc object to determine fitness to copy
         COPYFLAGS CopyFlags = COPYFLAG_None
         ) const;

      //! Delete the rvc object.  The method will call Close().
      //!
      //! For this function to work correctly, <b>ALL</b> instances that refer to this object must be closed.
      //! This method does not support delete when all closed paradigm.
      ERRVALUE Delete (                //! Delete the RVC::OBJECT
         );

      //! Detach instance from RVC object
      //!
      //! Will close the object and file
      void Detach (                    //! Close and unattach the file representing this RVC::OBJECT
         );

      //! Dump object information into a MISTRING reference
      ERRVALUE DumpObjectInfo (
         MISTRING& LogString,
         DUMPINFOFLAGS DumpInfoFlags = DUMPINFOFLAG_Minimal       //!< Controls how much information is placed into "LogString'
         );
         
      //! Locate rvc child object based on rvc child default object type and given name
      //!
      //! This routine determines the derived class default rvc object type and uses that for its search.
      //!  Object must be open for this method to work.  Returns false if not
      //! @return true if rvc object found and child sucessfully attached, false if not
      bool FindChild (                 //! Find child RVC::OBJECT by RVC::OBJECTNAME, if exists
         RVC::OBJECT& Child,                 //!<  Child object attached if found
         const RVC::OBJECTNAME& name            //!< Name of rvc child object to find
         ) const;

      //! Locate rvc child object based on rvc child default object type, given name, and a filter object
      //!
      //! This routine determines the derived class default rvc object type and uses that for its search.
      //!  Object must be open for this method to work.  Returns false if not
      //! @return true if rvc object found and child sucessfully attached, false if not
      bool FindChild (                 //! Find child RVC::OBJECT by RVC::OBJECTNAME and filter, if exists
         RVC::OBJECT& Child,                 //!<  Child object attached if found
         const RVC::OBJECTNAME& name,        //!< Name of rvc child object to find
         FILTER& filter                      //!< Method called with an rvc object to determine child fitness
         ) const;

      //! Locate rvc child object based on object path
      //!
      //! This routine locates the proper rvc object using the child's filepath and the rvc object path.
      //!  Object must be attached for this method to work.  Returns false if not
      //! @return true if rvc object found and child sucessfully attached, false if not
      bool FindChild (                 //! Find child RVC::OBJECT by RVC Object Path, if exists
         RVC::OBJECT& Child,                 //!<  Child object attached if found
         const MISTRING& ObjectPath       //!< RVC object path to look for child with
         ) const;

      //! Locate last used rvc child object based on child rvc object type
      //!
      //! This routine determines the derived class default rvc object type and uses that for its search.
      //!  Object must be open for this method to work.  Returns false if not
      //! @return true if rvc object found and child sucessfully attached, false if not
      bool FindChildLastUsed (            //! Last used RVC::OBJECT if found assigned to "Child"
         RVC::OBJECT& Child                  //!< RVC Child object attached if found
         ) const;

      //! Locate last used rvc child object based on child rvc object type and a filter object
      //!
      //! This routine determines the derived class default rvc object type and uses that for its search.
      //!  Object must be open for this method to work.  Returns false if not
      //! @return true if rvc object found and child sucessfully attached, false if not
      bool FindChildLastUsed (         //! Last used RVC::OBJECT if found assigned to "Child"
         RVC::OBJECT& Child,           //!<  Child object attached if found
         FILTER& filter                //!< Method called with an rvc object to determine fitness
         ) const;

      //! Update file information stored in caches to the file itself      
      ERRVALUE FlushFile (
         );

      //! Generate a unique object name based on the passed in filter
      static ERRVALUE GenerateUniqueName (
         RVC::OBJECTNAME& name,
         UNIQUENAMEFILTER& filter
         );

      //! Determine the number of children under this rvc object
      //!
      //!  Object must be opened for this method to work
      //! @return number of children found
      INT32 GetChildCount (               //! Count of children or ERRVALUE RETURNED
         RVC::OBJTYPE otype = RVC::OBJTYPE_All           //!< Type of rvc object to count, RVC::OBJTYPE_All to count all children
         ) const;

      //! Determine the number of children under this rvc object
      //!
      //!  Object must be opened for this method to work
      //! @return number of children found
      INT32 GetChildCount (               //! Count of children or ERRVALUE RETURNED
         RVC::OBJTYPE otype,              //!< Type of rvc object to count, RVC::OBJTYPE_All to count all children
         FILTER& filter                   //!< Method called with an rvc object to determine fitness
         ) const;

      //! Determine the number of children under this rvc object
      //!
      //!  Object must be opened for this method to work
      //! @return number of children found
      INT32 GetChildList (
         RVC::OBJTYPE ObjType,            //!< Type of rvc object to count, RVC::OBJTYPE_All to count all children
         RVC::OBJITEMLIST& ObjItemList,   //!< List of children RETURNED
         FILTER* filter = 0               //!< Method called with an rvc object to determine fitness
         ) const;

      //! Obtain the rvc object description
      //!
      //!  Object must be opened for this method to work
      ERRVALUE GetDescription (
         RVC::OBJECTDESC& Desc                  //!< Place to put rvc object description
         ) const;

      //! Obtain the default object type for the object instance
      //! @return The default object type for 'this'.  The default value is RVC::OBJTYPE_File.
      RVC::OBJTYPE GetDftObjectType (
         ) const;

      //! Get the RVC file handle associated with this RVC::OBJECT instance
      //!
      //! Used to integrate object classes with old functions, as soon as old functions are
      //! DEPRECATED, this method is RETIRED.
      //! The instance must be open to get a valid handle
   //!   #ifndef NO_DEPRECATED
      int GetFileHandle (                 //! For derived classes, gets the internal file handle
         ) const {
         return (GetFileHandlePro());
         }
   //!   #endif

      //! Get the FILEPATH associated with this RVC::OBJECT instance
      //! @return The filepath associated with this object.  FILEPATH will be empty if the object is not attached 
      const FILEPATH& GetFilePath (
         ) const;

      //! Get the FILEPATH linked file associated with this RVC::OBJECT instance
      //! @return The filepath linked file associated with this object.  FILEPATH will be empty if the object link is not attached 
      const FILEPATH& GetFilePathLink (
         ) const;

      //! Get the RVCINODENUM associated with this RVC::OBJECT instance
   //!   #ifndef NO_DEPRECATED
      RVCINODENUM GetInodeNum (           //! Internal inode number returned, for derived classes
         ) const {
         return (GetInodeNumPro());
         }
   //!   #endif
   
      //! Obtain link file information for this object and/or children
      ERRVALUE GetLinkedFiles (
         MILIST<LINKITEM>& LinkFileList,
         LINKFILEFLAGS LinkFileFlags = LINKFILEFLAG_None
         ) const;

      //! Obtain the rvc object name
      //!
      //! The object must be opened for this method to work
      ERRVALUE GetName (
         RVC::OBJECTNAME& Name               //!< Object name RETURNED
         ) const;

      //! Fill in the RVC::OBJITEM for the location of this object
      //!
      //! The object must be attached for this method to work
      ERRVALUE GetObjectItem (
         RVC::OBJITEM& ObjectItem            //!< Object Item RETURNED
         ) const;

      //! Determine the RVC Object Path from the root to this object
      //!
      //! The object must be attached for this method to work
      //! This rvc object path is defined to be a UNICODE string containing the heirarchy from the file root
      //! rvc object to the rvc object referenced by this instance.  It is used in specific Attach() and Open() methods.
      ERRVALUE GetObjectPath (
         MISTRING& ObjectPath          //!< Path to the rvc object from the root(file) rvc object.
         ) const;

      //! Get the RVC::OBJTYPE_... associated with this RVC::OBJECT instance
      //! @return The RVC::OBJTYPE_...associated with this object.
      RVC::OBJTYPE GetObjectType (
         ) const;
      
      //! Obtain object type from defined tag
      //! @return The RVC::OBJTYPE_...associated with this tag
      static RVC::OBJTYPE GetObjectTypeFromTag (
         const char* tag
         );

      //! Obtain object type from defined tag
      //! @return The RVC::OBJTYPE_...associated with this tag
      static RVC::OBJTYPE GetObjectTypeFromTag (
         const UNICODE* tag
         );

      //! Obtain the parent rvc object.  If the rvc object is RVC::OBJTYPE_File, the parent rvc object returned is the same 
      //! as the rvc object
      //!
      //! The  Object must be opened for this method to work
      ERRVALUE GetParent (
         RVC::OBJECT& ObjParent              //!< Parent object attached if sucessful
         ) const;

      //! Obtain the product version number which this rvc object was created
      //!
      //! The  Object must be opened for this method to work
      ERRVALUE GetProductVersion (
         UINT16& ProductVersion           //!< TNT product version in the form of MMmm (M - Major, m - minor) RETURNED
         ) const;

      //! Obtain the size of this rvc object in bytes
      //!
      //! The  Object must be opened for this method to work
      ERRVALUE GetSize (
         UINT64& size                  //!< Size of opened rvc object RETURNED
         ) const;

      //! Obtain the creation source string for this rvc object
      //!
      //! The  Object must be opened for this method to work
      ERRVALUE GetSource (
         RVC::OBJECTSOURCE& Source           //!< RVC Object creation source name RETURNED
         ) const;
         
      //! Obtain TEXTID from defined object type
      //! @return The TEXTID associated with the RVC::OBJTYPE_...
      static TEXTID GetTextIDFromObjectType (
         OBJTYPE ObjType
         );

      //! Obtain the creation time for this rvc object
      //!
      //! The  Object must be opened for this method to work
      void GetTimeCreate (
         DATETIME& Create              //!< Creation time RETURNED
         ) const;

      //! Obtain the Last Modified Time for this rvc object
      //!
      //! The  Object must be opened for this method to work
      ERRVALUE GetTimeLastMod (
         DATETIME& LastMod             //!< Last modified time RETURNED
         ) const;

      //! Obtain the Last Used Time for this rvc object
      //!
      //! The  Object must be opened for this method to work
      ERRVALUE GetTimeLastUsed (
         DATETIME& LastUsed               //!< Last used time RETURNED
         ) const;
         
      //! Get the number of available undo levels
      //! @return Number of available undo levels
      INT32 GetUndoNumLevels (
         ) const;

      //! Is this RVC::OBJECT attached to a RVC object?
      bool IsAttached (
         ) const;
         
      //! Is this RVC::OBJECT a child of the given parent?
      bool IsChildOf (
         const RVC::OBJECT& parent           //!< Parent object to test
         ) const;

      //! Do the two rvc object instances refer to the same RVC object?
      //! If either are unattached, this method returns false
      bool IsEqual (
         const RVC::OBJECT& rhs           //!< RVC Object to compare to
         ) const;
         
      //! Is the file a link file or not
      //! @return True if the file is linked, false if not
      bool IsFileLinked (
         ) const;

      //! Is this rvc object a root file rvc object?
      bool IsFileObject (
         ) const;

      //! Is the object / file created by TNTlite
      //! @return True if the object / file is created by TNTlite, false if not
      bool IsLiteCreated (
         ) const;

      //! Is the object a link object or not
      //! @return True if the object is linked, false if not
      bool IsObjectLinked (
         ) const;

      //! Is the object older than the passed in object, using the last modified timestamp
      //! @return True if 'this' is older than 'Object', false if not
      bool IsOlderThan (
         const RVC::OBJECT& Object
         ) const;

      //! Determine if rvc object is opened
      //! @return True if rvc object is opened
      bool IsOpen (
         ) const;             

      //! Determine if the attached rvc file is a temporary file
      //! @return True if file is temporary, False if not
      bool IsTempFile (
         ) const;
      
      //! Is this rvc object a child of a folder or the root file rvc object?
      bool IsTopObject (
         ) const;             

      //! Is the rvc object opened for writing
      bool IsWritable (
         ) const;

      //! Create a RVC file
      //!
      //! This method will create a project (RVC) file using the given location
      ERRVALUE MakeFile (
         const FILEPATH& FilePath,        //!< Place to create the file
         const RVC::OBJECTDESC& desc         //!< Description to give the file
         );

      //! Create a RVC link object under 'this'
      //!
      //! This method will create a linked object (NewLinkObject) to an existing RVC object (LinkToObject)
      ERRVALUE MakeLink (
         const RVC::OBJECT& LinkToObject,
         RVC::OBJECT& NewLinkObject,         //!< Only attached to the new link, not opened
         bool LinkToSubobjects = false
         );

      //! Create a RVC link object under 'this'
      //!
      //! This method will create a linked object (NewLinkObject) to an existing RVC object (LinkToObject)
      ERRVALUE MakeLink (
         const RVC::OBJECT& LinkToObject,
         RVC::OBJECT& NewLinkObject,         //!< Only attached to the new link, not opened
         const OBJECTNAME& name,
         const OBJECTDESC& desc,
         bool LinkToSubobjects = false
         );

      //! Create a RVC file as a temporary file
      //!
      //! This method will create a temporary RVC file using the temporary file path 
      //! with the largest free space.
      ERRVALUE MakeTempFile (
         TEMPFILE flags = TEMPFILE_DeleteOnClose      //!< Determines if to delete the temp file on closing of the file, or when the process ends
         );

      //! Open an <b>attached</b> RVC::OBJECT instance
      //!
      //! This method will open the file and derived rvc class object if possible
      //! If the instance is already open and the OPENMODE is not different, this
      //! method will return without doing anything, else it will Close() then Open()
      //! the instance.
      //! The instance must be attached for this to work
      ERRVALUE Open (
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0               //!< Parent dialog handle, 0 for default handle
         );

      //! Open an RVC::OBJECT instance using another instance to the same rvc object.
      //!
      //! This method will attach and open the file and derived rvc class object if possible.
      //! Use this method to re-open the rvc object using a different OPENMODE.
      ERRVALUE Open (
         const RVC::OBJECT& twin,            //!< Identical rvc object to open with a different OPENMODE
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );

      //! Open an RVC::OBJECT instance using the rvc object's parent, type of rvc object, and the rvc object's name
      //!
      //! This method will attach and locate the rvc object and open the file and derived rvc class object if possible
      ERRVALUE Open (
         const RVC::OBJECT& parent,       //!< Parent rvc object to search under
         const RVC::OBJTYPE ObjType,            //!< Type of rvc object to look for
         const RVC::OBJECTNAME& name,        //!< Name of rvc object to look for
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );

      //! Open an RVC::OBJECT instance to a rvc root folder using the given file location
      //!
      //! This method will attach and open the file
      //! If the class is derived, this function will fail and return an error.
      ERRVALUE Open (
         const FILEPATH& FilePath,        //!< Location of file to attach to
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );

   //!   #ifndef NO_DEPRECATED
      //! Open an RVC::OBJECT instance using the given file location and rvc object inode
      //!
      //! This method will attach and open the file and derived rvc class object if possible
      //! <b>This is a legacy method, it will be DEPRECATED as soon as possible</b>
      //! Read Goal item 3 for reason
      ERRVALUE Open (
         const FILEPATH& FilePath,        //!< Location of file to open
         const RVCINODENUM InodeNum,
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );
         
      //! Open an RVC::OBJECT instance using the given open object id
      //!
      //! This method will attach and open the file and derived rvc class object if possible
      //! <b>This is a legacy method, it will be DEPRECATED as soon as possible</b>
      //! Read Goal item 3 for reason
      ERRVALUE Open (
         int ObjectID,                       //!< Legacy open object ID handle
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );
   //!   #endif

      //! Open an RVC::OBJECT instance using a RVC::OBJITEM instance
      //!
      //! This method will attach and open the file and derived rvc class object if possible
      ERRVALUE Open (
         const RVC::OBJITEM& ObjItem,        //!< This contains the file and rvc object location information
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );

      //! Open an RVC::OBJECT instance using the given file location and rvc object path
      //!
      //! This method will attach and locate the rvc object and open the file and derived rvc class object if possible
      ERRVALUE Open (
         const FILEPATH& FilePath,        //!< Location of file to open
         const MISTRING& ObjectPath,         //!< Full name of rvc object obtained from GetObjectPath()
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );

      //! Open an RVC::OBJECT instance using a source rvc object, possible relative path, and rvc object path
      //!
      //! This method will attach and open the file and derived rvc class object if possible
      ERRVALUE Open (
         const RVC::OBJECT& source,       //!< Source rvc object used if 'filename' is a relative path
         const UNICODE *filename,         //!< Full or relative path to the rvc file to open
         const MISTRING& ObjectPath,         //!< Full name of rvc object obtained from GetObjectPath()
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT parent = 0            //!< Parent dialog handle, 0 for default handle
         );

      //! Open a parent of an RVC::OBJECT instance using a RVC::OBJITEM instance
      //!
      //! This method will attach and open the file and derived rvc class object if possible
      ERRVALUE OpenParent (
         const RVC::OBJITEM& ObjItem,        //!< This contains the file and rvc object location information
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );

      //! Perform project file recovery to the output object specified
      ERRVALUE RecoverProjectFileTo (
         RVC::OBJECT& OutputObject,
         MISTRING& LogString
         );
   
      //! Redo (reinstate) changes made by an undo operation, if enabled
      ERRVALUE RedoChanges (
         );
         
      //! Search children of 'this' for any children that are invalid due to:
      //! 1.  Violation of parent object rules (child cannot be under this parent object)
      //! 2.  Singleton violation:  There can be only one object of this type under the parent
      ERRVALUE SearchForInvalidChildObjects (
         bool SearchAllSubLevels,                     //!< 'false' to return only the first level children, true to do levels of children
         OBJITEMLIST& InvalidChildList,            //!< List of children that violate parent object rules  (child cannot be under this parent object)
         OBJITEMLIST& SingletonChildList        //!< Singleton violation:  There can be only one object of this type under the parent
         ) const;

      ERRVALUE SetMinimumTNTVersion (
         UINT16 Version = 0         //!< Default is to the current version
         );
         
      //! Modify the rvc object's TimeLastUsed field to the current time
      //!
      //! The  object must be opened for writing
      ERRVALUE SetTimeLastUsed (
         );

      //! Modify the rvc object's TimeLastUsed field to the time given
      //!
      //! The  object must be opened for writing
      ERRVALUE SetTimeLastUsed (
         const DATETIME& NewTime          //!< Date / Time to set the rvc object's "last used" field
         );

      //! Modify the rvc object's TimeLastModified field to the current time
      //!
      //! The  object must be opened for writing
      ERRVALUE SetTimeLastMod (
         );

      //! Modify the rvc object's TimeLastModified field to the time given
      //!
      //! The rvc object must be opened for writing
      ERRVALUE SetTimeLastMod (
         const DATETIME& NewTime          //!< Date / Time to set the rvc object's "last modified" field
         );

      //! Set the maximum number of undo levels
      ERRVALUE SetUndoMaxLevel (
         INT32 NewLevel
         );
         
      //! Method to traverse an object link if 'this' references a RVC object link.
      //! If 'this' references a link, 'TraversedObject' will be attached to the linked to object, if 'this'
      //! is not a link, 'TraversedObject' will be attached to 'this'.
      //! @return '1' if the link existed and was traversed, '0' if not a link, < 0 error
      ERRVALUE TraverseLink (
         RVC::OBJECT& TraversedObject
         );
         
      //! Undo changes made from the last undo mark      
      ERRVALUE UndoChanges (
         bool SetRedo = false             //!< Set redo information to undo the undo
         );

      //! Clear out all undo information     
      ERRVALUE UndoClear (
         );
         
      //! Mark a spot for an undo call to undo to.  This first call to this function
      //! marks the initial position for undo and enables undo for this file
      ERRVALUE UndoMark (
         );
      
      //! Update file information stored in object caches to the file itself     
      ERRVALUE UpdateFile (
         );

      //! Update "Last Used" time to be later than any like object.  Only updates the object if necessary.
      //! Guarentees this object will be selected be FindChildLastUsed()
      ERRVALUE UpdateTimeLastUsed (
         );
         
      //! Validate OBJECTNAME to specs
      static void ValidateName (
         RVC::OBJECTNAME& name
         );

   protected:

      virtual ERRVALUE v_GetName (RVC::OBJECTNAME& Name) const;
      virtual ERRVALUE v_GetDescription (RVC::OBJECTDESC& Desc) const;

      void AssignInfo (const RVCGENINFO& info);
      void AssignInode (RVCINODENUM inode);

      void CallOnNotifyRaw (UINT32 reason, void *data = 0);
      void CallOnChildCreate (const OBJECT& object);
      void CallOnChildOpen (const OBJECT& object);
      void CallOnChildClosing (const OBJECT& object);
      void CallOnClose ();
      void CallOnUndoBegin ();
      void CallOnUndoEnd ();
      void CallOnUndoPossible ();
      
      ERRVALUE CloseFile (             //! Close the open file
         );

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

      //! Get the RVC file handle associated with this RVCRVC::OBJECT instance
      //! The instance must be open to get a valid handle
      RVC::FILEHANDLE* GetFileInstance (                 //! For derived classes, gets the internal file handle
         ) const;
      
      //! Get the RVC file handle associated with this RVCRVC::OBJECT instance
      //! The instance must be open to get a valid handle
      int GetFileHandlePro (                 //! For derived classes, gets the internal file handle
         ) const;
      
      //! Get the RVCINODENUM associated with this RVC::OBJECT instance
      RVCINODENUM GetInodeNumPro (           //! Internal inode number returned, for derived classes
         ) const;
      
      //! Obtain current open mode for this rvc object instance.
      //! Used in copy constructors and assignment operators of derived classes to open the rvc object using
      //! the same OPENMODE as the 'rhs' rvc object instance
      //!
      //! @return Open mode of rvc object instance
      OPENMODE GetOpenMode (           //! Returns open object read or write, useful for copy and assignment
         ) const;
      
      bool IsFileOpen (                //! Is the file opened?
         ) const;

      ERRVALUE OpenFile (                 //! Open file only
         OPENMODE OpenMode,
         MDLGPARENT parent
         );

      ERRVALUE OpenRVCFile (const FILEPATH& filepath, OPENMODE OpenMode, MDLGPARENT parent);
      void SetMakeObject (const RVC::OBJECT& rhs);

      void SetBasicInfo (
         RVCGENINFO& ginfo,
         const RVC::OBJECT& parent,
         const RVC::OBJECTNAME& name,
         const RVC::OBJECTDESC& desc,
         const char *Source = 0              //!< New source of copied object, default is GetAppName()
         );

      ERRVALUE SetParent (const OBJITEM& ObjItem);
         
      UINT32 TranslateOpenFlags (            //! Translates OPENMODE to FILE_... flags
         OPENMODE flags
         ) const;


   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      FILEPATH m_FilePath;    //!< File to re-open if closed
      FILEHANDLE* m_FileHandle;
      bool m_Attached;
      bool m_IsWritable;
      bool m_CanWrite;

      //! The members listed below are the members of RVCGENINFO 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 (                   //! Constructor by file handle and inode number, used for internal creation
         const FILEHANDLE* FileHandle,
         RVCINODENUM InodeNum
         );

      OBJECT (                   //! Constructor by file index and inode number, used for internal creation
         int fhandle,
         RVCINODENUM InodeNum
         );

      bool operator== (const OBJECT& rhs) const;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      //! Called by the Close() method to close the derived class open handle, if possible and necessary
      //!
      //! If the derived class retains an open state with the rvc object, then the derived class MUST support this method
      //! The default behaviour is to return (0).
      //!
      //! If this method is supported, then the derived class must support IsObjectOpen() and OpenObject().
      virtual ERRVALUE v_CloseObject (
         );

      //! Called whenever a default object type is needed for comparison or default parameters.
      //!
      //! All derived classes that model a specific object must override this method and provide a correct
      //! RVC::OBJTYPE_... value.  The default value is RVC::OBJTYPE_File.
      virtual RVC::OBJTYPE v_GetDftObjectType (
         ) const;

      //! Can the derived class handle multiple object types.
      //!
      //! Used in caes where the object instance determines the object to look for
      virtual bool v_IsMultiObject (
         ) const;

      //! Called by the IsOpen() method to determine if the rvc object is open, if possible and necessary.
      //!
      //! If the derived class retains an open state with the rvc object, then the derived class MUST support this method
      //! The default behaviour is to return (true).
      //!
      //! If this method is supported, then the derived class must support CloseObject() and OpenObject().
      virtual bool v_IsObjectOpen (
         ) const;             

      //! Called by the Open() methods to open an rvc object.
      //!
      //! If the derived class retains an open state with the rvc object, then the derived class MUST support this method
      //! The default behaviour is to return (0).
      //!
      //! If this method is supported, then the derived class must support CloseObject() and IsObjectOpen().
      virtual ERRVALUE v_OpenObject (
         OPENMODE OpenMode,
         MDLGPARENT parent
         );

      //! Called to determine if the derived class can handle the specified object type
      //!
      //! All derived classes that model a specific object must override this method and test the validity of the 
      //! RVC::OBJTYPE_... value passed in.  The default value is true, since the RVC::OBJECT class can handle any object type
      virtual bool v_ValidateObjectType (
         const RVC::OBJTYPE otype
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      ERRVALUE AttachLow (
         const FILEPATH& FilePath,
         const RVCINODENUM InodeNum,
         OPENMODE OpenMode,               //!< Mode in which to open the object
         MDLGPARENT parent = 0            //!< Parent dialog handle, 0 for default handle
         );

      ERRVALUE AttachLow (
         const OBJITEM& ObjItem,
         OPENMODE OpenMode,               //!< Mode in which to open the object
         MDLGPARENT parent = 0            //!< Parent dialog handle, 0 for default handle
         );

      ERRVALUE AttachLow (
         const FILEPATH& FilePath,
         const MISTRING& ObjectPath,
         OPENMODE OpenMode,               //!< Mode in which to open the object
         MDLGPARENT parent = 0            //!< Parent dialog handle, 0 for default handle
         );

      ERRVALUE AttachLow (
         const OBJECT& parent,
         const OBJTYPE ObjType,
         const OBJECTNAME& name,
         OPENMODE OpenMode,               //!< Mode in which to open the object
         MDLGPARENT widget = 0            //!< Parent dialog handle, 0 for default handle
         );

      ERRVALUE AttachLow (
         const OBJECT& source,
         const UNICODE *filename,
         const MISTRING& ObjectPath,
         OPENMODE OpenMode,               //!< Mode in which to open the object
         MDLGPARENT parent = 0            //!< Parent dialog handle, 0 for default handle
         );

      static void CallbackFunc (MfAnyCallbackStruct *cb, void *data);
      #endif // GENERATING_DOXYGEN_OUTPUT

   };
DEFINE_ENUM_OPERATORS(OBJECT::COPYFLAGS);


//! Constant iterator class
//!
//! This class is used to iterate through a parent rvc object's children.  This construct replaces the MfGetList() routines.
//! See methods ChildListBegin() and ChildListEnd() for obtaining an child iterator
class OBJECT::CONST_ITERATOR {
   public:

      //! Default constructor
      CONST_ITERATOR (
         ) : 
         m_Iterator(0),
         m_CurrentObj(0),
         m_ObjType(OBJTYPE_All)
         {}

      //! Idiot constructor for G++
      explicit CONST_ITERATOR (
         int WorthlessValue
         ) : 
         m_Iterator(0),
         m_CurrentObj(0),
         m_ObjType(OBJTYPE_All)
         {}

      //! Copy constructor
      CONST_ITERATOR (
         const CONST_ITERATOR& rhs
         );

      //! Interanl constructor used by ChildListBegin() methods
      CONST_ITERATOR (
         const RVC::OBJECT* parent,
         RVC::OBJTYPE m_ObjType
         );

      //! Destructor
      virtual ~CONST_ITERATOR (
         );

      //! Assignment
      CONST_ITERATOR& operator= (
         const CONST_ITERATOR& rhs
         );

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

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

      //! Pre-increment
      CONST_ITERATOR& operator++ (
         );

      //! Comparison for equality
      bool operator== (
         const CONST_ITERATOR& rhs
         ) const {return (m_Iterator == rhs.m_Iterator);}

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

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


//!