/* $NoKeywords: $ */
/*
//
// Copyright (c) 1993-2012 Robert McNeel & Associates. All rights reserved.
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
// McNeel & Associates.
//
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
//				
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
//
////////////////////////////////////////////////////////////////
*/

////////////////////////////////////////////////////////////////
//
//   virtual base class for all openNURBS objects
//
////////////////////////////////////////////////////////////////

#if !defined(OPENNURBS_OBJECT_INC_)
#define OPENNURBS_OBJECT_INC_


class ON_ClassId; // used for runtime class identification

////////////////////////////////////////////////////////////////
//
//
/*
 Description:
   OpenNURBS classes derived from ON_Object use ON_ClassId to
   store run-time type information  
   
   The ON_OBJECT_DECLARE and ON_OBJECT_IMPLEMENT macros generate
   the code that creates and initializes the ON_ClassId for each
   class.

   The ON_Object::IsKindOf() and ON_Object::Cast() functions
   use this run-time type information.
*/
class ON_CLASS ON_ClassId
{
public:

  // Description:
  //   This constructor is called to initialize each class id.
  //   The call is generated by the ON_OBJECT_IMPLEMENT macro.
  //
  // Parameters:
  //   sClassName - [in] name of the class (like ON_Geometry)
  //   sBaseClassName - [in] name of baseclass (like ON_Object)
  //   create - [in] function to create a new object(like CreateNewON_Geometry())
  //   sUUID - [in] UUID in registry format from Windows guidgen.exe
  ON_ClassId( 
          const char* sClassName,
          const char* sBaseClassName,
          class ON_Object* (*create)(),
          const char* sUUID
           );

  ~ON_ClassId();

  // Description: 
  //   Gets a class's ON_ClassId from the class's name.
  // Parameters:
  //   sClassName - [in] name of class
  // Returns: 
  //   Pointer to the class's ON_ClassId.
  // Example:
  //   const ON_ClassId* brep_id = ON_CLassId::ClassId("ON_Brep");
  static const ON_ClassId* ClassId( 
          const char* sClassName
          );

  // Description: 
  //   Gets a class's ON_ClassId from the class's uuid.
  // Parameters:
  //   class_uuid - [in] uuid for the class
  // Returns: 
  //   Pointer to the class's ON_ClassId.
  // Example:
  //   ON_UUID brep_uuid = ON_UuidFromString("60B5DBC5-E660-11d3-BFE4-0010830122F0");
  //   const ON_ClassId* brep_id = ON_ClassId::ClassId(brep_uuid);
  static const ON_ClassId* ClassId( 
          ON_UUID class_uuid
          );

  // Description:
  //   Each class derived from ON_Object has a corresponding ON_ClassId
  //   stored in a linked list and the class is marked with an integer
  //   value.  ON_ClassId::IncrementMark() increments the value used to
  //   mark new classes and returns the new marking value.
  // Returns:
  //   Value that will be used to mark all future ON_ClassIds.
  static int IncrementMark();
  static int CurrentMark();
  static const ON_ClassId* LastClassId();

  // Description:
  //   Each class derived from ON_Object has a corresponding
  //   ON_ClassId stored in a linked list.  If a class definition
  //   is going to disappear (which happens when the derived object
  //   definition is in a DLL that uses openNURBS as a DLL and the 
  //   DLL containing the derived object's definition is unloaded),
  //   then the class's ON_ClassId needs to be removed from the class 
  //   list.  ON_ClassId::Purge( mark ) removes all ON_ClassIds with a
  //   a prescribed mark and returns the number of classes that
  //   were purged.  
  // Parameters:
  //   mark - [in] All ON_ClassIds with this mark will be purged.
  // Returns:
  //   Number of classes that were purged.
  // Example:
  //   // Call ON_ClassId::IncrementMark() BEFORE loading MY.DLL.
  //   int my_dll_classid_mark = ON_ClassId::IncrementMark();
  //   load MY.DLL with classes derived from ON_Object
  //   ...
  //   // Call ON_ClassId::Purge() BEFORE unloading MY.DLL.
  //   ON_ClassId::Purge( my_dll_classid_mark );
  //   unload MY.DLL
  static int Purge(int mark);
  static bool PurgeAfter(const ON_ClassId* pClassId);

  // Description:
  //   Dumps the ON_ClassId list
  // Parameters:
  //   dump - [in] destination for the text dump.
  static void Dump( 
    ON_TextLog& dump
    );

  // Returns:
  //   class name
  const char* ClassName() const;

  // Returns:
  //   base class name
  const char* BaseClassName() const;
  
  // Returns:
  //   base class id
  const ON_ClassId* BaseClass() const;

  // Description:
  //   Determine if the class associated with this ON_ClassId
  //   is derived from another class.
  // Parameters:
  //   potential_parent - [in] Class to test as parent.
  // Returns:
  //   true if this is derived from potential_parent.
	bool IsDerivedFrom( 
    const ON_ClassId* potential_parent
    ) const;

  // Descrption:
  //   Use the default constructor to create an instance of the
  //   class on the heap.
  // Returns:
  //   Null or a pointer to an instance of the class created
  //   using new and the class's default constructor.
  ON_Object* Create() const;

  // Returns:
  //   class uuid
  ON_UUID Uuid() const;

  /*
  Description:
    Opennurbs classes have a mark value of 0.  Core Rhino
    classes have a mark value of 1.  Rhino plug-in classes
    have a mark value of > 1.
  Returns:
    Class mark value
  */
  int Mark() const;

  unsigned int ClassIdVersion() const;

private:
  static ON_ClassId* m_p0;     // first id in the linked list of class ids
  static ON_ClassId* m_p1;     // last id in the linked list of class ids
  static int m_mark0;  // current mark value
  ON_ClassId* m_pNext;         // next in the linked list of class ids
  const ON_ClassId* m_pBaseClassId;  // base class id
  char m_sClassName[80];              
  char m_sBaseClassName[80];
  // m_create points to a function that calls the default constuctor.
  // m_create() is used to create classes from uuids when reading files.
  ON_Object* (*m_create)(); 
  ON_UUID m_uuid;
  int m_mark; // bit 0x80000000 is used to indicate new extensions

private:
  // There are no implementaions of the default constructor, copy constructor
  // or operator=() to prohibit use.
  ON_ClassId();
  ON_ClassId( const ON_ClassId&);
  ON_ClassId& operator=( const ON_ClassId&);

private:
  void ConstructorHelper( 
          const char* sClassName, 
          const char* sBaseClassName, 
          const char* sUUID
          );

  // The m_f[] pointers provide a way add a "virtual" function to
  // a class derived from ON_Object without breaking the SDK.
  // At each SDK breaking relase, any functions that use this
  // mechanism are made into C++ virtual functions on the appropriate
  // classes. Currently, none of these are in use.
  unsigned int m_class_id_version; 
  void* m_f1;
  void* m_f2;
  void* m_f3;
  void* m_f4;
  void* m_f5;
  void* m_f6;
  void* m_f7;
  void* m_f8;
};

/*
Description:
  ON_CLASS_RTTI is a macro to get the class's run-time type
  information from class name.
Example:
        // Get the ON_Brep class's run-time type information.
        const ON_ClassId& brep_rtti = ON_CLASS_RTTI(ON_Brep);
*/
#define ON_CLASS_RTTI( cls ) cls::m_##cls##_class_rtti

/*
Description:
  ON_CLASS_ID is a macro to get the class's uuid from
  a class name.
Example:
        // Get the class id for ON_Brep.
        ON_UUID brep_class_id = ON_CLASS_ID(ON_Brep);
*/
#define ON_CLASS_ID( cls ) ON_CLASS_RTTI( cls ).Uuid()

/*
Description:
  Expert user function to get the value of ON_ClassId::m_uuid
  of the last instance of ON_ClassId to call ON_ClassId::Create().
  This function was created to support Rhino's .NET SDK.
  This function returns the value of a static id in
  opennurbs_object.cpp and is NOT thread safe.
Returns:
  Value of ON_ClassId::m_uuid of the instance of ON_ClassId that
  most recently called ON_ClassId::Create().
*/
ON_DECL
ON_UUID ON_GetMostRecentClassIdCreateUuid();


#define ON_OBJECT_DECLARE_VIRTUAL
#define ON_OBJECT_DECLARE_OVERRIDE override

/*
All classes derived from ON_Object must have the declaration macro
  ON_OBJECT_DECLARE( <classname> );
as the first line in their class definition, must have a robust
operator=(), should have a robust copy constructory, and must
have exactly one of the following implementation macros in 
a .cpp file.
  Classes with a pure virtual function:
    ON_VIRTUAL_OBJECT_IMPLEMENT( <classname>, <basclassname>, <classuuid> )
  Classes with an operator= and copy constructor.
    ON_OBJECT_IMPLEMENT( <classname>, <basclassname>, <classuuid> )
  Classes with an operator=, but no copy constructor.
    ON_OBJECT_IMPLEMENT_NO_COPYCTOR( <classname>, <basclassname>, <classuuid> )
*/
#define ON_OBJECT_DECLARE( cls )                          \
  protected:                                              \
    static void* m_s_##cls##_ptr;                         \
                                                          \
  public:                                                 \
    /* OpenNURBS class run-time type information */       \
    static const ON_ClassId m_##cls##_class_rtti;         \
                                                          \
    /*OpenNURBS platfrom independent dynamic cast*/       \
    static cls * Cast( ON_Object* );                      \
                                                          \
    /*OpenNURBS platfrom independent dynamic cast*/       \
    static const cls * Cast( const ON_Object* );          \
                                                          \
    /*Returns: OpenNURBS run-time type information.*/     \
    ON_OBJECT_DECLARE_VIRTUAL const ON_ClassId* ClassId() const ON_OBJECT_DECLARE_OVERRIDE; \
                                                          \
  public:                                                 \
    /*Description:                                     */ \
    /*  Uses a virtual function to create a deep copy. */ \
    /*Returns:                                         */ \
    /*  null or a deep copy with type this->ClassId(). */ \
    /*See Also:                                        */ \
    /*  ON_Curve::DuplicateCurve()                     */ \
    /*  ON_Surface::DuplicateSurface()                 */ \
    /*  CRhinoObject::DuplicateRhinoObject()           */ \
    cls * Duplicate() const;                              \
                                                          \
    /*Description:                                     */ \
    /*  Uses operator= to copy src to this.            */ \
    /*Returns:                                         */ \
    /*  True if successful.                            */ \
    /*  False if src is null or an incompatible type.  */ \
    ON_OBJECT_DECLARE_VIRTUAL bool CopyFrom(const ON_Object*) ON_OBJECT_DECLARE_OVERRIDE; \
                                                          \
  private:                                                \
    /* Duplicate() uses this virtual helper function. */  \
    ON_OBJECT_DECLARE_VIRTUAL ON_Object* Internal_DeepCopy() const ON_OBJECT_DECLARE_OVERRIDE \
                                                          

/*
Classes derived from ON_Object that are pure virtual classes,
or do not have a valid default constructor, valid operator new
or valid operator= must use ON_VIRTUAL_OBJECT_IMPLEMENT in their
implementation. Classes implemented with ON_VIRTUAL_OBJECT_IMPLEMENT
cannot be serialized using ON_BinaryArchive::ReadObject()/WriteObject()
or duplicated using ON_Object::Duplicate().
The Cast() and ClassId() members work on classes implemented with
ON_VIRTUAL_OBJECT_IMPLEMENT, ON_OBJECT_IMPLEMENT or
ON_OBJECT_IMPLEMENT_NO_COPYCTOR
*/
#define ON_VIRTUAL_OBJECT_IMPLEMENT( cls, basecls, uuid ) \
  void* cls::m_s_##cls##_ptr = nullptr; \
  const ON_ClassId cls::m_##cls##_class_rtti(#cls,#basecls,0,uuid);\
  cls * cls::Cast( ON_Object* p) {return(p&&p->IsKindOf(&cls::m_##cls##_class_rtti))?static_cast< cls *>(p):nullptr;} \
  const cls * cls::Cast( const ON_Object* p) {return(p&&p->IsKindOf(&cls::m_##cls##_class_rtti))?static_cast<const cls *>(p):nullptr;} \
  const ON_ClassId* cls::ClassId() const {return &cls::m_##cls##_class_rtti;} \
  bool cls::CopyFrom(const ON_Object*) {return false;} \
  cls * cls::Duplicate() const {return static_cast< cls *>(this->Internal_DeepCopy());} \
  ON_Object* cls::Internal_DeepCopy() const {return nullptr;}

/*
Classes derived from ON_Object that have a valid default constructor,
valid copy constructor, operator new and operator= can use
ON_OBJECT_IMPLEMENT in their implementation.  Classes implemented
with ON_OBJECT_IMPLEMENT can be created from their run-time type
information id and their Duplicate() function will use the class's
copy constructor to create a deep copy.
*/
#define ON_OBJECT_IMPLEMENT( cls, basecls, uuid ) \
  void* cls::m_s_##cls##_ptr = nullptr; \
  static ON_Object* CreateNew##cls() {return new cls();} \
  const ON_ClassId cls::m_##cls##_class_rtti(#cls,#basecls,CreateNew##cls,uuid);\
  cls * cls::Cast( ON_Object* p) {return(p&&p->IsKindOf(&cls::m_##cls##_class_rtti))?static_cast< cls *>(p):nullptr;} \
  const cls * cls::Cast( const ON_Object* p) {return(p&&p->IsKindOf(&cls::m_##cls##_class_rtti))?static_cast<const cls *>(p):nullptr;} \
  const ON_ClassId* cls::ClassId() const {return &cls::m_##cls##_class_rtti;} \
  bool cls::CopyFrom( const ON_Object* src){const cls * s=cls::Cast(src); if ( nullptr != this && nullptr != s) {*this = *s; return true;}return false;} \
  cls * cls::Duplicate() const {return static_cast< cls *>(this->Internal_DeepCopy());} \
  ON_Object* cls::Internal_DeepCopy() const {return new cls (*this);}

/*
Classes derived from ON_Object that have a valid default constructor,
operator new and operator=, but do not have a valid copy constructor,
can use ON_OBJECT_IMPLEMENT_NO_COPYCTOR in their implementation.
Classes implemented with ON_OBJECT_IMPLEMENT_NO_COPYCTOR can be created 
from their run-time type information id and their Duplicate() function
will use the class's default constructor and operator= to create a
deep copy.
*/
#define ON_OBJECT_IMPLEMENT_NO_COPYCTOR( cls, basecls, uuid ) \
  void* cls::m_s_##cls##_ptr = nullptr; \
  static ON_Object* CreateNew##cls() {return new cls();} \
  const ON_ClassId cls::m_##cls##_class_rtti(#cls,#basecls,CreateNew##cls,uuid);\
  cls * cls::Cast( ON_Object* p) {return(p&&p->IsKindOf(&cls::m_##cls##_class_rtti))?static_cast< cls *>(p):nullptr;} \
  const cls * cls::Cast( const ON_Object* p) {return(p&&p->IsKindOf(&cls::m_##cls##_class_rtti))?static_cast<const cls *>(p):nullptr;} \
  const ON_ClassId* cls::ClassId() const {return &cls::m_##cls##_class_rtti;} \
  bool cls::CopyFrom( const ON_Object* src){const cls* s=cls::Cast(src); if ( 0 != this && 0 != s) {*this = *s; return true;}return false;} \
  cls * cls::Duplicate() const {return static_cast< cls *>(this->Internal_DeepCopy());} \
  ON_Object* cls::Internal_DeepCopy() const { cls* p = new cls();if (p) {*p = *this; return p;}return nullptr;}

/*
Classes derived from ON_Object that have a valid default constructor,
operator new and operator=, but do not have a valid copy constructor or assignment operator,
can use ON_OBJECT_IMPLEMENT_NO_COPY in their implementation.
Classes implemented with ON_OBJECT_IMPLEMENT_NO_COPY can be created
from their run-time type information id and their Duplicate() function
will silently return a nullptr.  CopyFrom will return false.
*/
#define ON_OBJECT_IMPLEMENT_NO_COPY( cls, basecls, uuid ) \
  void* cls::m_s_##cls##_ptr = nullptr; \
  static ON_Object* CreateNew##cls() {return new cls();} \
  const ON_ClassId cls::m_##cls##_class_rtti(#cls,#basecls,CreateNew##cls,uuid);\
  cls * cls::Cast( ON_Object* p) {return(p&&p->IsKindOf(&cls::m_##cls##_class_rtti))?static_cast< cls *>(p):nullptr;} \
  const cls * cls::Cast( const ON_Object* p) {return(p&&p->IsKindOf(&cls::m_##cls##_class_rtti))?static_cast<const cls *>(p):nullptr;} \
  const ON_ClassId* cls::ClassId() const {return &cls::m_##cls##_class_rtti;} \
  bool cls::CopyFrom( const ON_Object* src){return false;} \
  cls * cls::Duplicate() const {return nullptr;} \
  ON_Object* cls::Internal_DeepCopy() const { return nullptr;}

#define ON__SET__THIS__PTR(ptr) if (ptr) *((void**)this) = ptr

class ON_CLASS ON_UserString
{
public:
  ON_UserString();
  ~ON_UserString();
  ON_wString m_key;
  ON_wString m_string_value;

  void Dump(ON_TextLog& text_log) const;
  bool Write(ON_BinaryArchive&) const;
  bool Read(ON_BinaryArchive&);
};

#if defined(ON_DLL_TEMPLATE)
ON_DLL_TEMPLATE template class ON_CLASS ON_ClassArray<ON_UserString>;
#endif

/*
Description:
  When ON_Object::IsValid() fails and returns false, ON_IsNotValid()
  is called.  This way, a developer can put a breakpoint in
  ON_IsNotValid() and stop execution at the exact place IsValid()
  fails.
Returns:
  false;
*/
ON_DECL
bool ON_IsNotValid();

////////////////////////////////////////////////////////////////

// Description:
//   Pure virtual base class for all classes that must provide
//   runtime class id or support object level 3DM serialization
class ON_CLASS ON_Object
{
#undef ON_OBJECT_DECLARE_VIRTUAL
#undef ON_OBJECT_DECLARE_OVERRIDE
#define ON_OBJECT_DECLARE_VIRTUAL virtual
#define ON_OBJECT_DECLARE_OVERRIDE
  // This is the base class
  ON_OBJECT_DECLARE(ON_Object);
  // Every other use of ON_OBJECT_DECLARE() is in derived class
#undef ON_OBJECT_DECLARE_VIRTUAL
#undef ON_OBJECT_DECLARE_OVERRIDE
#define ON_OBJECT_DECLARE_VIRTUAL
#define ON_OBJECT_DECLARE_OVERRIDE override

public:
  ON_Object() ON_NOEXCEPT;
  virtual ~ON_Object();
  ON_Object( const ON_Object& );
  ON_Object& operator=( const ON_Object& );

#if defined(ON_HAS_RVALUEREF)
  // rvalue copy constructor
  ON_Object( ON_Object&& ) ON_NOEXCEPT;

  // The rvalue assignment operator calls this->PurgeUserData()
  // which calls unknown destructors that could throw exceptions.
  ON_Object& operator=( ON_Object&& );
#endif

public:




  /*
  Description:
    Sets m_user_data_list = 0.
  */
  void EmergencyDestroy();

  /*
  Description:
    The MemoryRelocate() function is called when an 
    object's location in memory is changed.  For 
    example, if an object resides in a chunk of 
    memory that is grown by calling a realloc
    that has to allocate a new chunk and
    copy the contents of the old chunk to the
    new chunk, then the location of the object's
    memory changes.  In practice this happens when
    classes derived from ON_Object are stored
    in dynamic arrays, like the default implementation
    of ON_ObjectArray<>'s that use realloc to grow
    the dynamic array.
  */
  virtual 
  void MemoryRelocate();

  /*
  Description:
    Low level tool to test if an object is derived
    from a specified class.
  Parameters:
    pClassId - [in] use classname::ClassId()
  Returns:
    true if the instantiated object is derived from the
    class whose id is passed as the argument.
  Example:

          ON_Object* p = ....;
          if ( p->IsKindOf( ON_NurbsCurve::ClassId() ) )
          {
            it's a NURBS curve
          }

  Remarks:
    The primary reason for IsKindOf() is to support the
    static Cast() members declared in the ON_OBJECT_DECLARE
    macro.  If we determine that dynamic_cast is properly 
    supported and implemented by all supported compilers, 
    then IsKindOf() may dissappear.  If an application needs
    to determine if a pointer points to a class derived from
    ON_SomeClassName, then call 
    ON_SomeClassName::Cast(mystery pointer) and check for 
    a non-null return.
  */
  bool IsKindOf( 
        const ON_ClassId* pClassId
        ) const;

  /*
  Description:
    Tests an object to see if its data members are correctly
    initialized.
  Parameters:
    text_log - [in] if the object is not valid and text_log
        is not nullptr, then a brief englis description of the
        reason the object is not valid is appened to the log.
        The information appended to text_log is suitable for 
        low-level debugging purposes by programmers and is 
        not intended to be useful as a high level user 
        interface tool.
  Returns:
    @untitled table
    true     object is valid
    false    object is invalid, uninitialized, etc.
  */
  virtual bool IsValid( class ON_TextLog* text_log = nullptr ) const;

  /*
  Description:
    Tests to see if this is null in ways that will prevent compilers like
    CLang from thinking the test is not necessary. 
    The reason the runtime test is being performed is to find bugs that call 
    member functions on null pointers.
  */
  bool ThisIsNullptr(
    bool bSilentError
  ) const;

  /*
  Description:
    Check for corrupt data values that are likely to cause crashes.
  Parameters:
    bRepair - [in]
      If true, const_cast<> will be used to change the corrupt data
      so that crashes are less likely.
    bSilentError - [in]
      If true, ON_ERROR will not be called when corruption is detected.
    text_log - [out]
      If text_log is not null, then a description of corruption 
      is printed using text_log.
  Remarks:
    Ideally, IsCorrupt() would be a virtual function on ON_Object,
    but doing that at this point would break the public SDK.
  */
  bool IsCorrupt(
    bool bRepair,
    bool bSilentError,
    class ON_TextLog* text_log
  ) const;

  /*
  Description:
    Creates a text dump of the object.
  Remarks:
    Dump() is intended for debugging and is not suitable
    for creating high quality text descriptions of an
    object.

    The default implementations of this virtual function 
    prints the class's name.
  */
  virtual
  void Dump( ON_TextLog& ) const;

  /*
  Returns:
    An estimate of the amount of memory the class uses in bytes.
  */
  virtual
  unsigned int SizeOf() const;

  /*
  Description:
    Returns a CRC calculated from the information that defines
    the object.  This CRC can be used as a quick way to see
    if two objects are not identical.
  Parameters:
    current_remainder - [in];
  Returns:
    CRC of the information the defines the object.
  */
  virtual
  ON__UINT32 DataCRC(ON__UINT32 current_remainder) const;

  /*
  Description:
    Low level archive writing tool used by ON_BinaryArchive::WriteObject().
  Parameters:
    binary_archive - archive to write to
  Returns:
    Returns true if the write is successful.
  Remarks:
    Use ON_BinaryArchive::WriteObject() to write objects.
    This Write() function should just write the specific definition of
    this object.  It should not write and any chunk typecode or length
    information.  

    The default implementation of this virtual function returns 
    false and does nothing.
  */
  virtual
  bool Write(
         ON_BinaryArchive& binary_archive
       ) const;

  /*
  Description:
    Low level archive writing tool used by ON_BinaryArchive::ReadObject().
  Parameters:
    binary_archive - archive to read from
  Returns:
    Returns true if the read is successful.
  Remarks:
    Use ON_BinaryArchive::ReadObject() to read objects.
    This Read() function should read the objects definition back into
    its data members.

    The default implementation of this virtual function returns 
    false and does nothing.
  */
  virtual
  bool Read(
         ON_BinaryArchive& binary_archive
       );

  /*
  Description:
    Useful for switch statements that need to differentiate
    between basic object types like points, curves, surfaces,
    and so on.

  Returns: 
    ON::object_type enum value.

  Remarks:
    The default implementation of this virtual function returns
    ON::unknown_object_type
  */
  virtual
  ON::object_type ObjectType() const;



  /*
  Description:
    All objects in an opennurbs model have an id
    ( ON_Layer.m_layer_id, ON_Font.m_font_id, 
      ON_Material.m_material_id, ON_3dmObjectAttributes.m_uuid
      ).
  Returns:
    The id used to identify the object in the openurbs model.
  */
  virtual
  ON_UUID ModelObjectId() const;

  //////////////////////////////////////////////////////////////////
  //
  // BEGIN: User string support
  //

  /*
  Description:
    Attach a user string to the object.  This information will
    perisist through copy construction, operator=, and file IO.
  Parameters:
    key - [in] id used to retrieve this string.
    string_value - [in] 
      If nullptr, the string with this id will be removed.
  Returns:
    True if successful.
  */
  bool SetUserString( 
    const wchar_t* key, 
    const wchar_t* string_value 
    );

  /*
  Description:
    Append entries to the user string list
  Parameters:
    count - [in]
      number of element in us[] array
    user_strings - [in]
      entries to append.
    bReplace - [in]
      If bReplace is true, then existing entries with the same key are
      updated with the new entry's value.  If bReplace is false, then
      existing entries are not updated.
  Returns:
    Number of entries added, deleted, or modified.
  */
  int SetUserStrings( int count, const ON_UserString* user_strings, bool bReplace );

  /*
  Description:
    Get user string from the object.
  Parameters:
    key - [in] id used to retrieve the string.
    string_value - [out]
  Returns:
    True if a string with id was found.
  */
  bool GetUserString( 
    const wchar_t* key, 
    ON_wString& string_value 
    ) const;

  /*
  Description:
    Get a list of all user strings on the object.
  Parameters:
    user_strings - [out]
      user strings are appended to this list.
  Returns:
    Number of elements appended to the user_strings list.
  */
  int GetUserStrings( 
    ON_ClassArray<ON_UserString>& user_strings 
    ) const;

  /*
  Description:
    Get a list of all user string keys on the object.
  Parameters:
    user_string_keys - [out]
      user string keys are appended to this list.
  Returns:
    Number of elements appended to the user_strings list.
  */
  int GetUserStringKeys( 
    ON_ClassArray<ON_wString>& user_string_keys 
    ) const;

  /*
  Returns:
    Number of user strings on the object.
  */
  int UserStringCount() const;

  //
  // END: User string support
  //
  //////////////////////////////////////////////////////////////////

  /////////////////////////////////////////////////////////////////
  //
  // User data provides a standard way for extra information to
  // be attached to any class derived from ON_Object.  The attached
  // information can persist and be transformed.  If you use user
  // data, please carefully read all the comments from here to the
  // end of the file.
  //

  /*
  Description:
    Attach user data to an object.
  Parameters:
    pUserData - [in] user data to attach to object.
        The ON_UserData pointer passed to AttachUserData()
        must be created with new.  
  Returns:
    If true is returned, then ON_Object will delete the user
    data when appropriate.  If false is returned, then data 
    could not be attached and caller must delete.  
  Remarks:
    AttachUserData() will fail if the user data's m_userdata_uuid
    field is nil or not unique.
  */
  bool AttachUserData( 
          class ON_UserData* pUserData 
          );

  /*
  Description:
    Remove user data from an object.
  Parameters:
    pUserData - [in] user data to attach to object.
        The ON_UserData pointer passed to DetachUserData()
        must have been previously attached using 
        AttachUserData().  
  Returns:
    If true is returned, then the user data was
    attached to this object and it was detached.  If false
    is returned, then the user data was not attached to this
    object to begin with.  In all cases, you can be assured
    that the user data is no longer attached to "this".
  Remarks:
    Call delete pUserData if you want to destroy the user data.
  */
  bool DetachUserData(
          class ON_UserData* pUserData 
          );


  /*
  Description:
    Get a pointer to user data.
  Parameters:
    userdata_uuid - [in] value of the user data's 
       m_userdata_uuid field.
  Remarks:
    The returned user data is still attached to the object.
    Deleting the returned user data will automatically remove
    the user data from the object.
  */
  class ON_UserData* GetUserData( 
          const ON_UUID& userdata_uuid
          ) const;

  /*
  Description:
    PurgeUserData() removes all user data from object.  
  Remarks:
    Use delete GetUserData(...) to destroy a single piece
    of user data.
  */
  void PurgeUserData();

  /*
  Description:
    User data is stored as a linked list of ON_UserData
    classes.  FirstUserData gets the first item in the
    linked list.  This is the most recent item attached
    using AttachUserData().
  Remark:
    To iterate through all the user data on an object, 
    call FirstUserData() and then use ON_UserData::Next()
    to traverse the list.
  */
  class ON_UserData* FirstUserData() const;

  /*
  Description:
    Objects derived from ON_Geometry must call
    TransformUserData() in their Transform() member function.
  Parameters:
    xform - [in] transformation to apply to user data
  */
  void TransformUserData( 
    const class ON_Xform& xform
    );

  /*
  Description:
    When a userdata item is copied or moved from a source object to
    a destination object, the ON_Object::UserDataConflictResolution
    enum values specify how conficts are resolved.
  Remark:
    A userdata item "conflict" occurs when both the destination
    and source object have a user data item with the same
    value of ON_UserData::m_userdata_uuid.
  */
  enum class UserDataConflictResolution : unsigned char
  {
    destination_object = 0,       // use destination item
    source_object = 1,            // use source item
    source_copycount_gt = 2,      // use source item if source copycount > destination copy count
    source_copycount_ge = 3,      // use source item if source copycount >= destination copy count
    destination_copycount_gt = 4, // use destination item if destination copycount > source copy count
    destination_copycount_ge = 5, // use destination item if destination copycount >= source copy count
    delete_item = 6               // delete item from the destination object
  };

  /*
  Description:
    Expert user tool that copies user data items with positive values of
    ON_UserData.m_userdata_copycount from source_object to "this.
  Parameters:
    source_object - [in] 
      source of user data to copy
    source_userdata_item_id - [in]
      If source_userdata_item_id  is not nil, then only the user data item
      with a matching ON_UserData.m_userdata_uuid value will be copied.
    userdata_conflict_resolution - [in]
      method to resolve userdata item conficts.
  Remarks:
    Generally speaking you don't need to use CopyUserData().
    Simply rely on ON_Object::operator=() or the copy constructor
    to do the right thing.
  Returns:
    Number of user data items that were copied.
  */
  unsigned int CopyUserData( 
    const ON_Object& source_object,
    ON_UUID source_userdata_item_id,
    ON_Object::UserDataConflictResolution userdata_conflict_resolution
    );

  /*
  Description:
    Expert user tool that moves user data items from source_object to "this.
  Parameters:
    source_object - [in] 
      source of user data to copy
    source_userdata_item_id - [in]
      If source_userdata_item_id  is not nil, then only the user data item
      with a matching ON_UserData.m_userdata_uuid value will be moved.
    userdata_conflict_resolution - [in]
      method to resolve userdata item conficts.
    bDeleteAllSourceItems - [in]
      If bDeleteAllSourceItems is true, then any userdata items
      that are not copied from source_object are deleted.
  Remarks:
    Generally speaking you don't need to use MoveUserData().
    Simply rely on ON_Object::operator=() or the copy constructor
    to do the right thing.
  Returns:
    Number of user data items that were moved.
  */
  unsigned int MoveUserData( 
    ON_Object& source_object,
    ON_UUID source_userdata_item_id,
    ON_Object::UserDataConflictResolution userdata_conflict_resolution,
    bool bDeleteAllSourceItems
    );

  /*
  Description:
    Calls CopyUserData(source_object,ON_Object::UserDataConflictResolution::source_object).
  Parameters:
    source_object - [in] 
  */
  void CopyUserData( 
    const ON_Object& source_object 
    );

  /*
  Description:
    Calls MoveUserData(source_object,ON_Object::UserDataConflictResolution::source_object,true).
  Parameters:
    source_object - [in] 
  */
  void MoveUserData( 
    ON_Object& source_object 
    );
  
  /*
  Description:
    Uses the destination_manifest to update references to other components.
    This is typically done when a component's references came from a "source" 
    context and are being updated to the "destination" context. For example,
    inserting one model into another when index, id, and name conflicts 
    need to be resolved at the time of insertion.
  Parameters:
    source_manifest - [in]
      A manifest of the source context with indices and ids 
      corresponding to the current component references.
      If this manifest is not available, pass ON_ComponentManifest::Empty.
    destination_manifest - [in]
      A manifest of the destination context with indices and ids 
      corresponding to the desired component references.
      If this manifest is not available, pass ON_ComponentManifest::Empty.
    manifest_map - [in]
      A map from the source (current) referenced component index/id values 
      to the destination (desired) component index/id values.
  Returns:
    True if successful.
    False indicates a referenced component was not found in the manifest
    and the reference was changed to a default value.
  Example:
    If this object is an ON_Layer, the line pattern and render material references
    are updated. 
    If this object is an ON_DimStyle, the text style reference is updated. 
    If this object is an ON_3dmObjectAttributes, the layer,
    material, line pattern, and group references are updated. 
  */
  virtual bool UpdateReferencedComponents(
    const class ON_ComponentManifest& source_manifest,
    const class ON_ComponentManifest& destination_manifest,
    const class ON_ManifestMap& manifest_map
    );
  
  /////////////////////////////////////////////////////////////////
  //
  // Component status interface
  //
  //  Currently implemnented on ON_SubD and ON_Brep
  //

  /*
  Description:
    Set all active level component states to ON_ComponentStatus::NoneSet.
  Returns:
    Number of components where a state setting chanaged.
  */
  unsigned int ClearAllComponentStates() const;

  /*
  Description:
    Clear the specified states on every component.
  Parameters:
    states_to_clear - [in]
      States to clear.
  Returns:
    Number of components where a state setting chanaged.
  */
  virtual
  unsigned int ClearComponentStates(
    ON_ComponentStatus states_to_clear
    ) const;

  /*
  Parameters:
    states_filter - [in]

    bAllEqualStates - [in]
      If a state is set in states_filter, all active level components
      with the same state set will be included in the 
      components_with_set_states[] array.  

      If bAllEqualStates is true, then ON_ComponentStatus::AllEqualStates()
      is used to test for inclusion.  

      If bAllEqualStates is false, then ON_ComponentStatus::SomeEqualStates()
      is used to test for inclusion.

    components_with_set_states - [out]
  Returns:
    Number of returned components.
  */
  virtual
  unsigned int GetComponentsWithSetStates(
    ON_ComponentStatus states_filter,
    bool bAllEqualStates,
    ON_SimpleArray< ON_COMPONENT_INDEX >& components
    ) const;
  
  /*
  Description:
    Set states on an individual component.
  Parameters:
    component_index - [in]
      The states will be set on this component.
    states_to_set - [in]
      If a state is set in the states_to_set parameter, the same
      state will be set on the component.      
  Returns:
    0: no state settings changed on the component.
    1: some state setting changed on the component.
  */
  virtual
  unsigned int SetComponentStates(
    ON_COMPONENT_INDEX component_index,
    ON_ComponentStatus states_to_set
    ) const;

  /*
  Description:
    Clear states on an individual component.
  Parameters:
    component_index - [in]
      The states will be cleared on this component.
    states_to_clear - [in]
      If a state is set in the states_to_clear parameter, the same
      state will be cleared on the component.      
  Returns:
    0: no state settings changed on the component.
    1: some state setting changed on the component.
  */
  virtual
  unsigned int ClearComponentStates(
    ON_COMPONENT_INDEX component_index,
    ON_ComponentStatus states_to_clear
    ) const;
  
  /*
  Description:
    Copy status settings to an individual component.
  Parameters:
    component_index - [in]
      The states will be copied to this component.
    status_to_copy - [in]
  Returns:
    0: no state settings changed on the component.
    1: some state setting changed on the component.
  */
  virtual
  unsigned int SetComponentStatus(
    ON_COMPONENT_INDEX component_index,
    ON_ComponentStatus status_to_copy
    ) const;

  /*
  Description:
    Call whenever a component status setting is modifed 
    by directly changing it on a component in a way that
    will result in any saved information about the parent
    object's aggretate component status becoming invalid.

  Returns:
    Aggregate information about the object's component states.
  */
  virtual
  ON_AggregateComponentStatus AggregateComponentStatus() const;

  /*
  Description:
    Call whenever a component status setting is modifed 
    by directly changing it on a component in a way that
    will result in any saved information about the parent
    object's aggretate component status becoming invalid.

  Remarks:
    The implementations of this function are nearly instant.
    and this function may be called as frequently as needed. 
    The next time AggregateComponentStatus()
    is called the information used to return the value
    will be updated.
  */
  virtual
  void MarkAggregateComponentStatusAsNotCurrent() const;

  /*
  Description:
    Delete the portions of the object identified in ci_list[].
  Parameters:
    ci_list - [in]
      List of components to delete.
    ci_list_count - [in]
      Number of elements in the ci_list[] array.
  Returns:
    True: succesful
    False: failure - no changes.
  */
  virtual
  bool DeleteComponents(
    const ON_COMPONENT_INDEX* ci_list,
    size_t ci_count
    );

  /////////////////////////////////////////////////////////////////
  //
  // Expert interface
  //

  /*
  Description:
    Expert user function.  If you are using openNURBS in its
    default configuration to read and write 3dm archives,
    you never need to call this function.
    Many objects employ lazy creation of (runtime) caches
    that save information to help speed geometric calculations.
    This function will destroy all runtime information.
  Parameters:
    bDelete - [in] if true, any cached information is properly
                   deleted.  If false, any cached information
                   is simply discarded.  This is useful when
                   the cached information may be in alternate
                   memory pools that are managed in nonstandard
                   ways.
  */
  virtual void DestroyRuntimeCache( bool bDelete = true );

private:
  class ON_UserData* m_userdata_list;
  class ON_UserData* TransferUserDataItem(
    const class ON_UserData* source_ud_copy_this,
    class ON_UserData* source_ud_move_this,
    bool bPerformConflictCheck,
    ON_Object::UserDataConflictResolution userdata_conflict_resolution
    );
};

#endif

