lili/opennurbs
1
0
Fork 0
mirror of https://github.com/mcneel/opennurbs.git synced 2026-03-01 19:46:08 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
cf8984bb9af96dc828d4a111b61e5c8212031e24
opennurbs/opennurbs_model_component.cpp
Bozo the Builder 7ab15c3169 Sync changes from upstream repository
2024-02-15 08:00:36 -08:00

4076 lines
111 KiB
C++
Raw Blame History

//
// Copyright (c) 1993-2022 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>.
//
////////////////////////////////////////////////////////////////
#include "opennurbs.h"
#if !defined(ON_COMPILING_OPENNURBS)
// This check is included in all opennurbs source .c and .cpp files to insure
// ON_COMPILING_OPENNURBS is defined when opennurbs source is compiled.
// When opennurbs source is being compiled, ON_COMPILING_OPENNURBS is defined
// and the opennurbs .h files alter what is declared and how it is declared.
#error ON_COMPILING_OPENNURBS must be defined when compiling opennurbs
#endif
ON_OBJECT_IMPLEMENT(ON_ModelComponent,ON_Object,"CF37CFB5-8E6F-435F-98FE-D20FA9E7DB6F");
bool ON_ModelComponent::IsValid(
ON_TextLog* text_log
) const
{
return ( m_runtime_serial_number > 0 );
}
const ON_wString ON_ModelComponent::ComponentTypeToString(
ON_ModelComponent::Type component_type
)
{
switch (component_type)
{
case ON_ModelComponent::Type::Unset:
return ON_wString("Unset");
case ON_ModelComponent::Type::ModelGeometry:
return ON_wString("ModelGeometry");
case ON_ModelComponent::Type::Image:
return ON_wString("EmbeddedFile");
case ON_ModelComponent::Type::LinePattern:
return ON_wString("LinePattern");
case ON_ModelComponent::Type::Layer:
return ON_wString("Layer");
case ON_ModelComponent::Type::Group:
return ON_wString("Group");
case ON_ModelComponent::Type::TextStyle:
return ON_wString("TextStyle");
case ON_ModelComponent::Type::DimStyle:
return ON_wString("AnnotationStyle");
case ON_ModelComponent::Type::HatchPattern:
return ON_wString("HatchPattern");
case ON_ModelComponent::Type::InstanceDefinition:
return ON_wString("InstanceDefinition");
case ON_ModelComponent::Type::HistoryRecord:
return ON_wString("HistoryRecord");
case ON_ModelComponent::Type::TextureMapping:
return ON_wString("TextureMapping");
case ON_ModelComponent::Type::Material:
return ON_wString("RenderMaterial");
case ON_ModelComponent::Type::RenderLight:
return ON_wString("RenderLight");
case ON_ModelComponent::Type::RenderContent:
return ON_wString("RenderContent");
case ON_ModelComponent::Type::EmbeddedFile:
return ON_wString("EmbeddedFile");
case ON_ModelComponent::Type::SectionStyle:
return ON_wString("SectionStyle");
case ON_ModelComponent::Type::ObsoleteValue:
return ON_wString("ObsoleteValue");
case ON_ModelComponent::Type::Mixed:
return ON_wString("Mixed");
default:
ON_ERROR("invalid m_component_type value");
}
return ON_wString::EmptyString;
}
ON_ModelComponentTypeIterator::ON_ModelComponentTypeIterator() ON_NOEXCEPT
{
const size_t types_capacity = sizeof(m_types)/sizeof(m_types[0]);
for (size_t k = 0; k < types_capacity; k++)
m_types[k] = ON_ModelComponent::Type::Unset;
}
ON_ModelComponentTypeIterator::ON_ModelComponentTypeIterator(
size_t type_count,
const ON_ModelComponent::Type* types
) ON_NOEXCEPT
{
const size_t types_capacity = sizeof(m_types)/sizeof(m_types[0]);
m_type_count
= (nullptr != types && type_count > 0)
? (int)((type_count < types_capacity) ? type_count : types_capacity)
: 0;
memset(m_types, 0, sizeof(m_types));
for (int i = 0; i < m_type_count; i++)
m_types[i] = types[i];
for (size_t k = (size_t)m_type_count; k < types_capacity; k++)
m_types[k] = ON_ModelComponent::Type::Unset;
}
unsigned int ON_ModelComponentTypeIterator::TypeCount() const
{
return (unsigned int)m_type_count;
}
ON_ModelComponent::Type ON_ModelComponentTypeIterator::FirstType()
{
m_current_index = ON_UNSET_INT_INDEX;
return NextType();
}
ON_ModelComponent::Type ON_ModelComponentTypeIterator::LastType()
{
m_current_index = ON_UNSET_INT_INDEX;
return PreviousType();
}
ON_ModelComponent::Type ON_ModelComponentTypeIterator::NextType()
{
if (m_type_count > 0)
{
if (ON_UNSET_INT_INDEX == m_current_index)
m_current_index = 0;
else if (m_current_index < m_type_count)
m_current_index++;
}
return CurrentType();
}
ON_ModelComponent::Type ON_ModelComponentTypeIterator::PreviousType()
{
if (m_type_count > 0)
{
if (ON_UNSET_INT_INDEX == m_current_index)
m_current_index = m_type_count-1;
else if (m_current_index >= 0)
m_current_index--;
}
return CurrentType();
}
ON_ModelComponent::Type ON_ModelComponentTypeIterator::CurrentType() const
{
return (m_current_index >= 0 && m_current_index < m_type_count) ? m_types[m_current_index] : ON_ModelComponent::Type::Unset;
}
void ON_ModelComponent::Dump(
ON_TextLog& text_log
) const
{
const char* sUnset = "unset";
if (false == text_log.IsTextHash())
{
// m_runtime_serial_number depends on how many components have
// been contructed before this one. It must be suppressed when
// calculating content hash values from text logs.
text_log.Print("Model component %llu\n", m_runtime_serial_number);
}
text_log.PushIndent();
// model serial number CRhinoDoc::RuntimeSerialNumber()
text_log.Print("Model serial number = ");
if (ModelSerialNumberIsSet())
{
const unsigned int model_sn = ModelSerialNumber();
text_log.Print("%u", model_sn);
text_log.PrintNewLine();
// worksession reference model
const unsigned int reference_model_sn = ReferenceModelSerialNumber();
if (reference_model_sn > 0)
{
text_log.Print("Reference model = %u\n", reference_model_sn);
}
// linked instance defintion model
const unsigned int idef_model_sn = InstanceDefinitionModelSerialNumber();
if (idef_model_sn > 0)
{
text_log.Print("Instance definition = %u\n", idef_model_sn);
}
}
else
{
text_log.Print(sUnset);
text_log.PrintNewLine();
}
text_log.Print("Type = ");
if (this->ComponentTypeIsSet())
{
text_log.Print(ON_ModelComponent::ComponentTypeToString(m_component_type));
}
else
{
text_log.Print(sUnset);
}
text_log.PrintNewLine();
text_log.Print("Id = ");
if (IdIsSet())
text_log.Print(Id());
else
text_log.Print(sUnset);
text_log.PrintNewLine();
text_log.Print("Index = ");
if (IndexIsSet())
text_log.Print("%d", Index());
else
text_log.Print(sUnset);
text_log.PrintNewLine();
text_log.Print("Name = ");
if (NameIsSet())
text_log.Print(L"%ls", static_cast<const wchar_t*>(m_component_name));
else
text_log.Print(sUnset);
text_log.PrintNewLine();
const ON__UINT64 content_version_number = ContentVersionNumber();
if (0 != content_version_number && false == text_log.IsTextHash())
{
// content_version_number values vary depending on how
// the actual content was specified, even if the final content
// is identical. It must must be suppressed when calculating
// content hash values from text logs.
// Use PRIu64 to portably print 64-bit unsigned int in decimal format.
text_log.Print("Content version number = %" PRIu64 "\n",content_version_number);
}
text_log.PopIndent();
}
void ON_ModelComponentReference::Dump(
ON_TextLog& text_log
) const
{
const ON_ModelComponent* model_component = ModelComponent();
if ( nullptr == model_component )
text_log.Print("Empty ON_ModelComponentReference\n");
else
model_component->Dump(text_log);
}
unsigned int ON_ModelComponent::SizeOf() const
{
return (unsigned int)((sizeof(*this) - sizeof(ON_Object)) + ON_Object::SizeOf());
}
ON__UINT32 ON_ModelComponent::DataCRC(
ON__UINT32 current_remainder
) const
{
current_remainder = ON_CRC32(current_remainder, sizeof(m_locked_status), &m_locked_status);
current_remainder = ON_CRC32(current_remainder, sizeof(m_set_status), &m_set_status);
if (ModelSerialNumberIsSet())
{
current_remainder = ON_CRC32(current_remainder, sizeof(m_model_serial_number), &m_model_serial_number);
current_remainder = ON_CRC32(current_remainder, sizeof(m_reference_model_serial_number), &m_reference_model_serial_number);
current_remainder = ON_CRC32(current_remainder, sizeof(m_linked_idef_serial_number), &m_linked_idef_serial_number);
}
if (IdIsSet())
current_remainder = ON_CRC32(current_remainder, sizeof(m_component_id), &m_component_id);
if (ComponentTypeIsSet())
current_remainder = ON_CRC32(current_remainder, sizeof(m_component_type), &m_component_type);
if (IndexIsSet())
current_remainder = ON_CRC32(current_remainder, sizeof(m_component_index), &m_component_index);
if (NameIsSet())
{
ON_NameHash name_hash = NameHash();
current_remainder = ON_CRC32(current_remainder, sizeof(name_hash), &name_hash);
}
return current_remainder;
}
ON_UUID ON_ModelComponent::ModelObjectId() const
{
return Id();
}
static ON__UINT64 ON_ModelComponentContentVersionNumberOne(
ON__UINT64 runtime_serial_number
)
{
// make it unlikely for classes created sequentually to have the same content version numbers.
ON__UINT64 s = ON_CRC32(0, sizeof(runtime_serial_number), &runtime_serial_number );
return (runtime_serial_number*0x100000000ULL | s);
}
ON_ModelComponent::ON_ModelComponent
(
ON__UINT64 runtime_serial_number
) ON_NOEXCEPT
: m_runtime_serial_number(runtime_serial_number)
, m_content_version_number(ON_ModelComponentContentVersionNumberOne(m_runtime_serial_number))
{}
ON_ModelComponent::ON_ModelComponent() ON_NOEXCEPT
: m_runtime_serial_number(++ON_ModelComponent::Internal_RuntimeSerialNumberGenerator)
, m_content_version_number(ON_ModelComponentContentVersionNumberOne(m_runtime_serial_number))
{}
static const ON_ModelComponent Unset;
ON_ModelComponent::Type ON_ModelComponent::ComponentTypeFromUnsigned(
unsigned int component_type_as_unsigned
)
{
switch (component_type_as_unsigned)
{
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::Unset);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::Image);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::TextureMapping);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::Material);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::LinePattern);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::Layer);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::Group);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::TextStyle);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::DimStyle);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::RenderLight);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::HatchPattern);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::InstanceDefinition);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::ModelGeometry);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::HistoryRecord);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::RenderContent);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::EmbeddedFile);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::ObsoleteValue);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::SectionStyle);
ON_ENUM_FROM_UNSIGNED_CASE(ON_ModelComponent::Type::Mixed);
}
ON_ERROR("component_type_as_unsigned has invalid value.");
return ON_ModelComponent::Type::Unset;
}
bool ON_ModelComponent::WriteModelComponentAttributes(
class ON_BinaryArchive& archive,
unsigned int attributes_filter
) const
{
const int major_version = 1;
const int minor_version = 0;
if (!archive.BeginWrite3dmChunk(TCODE_ANONYMOUS_CHUNK,major_version,minor_version))
return false;
bool rc = false;
for (;;)
{
unsigned int bit;
bit = ON_ModelComponent::Attributes::IdAttribute & attributes_filter;
const bool bWriteId = (0 != bit && IdIsSet());
bit = ON_ModelComponent::Attributes::ParentIdAttribute & attributes_filter;
const bool bWriteParentId = (0 != bit && ParentIdIsSet());
bit = ON_ModelComponent::Attributes::IndexAttribute & attributes_filter;
const bool bWriteIndex = (0 != bit && IndexIsSet());
bit = ON_ModelComponent::Attributes::NameAttribute & attributes_filter;
const bool bWriteName = (0 != bit && NameIsSet());
bit = ON_ModelComponent::Attributes::ComponentStatusAttribute & attributes_filter;
const bool bWriteComponentStatus = (0 != bit && ModelComponentStatusIsSet());
ON__UINT32 write_bits = 0U;
if ( bWriteId )
write_bits |= 0x01U;
if ( bWriteParentId )
write_bits |= 0x02U;
if ( bWriteIndex )
write_bits |= 0x04U;
if ( bWriteName )
write_bits |= 0x08U;
if ( bWriteComponentStatus )
write_bits |= 0x10U;
if (!archive.WriteInt(write_bits))
break;
if (bWriteId)
{
if (!archive.WriteUuid(Id()))
break;
}
if (bWriteParentId)
{
if (!archive.WriteUuid(ParentId()))
break;
}
if (bWriteIndex)
{
if (!archive.Write3dmReferencedComponentIndex(*this))
break;
}
if (bWriteName)
{
if (!archive.WriteString(Name()))
break;
}
if (bWriteComponentStatus)
{
const ON_ComponentStatus component_status = ModelComponentStatus();
const ON__UINT32 locked_bit = 0x01;
const ON__UINT32 hidden_bit = 0x02;
// Additional states can be saved if that is reasonable.
const ON__UINT32 mask
= locked_bit
| hidden_bit;
ON__UINT32 value = 0U;
if ( component_status.IsLocked() )
value |= locked_bit;
if ( component_status.IsHidden() )
value |= hidden_bit;
if (!archive.WriteInt(mask))
break;
if (!archive.WriteInt(value))
break;
}
rc = true;
break;
}
if (!archive.EndWrite3dmChunk())
rc = false;
return rc;
}
bool ON_ModelComponent::ReadModelComponentAttributes(
class ON_BinaryArchive& archive
)
{
int major_version = 10;
int minor_version = 0;
if (!archive.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version))
return false;
bool rc = false;
for (;;)
{
if ( 1 != major_version)
break;
ON__UINT32 write_bits = 0U;
if (!archive.ReadInt(&write_bits))
break;
const bool bReadId = (0 != (write_bits & 0x01U));
const bool bReadParentId (0 != (write_bits & 0x02U));
const bool bReadIndex (0 != (write_bits & 0x04U));
const bool bReadName (0 != (write_bits & 0x08U));
const bool bReadComponentStatus = (0 != (write_bits & 0x10U));
if (bReadId)
{
ON_UUID id = Id();
if (!archive.ReadUuid(id))
break;
SetId(id);
}
if (bReadParentId)
{
ON_UUID parent_id = ParentId();
if (!archive.ReadUuid(parent_id))
break;
SetParentId(parent_id);
}
if (bReadIndex)
{
int component_index = Index();
if (!archive.ReadInt(&component_index))
break;
SetIndex(component_index);
}
if (bReadName)
{
ON_wString name;
if (!archive.ReadString(name))
break;
SetName(name);
}
if (bReadComponentStatus)
{
ON__UINT32 mask = 0U;
if (!archive.ReadInt(&mask))
break;
ON__UINT32 value = 0U;
if (!archive.ReadInt(&value))
break;
const ON__UINT32 locked_bit = 0x01;
const ON__UINT32 hidden_bit = 0x02;
// Additional states can be saved if that is reasonable.
const ON_ComponentStatus component_status0 = ModelComponentStatus();
ON_ComponentStatus component_status = component_status0;
if (0 != (mask & locked_bit))
{
const bool bIsLocked = (0 != (value & locked_bit));
component_status.SetLockedState(bIsLocked);
}
if (0 != (mask & hidden_bit))
{
const bool bIsHidden = (0 != (value & hidden_bit));
component_status.SetHiddenState(bIsHidden);
}
if ( component_status != component_status0 )
SetModelComponentStatus(component_status);
}
rc = true;
break;
}
if (!archive.EndRead3dmChunk())
rc = false;
return rc;
}
unsigned int ON_ModelComponent::CopyFrom(
const ON_ModelComponent& src,
unsigned int attributes_filter
)
{
unsigned int rc = 0;
unsigned int bit;
bool b;
// Erase unused bits.
attributes_filter &= ON_ModelComponent::Attributes::AllAttributes;
// Cannot set locked attributes.
bit = m_locked_status;
attributes_filter &= ~bit;
if ( 0 == attributes_filter )
return rc; // nothing to change
bit = ON_ModelComponent::Attributes::ModelSerialNumberAttribute & attributes_filter;
if (0 != bit)
{
b = (src.ModelSerialNumberIsSet())
? SetModelSerialNumber(src.ModelSerialNumber(),src.ReferenceModelSerialNumber(),src.InstanceDefinitionModelSerialNumber())
: ClearModelSerialNumber();
if (b)
rc |= bit;
}
// component type must be set before parent id
bit = ON_ModelComponent::Attributes::TypeAttribute & attributes_filter;
if (0 != bit)
{
b = (src.ComponentTypeIsSet())
? SetComponentType(src.ComponentType())
: ClearComponentType();
if (b)
rc |= bit;
}
bit = ON_ModelComponent::Attributes::IdAttribute & attributes_filter;
if (0 != bit)
{
b = (src.IdIsSet())
? SetId(src.Id())
: ClearId();
if (b)
rc |= bit;
}
bit = ON_ModelComponent::Attributes::ParentIdAttribute & attributes_filter;
if (0 != bit)
{
b = (src.ParentIdIsSet())
? SetParentId(src.ParentId())
: ClearParentId();
if (b)
rc |= bit;
}
bit = ON_ModelComponent::Attributes::IndexAttribute & attributes_filter;
if (0 != bit)
{
b = (src.IndexIsSet())
? SetIndex(src.Index())
: ClearIndex();
if (b)
rc |= bit;
}
bit = ON_ModelComponent::Attributes::NameAttribute & attributes_filter;
if (0 != bit)
{
b = (src.NameIsSet())
? SetName(src.Name())
: ClearName();
if (b)
rc |= bit;
}
bit = ON_ModelComponent::Attributes::ComponentStatusAttribute & attributes_filter;
if (0 != bit)
{
b = (src.ModelComponentStatusIsSet())
? SetModelComponentStatus(src.ModelComponentStatus())
: ClearModelComponentStatus();
if (b)
rc |= bit;
}
return rc;
}
ON_ModelComponent::ON_ModelComponent(const ON_ModelComponent& src)
: ON_Object(src)
, m_runtime_serial_number(++ON_ModelComponent::Internal_RuntimeSerialNumberGenerator)
, m_content_version_number(ON_ModelComponentContentVersionNumberOne(m_runtime_serial_number))
{
CopyFrom(src,ON_ModelComponent::Attributes::AllAttributes);
// The Type attribute is a special case. Locking it in the copy
// constructor allows the model components that are derived from
// ON_ModelComponent to use the default copy constructor.
const unsigned int bit = ON_ModelComponent::Attributes::TypeAttribute;
if (0 != (bit & m_set_status)
&& ON_ModelComponent::ComponentTypeIsValid(m_component_type)
&& src.ComponentTypeIsLocked()
)
m_locked_status |= bit;
}
ON_ModelComponent& ON_ModelComponent::operator=(const ON_ModelComponent& src)
{
if (this != &src)
{
// copy user data
ON_Object::operator=(src);
// copy ON_ModelComponent fields
CopyFrom(src,ON_ModelComponent::Attributes::AllAttributes);
}
return *this;
}
ON_ModelComponent::ON_ModelComponent(
ON_ModelComponent::Type component_type,
const ON_ModelComponent& src
) ON_NOEXCEPT
: ON_Object(src)
, m_runtime_serial_number(++ON_ModelComponent::Internal_RuntimeSerialNumberGenerator)
, m_content_version_number(ON_ModelComponentContentVersionNumberOne(m_runtime_serial_number))
, m_component_type(component_type)
{
if (ON_ModelComponent::Type::Unset != m_component_type)
{
// set and lock m_component_type
m_set_status = ON_ModelComponent::Attributes::TypeAttribute;
m_locked_status = ON_ModelComponent::Attributes::TypeAttribute;
}
CopyFrom(src,ON_ModelComponent::Attributes::AllAttributes);
}
ON_ModelComponent::ON_ModelComponent(
ON_ModelComponent::Type component_type
) ON_NOEXCEPT
: m_runtime_serial_number(++ON_ModelComponent::Internal_RuntimeSerialNumberGenerator)
, m_content_version_number(ON_ModelComponentContentVersionNumberOne(m_runtime_serial_number))
, m_component_type(component_type)
{
if (ON_ModelComponent::Type::Unset != m_component_type)
{
m_locked_status = ON_ModelComponent::Attributes::TypeAttribute;
m_set_status = ON_ModelComponent::Attributes::TypeAttribute;
}
}
ON__UINT64 ON_ModelComponent::NextRuntimeSerialNumber()
{
const ON__UINT64 last_runtime_serial_number(ON_ModelComponent::Internal_RuntimeSerialNumberGenerator);
return (last_runtime_serial_number + 1);
}
ON__UINT64 ON_ModelComponent::RuntimeSerialNumber() const
{
return m_runtime_serial_number;
}
ON__UINT64 ON_ModelComponent::ContentVersionNumber() const
{
return m_content_version_number;
}
void ON_ModelComponent::IncrementContentVersionNumber() const
{
m_content_version_number++;
}
bool ON_ModelComponent::EraseIdentification(
bool bIgnoreLocks
)
{
if (false == bIgnoreLocks)
{
if (IdIsLocked() && !(ON_ModelComponent::Unset.Id() == m_component_id))
{
ON_ERROR("Cannot erase id.");
return false;
}
if (ParentIdIsLocked() && !(ON_ModelComponent::Unset.Id() == m_component_parent_id))
{
ON_ERROR("Cannot erase parent id.");
return false;
}
if (NameIsLocked() && ON_ModelComponent::Unset.Name() != m_component_name)
{
ON_ERROR("Cannot erase name.");
return false;
}
if (IndexIsLocked() && ON_ModelComponent::Unset.Index() != m_component_index)
{
ON_ERROR("Cannot erase index.");
return false;
}
}
m_component_id = ON_ModelComponent::Unset.Id();
m_component_parent_id = ON_ModelComponent::Unset.Id();
m_component_index = ON_ModelComponent::Unset.Index();
m_component_name = ON_ModelComponent::Unset.Name();
m_component_name_hash = ON_ModelComponent::Unset.NameHash();
return true;
}
bool ON_ModelComponent::IsSystemComponent() const
{
return (
0 == m_content_version_number
&& 0 != (ON_ModelComponent::Attributes::SystemComponentAttribute & m_locked_status)
);
}
bool ON_ModelComponent::SetAsSystemComponent()
{
return Internal_SetAsSystemComponent(false);
}
bool ON_ModelComponent::SetAsUnsetSystemComponent()
{
return Internal_SetAsSystemComponent(true);
}
bool ON_ModelComponent::Internal_SetAsSystemComponent(
bool bUnsetSystemComponent
)
{
if (m_locked_status == 0xFFFFU)
{
ON_ERROR("component is already a system component.");
return true;
}
const bool bIndexRequired = ON_ModelComponent::IndexRequired(m_component_type);
const bool bUniqueNameRequired = ON_ModelComponent::UniqueNameRequired(m_component_type);
const bool bUniqueNameIncludesParent = ON_ModelComponent::UniqueNameIncludesParent(m_component_type);
for (;;)
{
if (ParentIdIsNotNil())
break;
if (bUniqueNameIncludesParent != ParentIdIsSet())
break;
if (IdIsNil())
{
if (!bUnsetSystemComponent)
break;
}
else
{
if (bUnsetSystemComponent)
break;
}
if ( bIndexRequired && false == bUnsetSystemComponent )
{
if (false == IndexIsSet())
break;
if (Index() >= 0)
break;
if (Index() <= ON_UNSET_INT_INDEX)
break;
}
else
{
if (IndexIsSet())
break;
}
if ( ON_ModelComponent::m_component_status != m_component_status )
break;
if (bUniqueNameRequired && false == bUnsetSystemComponent)
{
if (false == NameIsNotEmpty())
break;
if (false == NameHash().IsValidAndNotEmpty())
break;
}
else
{
if (NameIsSet())
return false;
if (false == NameHash().IsEmptyNameHash())
break;
}
m_locked_status = 0xFFFFU;
m_content_version_number = 0;
return true;
}
ON_ERROR("Invalid settings for a system component.");
return false;
}
///////////////////////////////////////////////////////////////////////////////
//
// Model Serial Number interface
//
unsigned int ON_ModelComponent::ModelSerialNumber() const
{
return m_model_serial_number;
}
unsigned int ON_ModelComponent::ReferenceModelSerialNumber() const
{
return m_reference_model_serial_number;
}
unsigned int ON_ModelComponent::InstanceDefinitionModelSerialNumber() const
{
return m_linked_idef_serial_number;
}
bool ON_ModelComponent::SetModelSerialNumber(
unsigned int model_serial_number
)
{
return SetModelSerialNumber(
model_serial_number,
ON_ModelComponent::Unset.ReferenceModelSerialNumber(),
ON_ModelComponent::Unset.InstanceDefinitionModelSerialNumber()
);
}
bool ON_ModelComponent::SetModelSerialNumber(
unsigned int model_serial_number,
unsigned int reference_model_serial_number,
unsigned int instance_definition_model_serial_number
)
{
const unsigned int bit = ON_ModelComponent::Attributes::ModelSerialNumberAttribute;
if (0 != (bit & m_locked_status))
return false;
m_model_serial_number = model_serial_number;
m_reference_model_serial_number = reference_model_serial_number;
m_linked_idef_serial_number = instance_definition_model_serial_number;
m_set_status |= bit;
return true;
}
bool ON_ModelComponent::ClearModelSerialNumber()
{
const unsigned int bit = ON_ModelComponent::Attributes::ModelSerialNumberAttribute;
return (bit == ClearModelComponentAttributes(bit));
}
void ON_ModelComponent::LockModelSerialNumber()
{
m_locked_status |= ON_ModelComponent::Attributes::ModelSerialNumberAttribute;
}
bool ON_ModelComponent::ModelSerialNumberIsLocked() const
{
const unsigned int bit = ON_ModelComponent::Attributes::ModelSerialNumberAttribute;
return (0 != (bit & m_locked_status));
}
bool ON_ModelComponent::ModelSerialNumberIsSet() const
{
const unsigned int bit = ON_ModelComponent::Attributes::ModelSerialNumberAttribute;
return (0 != (bit & m_set_status));
}
bool ON_ModelComponent::IsReferenceComponent() const
{
return (0 != m_reference_model_serial_number || 0 != m_linked_idef_serial_number);
}
///////////////////////////////////////////////////////////////////////////////
//
// Name interface
//
//
const wchar_t* ON_ModelComponent::GetName(
ON_wString& component_name
) const
{
component_name = static_cast<const wchar_t*>(m_component_name);
return static_cast<const wchar_t*>(component_name);
}
const ON_wString ON_ModelComponent::Name() const
{
return NameIsSet() ? m_component_name : ON_wString::EmptyString;
}
const ON_wString ON_ModelComponent::DeletedName() const
{
return DeletedNameIsSet() ? m_component_name : ON_wString::EmptyString;
}
const wchar_t* ON_ModelComponent::NameAsPointer() const
{
return NameIsSet() ? m_component_name : ON_wString::EmptyString;
}
const ON_wString ON_ModelComponent::RemoveAllReferencePrefixDelimiters(
const wchar_t* name
)
{
if ( nullptr == name || 0 == name[0] )
return ON_wString::EmptyString;
ON_wString local(name);
local.Replace(ON_ModelComponent::ReferencePrefixDelimiter, nullptr);
return local.IsNotEmpty() ? local : ON_wString::EmptyString;
}
static const ON_wString Internal_RemoveTrailingNameToken(
const wchar_t* name,
const ON_wString& token
)
{
if ( nullptr == name || 0 == name[0] || token.IsEmpty() )
return ON_wString::EmptyString;
ON_wString local(name);
wchar_t* s0 = local.Array();
if (nullptr == s0)
return ON_wString::EmptyString;
// remove any reference name delimiters
const unsigned int d_length = token.Length();
const unsigned int local_length = (unsigned int)local.Length();
if (local_length < d_length )
return local;
if (ON_wString::EqualOrdinal(s0 + (local_length - d_length), token, false))
{
local.SetLength((local_length - d_length));
}
return local;
}
const ON_wString ON_ModelComponent::RemoveTrailingReferencePrefixDelimiter(
const wchar_t* name
)
{
return Internal_RemoveTrailingNameToken(name, ON_ModelComponent::ReferencePrefixDelimiter);
}
const ON_wString ON_ModelComponent::RemoveTrailingReferencePrefixSeparator(
const wchar_t* name
)
{
return Internal_RemoveTrailingNameToken(name, ON_ModelComponent::ReferencePrefixSeparator);
}
const ON_wString ON_ModelComponent::RemoveTrailingNamePathSeparator(
const wchar_t* name
)
{
return Internal_RemoveTrailingNameToken(name, ON_ModelComponent::NamePathSeparator);
}
//const ON_wString ON_ModelComponent::WorksessionReferenceNamePrefix(
// const wchar_t* reference_prefix,
// bool bAppendReferenceNamePrefixDelimiter
//)
//{
// ON_wString s(reference_prefix);
//
// for (;;)
// {
// const int length0 = s.Length();
// s.TrimLeftAndRight();
// s.TrimLeftAndRight(L"[]");
// const int length1 = s.Length();
// if (length1 <= 0 || length1 >= length0)
// break;
// }
//
// if (s.IsEmpty())
// return ON_wString::EmptyString;
//
// ON_wString worksession_prefix = L"[ ";
// worksession_prefix += s;
// worksession_prefix += L" ]";
// return worksession_prefix;
//}
static const wchar_t* InternalStringBeginsWithToken(
const wchar_t* str,
const wchar_t* token
)
{
if (nullptr == str || nullptr == token || 0 == token[0])
return nullptr;
while (*str == *token && 0 != *token)
{
str++;
token++;
}
return (0 == *token) ? str : nullptr;
}
const wchar_t* ON_ModelComponent::IsReferencePrefixDelimiter(
const wchar_t* s
)
{
return InternalStringBeginsWithToken(s, ON_ModelComponent::ReferencePrefixDelimiter);
}
const wchar_t* ON_ModelComponent::IsReferencePrefixSeparator(
const wchar_t* s
)
{
return InternalStringBeginsWithToken(s, ON_ModelComponent::ReferencePrefixSeparator);
}
const wchar_t* ON_ModelComponent::IsNamePathSeparator(
const wchar_t* s
)
{
return InternalStringBeginsWithToken(s, ON_ModelComponent::NamePathSeparator);
}
void ON_ModelComponent::SplitName(
const wchar_t* name,
ON_wString& reference_prefix,
ON_wString& name_parent,
ON_wString& name_leaf
)
{
ON_wString local(name);
wchar_t* str = local.Array();
wchar_t* tail = str + local.Length();
reference_prefix = ON_wString::EmptyString;
name_parent = ON_wString::EmptyString;
name_leaf = ON_wString::EmptyString;
if (nullptr == str || 0 == str[0])
return;
bool bHaveReference = false;
bool bHaveLeaf = false;
while (tail > str)
{
tail--;
if (false == bHaveLeaf)
{
const wchar_t* s = ON_ModelComponent::IsNamePathSeparator(tail);
if (nullptr != s)
{
bHaveLeaf = true;
name_leaf = s;
*tail = 0;
continue;
}
}
if (false == bHaveReference)
{
const wchar_t* s = ON_ModelComponent::IsReferencePrefixDelimiter(tail);
if (nullptr != s)
{
bHaveReference = true;
if (false == bHaveLeaf)
{
bHaveLeaf = true;
name_leaf = s;
}
else
{
name_parent = s;
}
*tail = 0;
reference_prefix = ON_ModelComponent::RemoveAllReferencePrefixDelimiters(str);
break;
}
}
}
if (false == bHaveReference)
{
if (false == bHaveLeaf)
name_leaf = name;
else
name_parent = str;
}
reference_prefix.TrimLeftAndRight();
name_parent.TrimLeftAndRight();
name_leaf.TrimLeftAndRight();
}
const ON_wString ON_ModelComponent::NameReferencePrefix(const wchar_t * name)
{
if (nullptr == name || 0 == name[0])
return ON_wString::EmptyString;
const wchar_t* tail = name;
while (0 != *tail)
tail++;
while (tail > name)
{
tail--;
const wchar_t* s = ON_ModelComponent::IsReferencePrefixDelimiter(tail);
if (nullptr != s)
{
ON_wString name_reference = name;
name_reference.SetLength(tail - name);
name_reference = ON_ModelComponent::RemoveAllReferencePrefixDelimiters(name_reference);
name_reference.TrimLeftAndRight();
return name_reference;
}
}
return ON_wString::EmptyString;
}
const ON_wString ON_ModelComponent::NameParent(
const wchar_t * name,
bool bIncludeReference
)
{
if (nullptr == name || 0 == name[0])
return ON_wString::EmptyString;
if (false == bIncludeReference)
{
ON_wString name_reference;
ON_wString name_parent;
ON_wString name_leaf;
SplitName(name, name_reference, name_parent, name_leaf);
return name_parent;
}
const wchar_t* tail = name;
while (0 != *tail)
tail++;
while (tail > name)
{
tail--;
const wchar_t* s = ON_ModelComponent::IsNamePathSeparator(tail);
if (nullptr != s)
{
ON_wString name_parent = name;
name_parent.SetLength(tail - name);
name_parent.TrimLeftAndRight();
if (bIncludeReference)
return name_parent;
}
}
return ON_wString::EmptyString;
}
const ON_wString ON_ModelComponent::NameLeaf(
const wchar_t* name
)
{
if (nullptr == name || 0 == name[0])
return ON_wString::EmptyString;
const wchar_t* tail = name;
while (0 != *tail)
tail++;
while( tail > name )
{
tail--;
const wchar_t* s = ON_ModelComponent::IsNamePathSeparator(tail);
if ( nullptr == s )
s = ON_ModelComponent::IsReferencePrefixDelimiter(tail);
if (nullptr != s)
{
ON_wString name_leaf = s;
name_leaf.TrimLeftAndRight();
return name_leaf; // can be empty when name ends in a delimiter or separator or spaces
}
}
ON_wString name_leaf = name;
name_leaf.TrimLeftAndRight();
return name_leaf;
}
const ON_wString ON_ModelComponent::RemoveReferencePrefix(const wchar_t * name)
{
if (nullptr == name || 0 == name[0])
return ON_wString::EmptyString;
const wchar_t* tail = name;
while (0 != *tail)
tail++;
while (tail > name)
{
tail--;
const wchar_t* s = ON_ModelComponent::IsReferencePrefixDelimiter(tail);
if (nullptr != s)
{
ON_wString name_no_reference = s;
name_no_reference.TrimLeftAndRight();
return name_no_reference;
}
}
ON_wString name_no_reference(name);
name_no_reference.TrimLeftAndRight();
return name_no_reference;
}
const ON_NameHash& ON_ModelComponent::Internal_NameHash() const
{
if (m_component_name_hash.IsEmptyNameHash() && m_component_name.IsNotEmpty())
{
// lazy evaulation because SHA-1 calculation takes appreciable time
// For components whose names are in a tree structure, like layers,
// the parent id must be included.
// For all other components, the parent id must be ignored.
const ON_UUID name_parent_id
= ON_ModelComponent::UniqueNameIncludesParent(m_component_type)
? m_component_parent_id
: ON_nil_uuid;
const bool bIgnoreCase = ON_ModelComponent::UniqueNameIgnoresCase(m_component_type);
m_component_name_hash = ON_NameHash::Create(name_parent_id,m_component_name,bIgnoreCase);
}
return m_component_name_hash;
}
const ON_NameHash& ON_ModelComponent::NameHash() const
{
return NameIsSet() ? Internal_NameHash() : ON_NameHash::EmptyNameHash;
}
const ON_NameHash ON_ModelComponent::NewNameHash(
const wchar_t* new_name
) const
{
ON_wString local_buffer(new_name);
local_buffer.TrimLeftAndRight();
if (local_buffer.IsNotEmpty() && false == ON_ModelComponent::IsValidComponentName(local_buffer))
{
return ON_NameHash::UnsetNameHash;
}
const ON_UUID name_parent_id
= ON_ModelComponent::UniqueNameIncludesParent(ComponentType())
? Id()
: ON_nil_uuid;
return ON_NameHash::Create(name_parent_id, local_buffer);
}
const ON_NameHash& ON_ModelComponent::DeletedNameHash() const
{
return DeletedNameIsSet() ? Internal_NameHash() : ON_NameHash::EmptyNameHash;
}
bool ON_ModelComponent::NameIsEmpty() const
{
// should return true when the name is not set.
return NameIsSet() ? m_component_name.IsEmpty() : true;
}
bool ON_ModelComponent::NameIsNotEmpty() const
{
return NameIsSet() ? m_component_name.IsNotEmpty() : false;
}
bool ON_ModelComponent::ChangeName(
const wchar_t* new_name,
class ON_ComponentManifest* manifest
)
{
const ON_ModelComponent::Type component_type = ComponentType();
if (nullptr != manifest)
{
if (manifest->ItemFromId(component_type, Id()).IsUnset())
{
ON_ERROR("component is not in the manifest.");
return false;
}
}
const bool bUniqueNameRequired = ON_ModelComponent::UniqueNameRequired(component_type);
ON_wString local_name(new_name);
local_name.TrimLeftAndRight();
new_name = local_name;
const ON_UUID name_parent_id
= ON_ModelComponent::UniqueNameIncludesParent(component_type)
? ParentId()
: ON_nil_uuid;
const ON_NameHash new_name_hash = ON_NameHash::Create(name_parent_id,new_name);
if (local_name.IsEmpty() )
{
if (bUniqueNameRequired)
{
ON_ERROR("This component cannot have an empty name.");
return false;
}
}
else if (ON_ModelComponent::IsValidComponentName(new_name))
{
ON_ERROR("Invalid component name.");
return false;
}
else if (bUniqueNameRequired && nullptr != manifest )
{
if (manifest->ItemFromNameHash(component_type, new_name_hash).IsValid())
{
// name is already being used.
return false;
}
}
if (
nullptr != manifest
&& manifest->ChangeComponentName(Id(), component_type, ParentId(), new_name).IsUnset()
)
{
ON_ERROR("Unable to update manifest.");
return false;
}
const bool rc
= (local_name.IsEmpty())
? ClearName()
: SetName(new_name);
if (false == rc)
{
ON_ERROR("Unable to change component name.");
return false;
}
return true;
}
bool ON_ModelComponent::SetName(
const wchar_t* component_name
)
{
ON_wString local_buffer(component_name);
local_buffer.TrimLeftAndRight();
const unsigned int bit = ON_ModelComponent::Attributes::NameAttribute;
if (0 != (bit & m_locked_status))
return false;
if (local_buffer.IsNotEmpty() && false == ON_ModelComponent::IsValidComponentName(local_buffer))
{
ON_ERROR("Invalid component_name parameter.");
return false;
}
const bool bContentChange = (false == NameIsSet() || false == m_component_name.EqualOrdinal(local_buffer,false));
m_component_name = local_buffer;
// lazy evaluation is used to set m_component_name_hash
m_component_name_hash = ON_NameHash::EmptyNameHash;
m_set_status |= bit;
m_set_status &= ~(ON_ModelComponent::Attributes::DeletedNameAttribute);
if ( bContentChange )
IncrementContentVersionNumber();
return true;
}
bool ON_ModelComponent::SetLocalizedSystemComponentName(
const wchar_t* system_component_localized_name
)
{
if (false == IsSystemComponent())
{
ON_ERROR("not a system component.");
return false;
}
if (NameIsLocked())
{
ON_ERROR("name cannot be changed.");
return false;
}
ON_wString local_buffer(system_component_localized_name);
local_buffer.TrimLeftAndRight();
system_component_localized_name = local_buffer;
if (nullptr == system_component_localized_name || 0 == system_component_localized_name[0])
{
ON_ERROR("system_component_localized_name cannot be empty.");
return false;
}
const ON_NameHash name_hash = ON_NameHash::Create(ParentId(),system_component_localized_name);
if (false == name_hash.IsValidAndNotEmpty())
{
ON_ERROR("system_component_localized_name is not valid.");
return false;
}
m_component_name = local_buffer;
m_component_name_hash = name_hash;
return SetAsSystemComponent();
}
bool ON_ModelComponent::ClearName()
{
const unsigned int bit = (ON_ModelComponent::Attributes::NameAttribute | ON_ModelComponent::Attributes::DeletedNameAttribute);
return (bit == ClearModelComponentAttributes(bit));
}
void ON_ModelComponent::LockName()
{
m_locked_status |= ON_ModelComponent::Attributes::NameAttribute;
// If name is deleted, erase it.
m_set_status &= ~(ON_ModelComponent::Attributes::DeletedNameAttribute);
if (0 == (ON_ModelComponent::Attributes::NameAttribute & m_set_status))
{
m_component_name_hash = ON_NameHash::EmptyNameHash;
m_component_name = ON_wString::EmptyString;
}
}
void ON_ModelComponent::LockAllSettingsExceptName()
{
const unsigned int name_bit = ON_ModelComponent::Attributes::NameAttribute;
unsigned int mask = ~name_bit;
mask &= ON_ModelComponent::Attributes::AllAttributes;
m_locked_status |= mask;
}
bool ON_ModelComponent::NameIsLocked() const
{
const unsigned int bit = ON_ModelComponent::Attributes::NameAttribute;
return (0 != (bit & m_locked_status));
}
bool ON_ModelComponent::NameIsSet() const
{
const unsigned int bit = ON_ModelComponent::Attributes::NameAttribute;
return (0 != (bit & m_set_status));
}
bool ON_ModelComponent::DeletedNameIsSet() const
{
const unsigned int bit = ON_ModelComponent::Attributes::DeletedNameAttribute;
return (0 != (bit & m_set_status));
}
bool ON_ModelComponent::DeleteName()
{
if ( NameIsLocked() )
return false; // cannot modify a locked name.
if ( false == NameIsSet() )
return false; // nothing to delete.
const ON__UINT16 name_bit = (ON__UINT16)ON_ModelComponent::Attributes::NameAttribute;
const ON__UINT16 deleted_name_bit = (ON__UINT16)ON_ModelComponent::Attributes::DeletedNameAttribute;
m_set_status &= ~(name_bit | deleted_name_bit);
// do this for all m_component_name contents including empty names.
// There is a difference between name being "unset" and name being "set to empty".
//
// name is now "deleted"
m_set_status |= deleted_name_bit;
IncrementContentVersionNumber();
return DeletedNameIsSet();
}
bool ON_ModelComponent::UndeleteName()
{
if ( NameIsLocked() )
return false; // cannot modify a locked name.
if ( false == DeletedNameIsSet() )
return false; // nothing to delete.
const ON__UINT16 name_bit = (ON__UINT16)ON_ModelComponent::Attributes::NameAttribute;
const ON__UINT16 deleted_name_bit = (ON__UINT16)ON_ModelComponent::Attributes::DeletedNameAttribute;
m_set_status &= ~(name_bit | deleted_name_bit);
// do this for all m_component_name contents including empty names.
// There is a difference between name being "unset" and name being "set to empty".
//
// name is now "undeleted"
m_set_status |= name_bit;
IncrementContentVersionNumber();
return NameIsSet();
}
int ON_ModelComponent::CompareName(
const wchar_t* other_name
) const
{
return CompareName(ParentId(), other_name );
}
int ON_ModelComponent::CompareName(
const ON_UUID& other_parent_id,
const wchar_t* other_name
) const
{
int rc
= (ON_ModelComponent::UniqueNameIncludesParent(m_component_type) && NameIsSet())
? ON_UuidCompare(m_component_parent_id, other_parent_id)
: 0;
return
(0 != rc)
? rc
: ON_wString::CompareAttributeName(Name(), other_name);
}
int ON_ModelComponent::CompareId(
const ON_ModelComponent& a,
const ON_ModelComponent& b
)
{
return ON_UuidCompare(a.m_component_id, b.m_component_id);
}
int ON_ModelComponent::CompareNameAndId(
const ON_ModelComponent& a,
const ON_ModelComponent& b
)
{
int rc = ON_ModelComponent::CompareName(a, b);
if (0 == rc)
rc = ON_ModelComponent::CompareId(a, b);
return rc;
}
int ON_ModelComponent::CompareIdAndName(
const ON_ModelComponent& a,
const ON_ModelComponent& b
)
{
int rc = ON_ModelComponent::CompareId(a, b);
if (0 == rc)
rc = ON_ModelComponent::CompareName(a, b);
return rc;
}
int ON_ModelComponent::CompareName(
const ON_ModelComponent& a,
const ON_ModelComponent& b
)
{
const ON_UUID a_parent_id
= ON_ModelComponent::UniqueNameIncludesParent(a.m_component_type) && a.NameIsSet()
? a.ParentId()
: ON_nil_uuid;
const ON_UUID b_parent_id
= ON_ModelComponent::UniqueNameIncludesParent(b.m_component_type) && b.NameIsSet()
? b.ParentId()
: ON_nil_uuid;
int rc = ON_UuidCompare(a_parent_id,b_parent_id);
return
(0 != rc)
? rc
: ON_wString::CompareAttributeName(a.m_component_name,b.m_component_name);
}
int ON_ModelComponent::CompareNameExact(
const wchar_t* other_name
) const
{
return CompareNameExact(ParentId(),other_name);
}
int ON_ModelComponent::CompareNameExact(
const ON_UUID& other_parent_id,
const wchar_t* other_name
) const
{
int rc = ON_ModelComponent::CompareName(other_parent_id,other_name);
return
(0 != rc)
? rc
: ON_wString::CompareOrdinal(m_component_name,other_name,false);
}
int ON_ModelComponent::CompareNameExact(
const ON_ModelComponent& a,
const ON_ModelComponent& b
)
{
int rc = ON_ModelComponent::CompareName(a,b);
return
(0 != rc)
? rc
: ON_wString::CompareOrdinal(a.m_component_name,b.m_component_name,false);
}
///////////////////////////////////////////////////////////////////////////////
//
// Type interface
//
ON_ModelComponent::Type ON_ModelComponent::ComponentType() const
{
return m_component_type;
}
bool ON_ModelComponent::SetComponentType(
ON_ModelComponent::Type component_type
)
{
const unsigned int bit = ON_ModelComponent::Attributes::TypeAttribute;
if (0 != (bit & m_locked_status))
return false;
const bool bContentChange = (m_component_type != component_type);
m_component_type = component_type;
m_set_status |= bit;
if ( bContentChange )
IncrementContentVersionNumber();
return true;
}
bool ON_ModelComponent::ClearComponentType()
{
const unsigned int bit = ON_ModelComponent::Attributes::TypeAttribute;
return (bit == ClearModelComponentAttributes(bit));
}
void ON_ModelComponent::LockComponentType()
{
m_locked_status |= ON_ModelComponent::Attributes::TypeAttribute;
}
bool ON_ModelComponent::ComponentTypeIsLocked() const
{
const unsigned int bit = ON_ModelComponent::Attributes::TypeAttribute;
return (0 != (bit & m_locked_status));
}
bool ON_ModelComponent::ComponentTypeIsSet() const
{
const unsigned int bit = ON_ModelComponent::Attributes::TypeAttribute;
return (0 != (bit & m_set_status));
}
bool ON_ModelComponent::ComponentTypeIsValid(
ON_ModelComponent::Type component_type
)
{
return (
ON_ModelComponent::ComponentTypeFromUnsigned(static_cast<unsigned int>(component_type)) == component_type
&& ON_ModelComponent::Type::Unset != component_type
);
}
bool ON_ModelComponent::ComponentTypeIsValidAndNotMixed(
ON_ModelComponent::Type component_type
)
{
return
ON_ModelComponent::ComponentTypeIsValid(component_type)
&& ON_ModelComponent::Type::Mixed != component_type;
}
bool ON_ModelComponent::IsValidComponentName(
const ON_wString& candidate_component_name
)
{
return ON_ModelComponent::IsValidComponentName(
(size_t)candidate_component_name.Length(),
static_cast<const wchar_t*>(candidate_component_name)
);
}
bool ON_ModelComponent::IsValidComponentName(
size_t length,
const wchar_t* candidate_component_name
)
{
return
(length > 0
&& length <= 2147483645
&& length == (size_t)ON_wString::Length(candidate_component_name,length+1)
&& ON_ModelComponent::IsValidComponentName(candidate_component_name)
);
}
bool ON_ModelComponent::IsValidComponentName(
const class ON_ComponentManifest& model_manfest,
const ON_ModelComponent& model_component,
bool bPermitReferencePrefix,
ON_wString& valid_name
)
{
valid_name = ON_wString::EmptyString;
const ON_ModelComponent::Type model_component_type = model_component.ComponentType();
const ON_wString original_name = model_component.Name();
bool rc = false;
for (;;)
{
if (false == ON_ModelComponent::IsValidComponentName(original_name))
{
break;
}
const bool bUniqueNameRequired = ON_ModelComponent::UniqueNameRequired(model_component_type);
if (bPermitReferencePrefix && false == bUniqueNameRequired)
{
rc = true;
break;
}
const class ON_ComponentManifestItem& item
= (bUniqueNameRequired)
? model_manfest.ItemFromName(&model_component)
: ON_ComponentManifestItem::UnsetItem;
const bool bItemFromNameIsOK
= (item.ComponentRuntimeSerialNumber() == model_component.RuntimeSerialNumber())
|| item.IsUnset()
|| item.IsSystemComponent()
;
if ( bItemFromNameIsOK && bPermitReferencePrefix)
{
rc = true;
break;
}
ON_wString ref;
ON_wString parent;
ON_wString leaf;
ON_ModelComponent::SplitName(
original_name,
ref,
parent,
leaf
);
if (bItemFromNameIsOK && ref.IsEmpty())
{
rc = true;
break;
}
if (false == ON_ModelComponent::IsValidComponentName(leaf))
break;
const class ON_ComponentManifestItem& leaf_item
= (bUniqueNameRequired)
? model_manfest.ItemFromName(model_component_type,model_component.ParentId(),leaf)
: ON_ComponentManifestItem::UnsetItem;
if (leaf_item.IsUnset() || leaf_item.IsSystemComponent())
{
valid_name = leaf;
break;
}
valid_name = model_manfest.UnusedName(
model_component.ComponentType(),
model_component.ParentId(),
leaf,
nullptr,
nullptr,
0,
nullptr
);
break;
}
if (rc)
{
valid_name = original_name;
}
else if (valid_name.IsEmpty())
{
valid_name = model_manfest.UnusedName(
model_component_type,
model_component.ParentId(),
nullptr,
nullptr,
nullptr,
0,
nullptr
);
}
return rc;
}
static bool Internal_IsValidComponentNameCodePoint(ON__UINT32 unicode_code_point)
{
return
unicode_code_point >= ON_UnicodeCodePoint::ON_Space
&& 0 != ON_IsValidUnicodeCodePoint(unicode_code_point)
&& 0 == ON_IsUnicodeC1ControlCodePoint(unicode_code_point)
;
}
bool ON_ModelComponent::IsValidComponentNameFirstCodePoint(
ON__UINT32 unicode_code_point
)
{
return
Internal_IsValidComponentNameCodePoint(unicode_code_point)
&& 0 == ON_IsUnicodeSpaceCodePoint(unicode_code_point)
&& unicode_code_point != '('
&& unicode_code_point != ')'
&& unicode_code_point != '['
&& unicode_code_point != ']'
&& unicode_code_point != '{'
&& unicode_code_point != '}';
}
bool ON_ModelComponent::IsValidComponentNameFirstCodePoint(
int length,
const wchar_t* candidate_component_name
)
{
if (nullptr == candidate_component_name || 0 == candidate_component_name[0])
return false;
if (length < 0)
{
for (length = 0; 0 != candidate_component_name[length]; length++)
{
if (length > 8)
break; // 8 elements is plenty for all possible wchar_t encodings.
}
}
ON_UnicodeErrorParameters e = ON_UnicodeErrorParameters::FailOnErrors;
e.m_error_code_point = 0;
ON__UINT32 unicode_code_point = 0;
ON_DecodeWideChar(candidate_component_name, length, &e, &unicode_code_point);
return ON_ModelComponent::IsValidComponentNameFirstCodePoint(unicode_code_point);
}
bool ON_ModelComponent::IsValidComponentName(
const wchar_t* candidate_component_name
)
{
const bool bPermitInternalSpaces = true;
if (nullptr == candidate_component_name || 0 == candidate_component_name[0])
return false;
// the first character in a component name cannot be a bracket, space or below
const ON__UINT32 c2[2] = { (ON__UINT32)(candidate_component_name[0]), (ON__UINT32)(candidate_component_name[1]) };
const ON__UINT32 first_code_point
= ON_IsValidUTF32Value(c2[0])
? c2[0]
: (ON_IsValidUTF16SurrogatePair(c2[0], c2[1]) ? ON_DecodeUTF16SurrogatePair(c2[0], c2[1],0): 0)
;
bool rc = IsValidComponentNameFirstCodePoint(first_code_point);
bool bLastCharWasSpace = false;
for ( const wchar_t* name = candidate_component_name; 0 != *name && rc; name++ )
{
const ON__UINT32 c = (ON__UINT32)(name[0]);
if (0 == Internal_IsValidComponentNameCodePoint(c))
{
if (ON_IsValidUTF16SurrogatePair(c, (ON__UINT32)(name[1])))
{
// all code points that come from surrogate pairs are permitted
bLastCharWasSpace = false;
name++;
continue;
}
return false;
}
if (ON_IsUnicodeSpaceCodePoint(c))
{
rc = bPermitInternalSpaces;
bLastCharWasSpace = true;
}
else
bLastCharWasSpace = false;
}
return (rc && !bLastCharWasSpace) ? true : false;
}
bool ON_ModelComponent::IndexRequired(ON_ModelComponent::Type component_type)
{
switch (component_type)
{
case ON_ModelComponent::Type::Image:
case ON_ModelComponent::Type::TextureMapping:
case ON_ModelComponent::Type::RenderContent: // }
case ON_ModelComponent::Type::EmbeddedFile: // } JohnC: I have no idea how to decide what to return.
case ON_ModelComponent::Type::ObsoleteValue: // }
case ON_ModelComponent::Type::Material: // ON_Layer references render material by index
case ON_ModelComponent::Type::LinePattern: // ON_Layer references line pattern by index
case ON_ModelComponent::Type::Layer:
case ON_ModelComponent::Type::Group:
case ON_ModelComponent::Type::TextStyle:
case ON_ModelComponent::Type::DimStyle:
case ON_ModelComponent::Type::RenderLight:
case ON_ModelComponent::Type::HatchPattern:
case ON_ModelComponent::Type::InstanceDefinition:
case ON_ModelComponent::Type::SectionStyle:
return true;
case ON_ModelComponent::Type::ModelGeometry:
case ON_ModelComponent::Type::HistoryRecord:
return false;
default:
ON_ERROR("Invalid component_type parameter.");
return false;
}
}
bool ON_ModelComponent::UniqueNameIncludesParent(ON_ModelComponent::Type component_type)
{
// [Giulio] If this table is changed, then also RhinoCommon documentation in
// Rhino.DocObjects.ModelComponent.FindName() / FindNameHash() will require appropriate tweaks.
switch (component_type)
{
case ON_ModelComponent::Type::Layer:
return true;
case ON_ModelComponent::Type::Image:
case ON_ModelComponent::Type::TextureMapping:
case ON_ModelComponent::Type::Material:
case ON_ModelComponent::Type::RenderContent: // JohnC: TODO: Giulio's tweak above. Left for the wrapping phase.
case ON_ModelComponent::Type::EmbeddedFile: // JohnC: TODO: Giulio's tweak above. Left for the wrapping phase.
case ON_ModelComponent::Type::LinePattern:
case ON_ModelComponent::Type::Group:
case ON_ModelComponent::Type::TextStyle:
case ON_ModelComponent::Type::DimStyle:
case ON_ModelComponent::Type::RenderLight:
case ON_ModelComponent::Type::HatchPattern:
case ON_ModelComponent::Type::InstanceDefinition:
case ON_ModelComponent::Type::ModelGeometry:
case ON_ModelComponent::Type::HistoryRecord:
case ON_ModelComponent::Type::SectionStyle:
return false;
default:
ON_ERROR("Invalid component_type parameter.");
return false;
}
}
bool ON_ModelComponent::UniqueNameRequired(ON_ModelComponent::Type component_type)
{
// [Giulio] If this table is changed, then also
// Rhino.DocObjects.ModelComponent.ModelComponentTypeRequiresUniqueName()
// will need the same tweak.
switch (component_type)
{
case ON_ModelComponent::Type::LinePattern:
case ON_ModelComponent::Type::Layer:
case ON_ModelComponent::Type::Group:
case ON_ModelComponent::Type::TextStyle:
case ON_ModelComponent::Type::DimStyle:
case ON_ModelComponent::Type::HatchPattern:
case ON_ModelComponent::Type::InstanceDefinition:
case ON_ModelComponent::Type::EmbeddedFile:
case ON_ModelComponent::Type::SectionStyle:
return true;
case ON_ModelComponent::Type::Image:
case ON_ModelComponent::Type::TextureMapping:
case ON_ModelComponent::Type::Material:
case ON_ModelComponent::Type::RenderContent: // JohnC: TODO: Giulio's tweak above. Left for the wrapping phase.
case ON_ModelComponent::Type::RenderLight:
case ON_ModelComponent::Type::ModelGeometry:
case ON_ModelComponent::Type::HistoryRecord:
return false;
default:
ON_ERROR("Invalid component_type parameter.");
return false;
}
}
bool ON_ModelComponent::UniqueNameIgnoresCase(ON_ModelComponent::Type component_type)
{
// This function must return true for components like ON_Material that do not require a unique name.
return (
// NO // ON_ModelComponent::UniqueNameRequired(component_type) &&
ON_ModelComponent::Type::Group != component_type
);
}
///////////////////////////////////////////////////////////////////////////////
//
// Id interface
//
bool ON_ModelComponent::SetIdentification(
const class ON_ComponentManifestItem& manifest_item,
const wchar_t* manifest_name,
bool bSetId,
bool bSetParentId,
bool bSetName,
bool bSetIndex
)
{
bool rc = true;
if (bSetId && false == (manifest_item.Id() == Id()))
{
if (false == SetId(manifest_item.Id()))
{
ON_ERROR("id cannot be set");
rc = false;
}
}
const ON_UUID parent_id
= bSetParentId
? manifest_item.NameHash().ParentId()
: ON_nil_uuid;
if (bSetParentId && false == (parent_id == ParentId()))
{
if (false == SetParentId(parent_id))
{
ON_ERROR("parent id cannot be set");
rc = false;
}
}
if (bSetName && NameHash() != manifest_item.NameHash())
{
if ( manifest_item.NameHash() != ON_NameHash::Create(manifest_item.NameHash().ParentId(),manifest_name) )
{
ON_ERROR("manifest_name parameter is not valid.");
rc = false;
}
else if (false == SetName(manifest_name) )
{
ON_ERROR("name cannot be set");
rc = false;
}
}
if (bSetIndex && Index() != manifest_item.Index() )
{
if (false == SetIndex(manifest_item.Index()))
{
ON_ERROR("index cannot be set");
rc = false;
}
}
return rc;
}
///////////////////////////////////////////////////////////////////////////////
//
// Id interface
//
const ON_UUID& ON_ModelComponent::Id() const
{
return m_component_id;
}
bool ON_ModelComponent::IdIsNil() const
{
return (ON_nil_uuid == m_component_id);
}
bool ON_ModelComponent::IdIsNotNil() const
{
return !(ON_nil_uuid == m_component_id);
}
bool ON_ModelComponent::SetId(
const ON_UUID& component_id
)
{
const unsigned int bit = ON_ModelComponent::Attributes::IdAttribute;
if (0 != (bit & m_locked_status))
return false;
const bool bContentChange = (false == (m_component_id == component_id));
m_component_id = component_id;
m_set_status |= bit;
if ( bContentChange )
IncrementContentVersionNumber();
return true;
}
const ON_UUID& ON_ModelComponent::IfIdIsNilSetId()
{
return
( ON_nil_uuid == m_component_id)
? SetId()
: m_component_id;
}
const ON_UUID& ON_ModelComponent::SetId()
{
if (false == IdIsLocked())
{
SetId(ON_CreateId());
return m_component_id;
}
return ON_nil_uuid;
}
const ON_UUID& ON_ModelComponent::SetAndLockId()
{
const ON_UUID& new_id = SetId();
if (!(ON_nil_uuid == new_id))
LockId();
return new_id;
}
bool ON_ModelComponent::ClearId()
{
const unsigned int bit = ON_ModelComponent::Attributes::IdAttribute;
return (bit == ClearModelComponentAttributes(bit));
}
void ON_ModelComponent::LockId()
{
m_locked_status |= ON_ModelComponent::Attributes::IdAttribute;
}
bool ON_ModelComponent::IdIsLocked() const
{
const unsigned int bit = ON_ModelComponent::Attributes::IdAttribute;
return (0 != (bit & m_locked_status));
}
bool ON_ModelComponent::IdIsSet() const
{
const unsigned int bit = ON_ModelComponent::Attributes::IdAttribute;
return (0 != (bit & m_set_status));
}
///////////////////////////////////////////////////////////////////////////////
//
// Component Status interface
//
//
ON_ComponentStatus ON_ModelComponent::ModelComponentStatus() const
{
return m_component_status;
}
bool ON_ModelComponent::SetModelComponentStatus(
ON_ComponentStatus component_status
)
{
const unsigned int bit = ON_ModelComponent::Attributes::ComponentStatusAttribute;
if (0 != (bit & m_locked_status))
return false;
const bool bContentChange = (m_component_status != component_status);
m_component_status = component_status;
m_set_status |= bit;
if ( bContentChange )
IncrementContentVersionNumber();
return true;
}
bool ON_ModelComponent::ClearModelComponentStatus()
{
const unsigned int bit = ON_ModelComponent::Attributes::ComponentStatusAttribute;
return (bit == ClearModelComponentAttributes(bit));
}
void ON_ModelComponent::LockModelComponentStatus()
{
m_locked_status |= ON_ModelComponent::Attributes::ComponentStatusAttribute;
}
bool ON_ModelComponent::ModelComponentStatusIsLocked() const
{
const unsigned int bit = ON_ModelComponent::Attributes::ComponentStatusAttribute;
return (0 != (bit & m_locked_status));
}
bool ON_ModelComponent::ModelComponentStatusIsSet() const
{
const unsigned int bit = ON_ModelComponent::Attributes::ComponentStatusAttribute;
return (0 != (bit & m_set_status));
}
bool ON_ModelComponent::IsDeleted() const
{
return m_component_status.IsDeleted();
}
bool ON_ModelComponent::SetDeletedModelComponentState(
bool bDeleted,
ON_ComponentManifest* manifest
)
{
bDeleted = bDeleted ? true : false; // inusre exact "true"
ON_ComponentStatus component_status = ModelComponentStatus();
if (bDeleted == component_status.IsDeleted())
{
// nothing to change
ON_ERROR("model_component deleted status = bDeleted");
}
else
{
component_status.SetDeletedState(bDeleted);
if (false == SetModelComponentStatus(component_status))
{
ON_ERROR("cannot change component deleted state.");
}
}
const ON_ComponentManifestItem& manifest_item
= (nullptr != manifest)
? ((bDeleted || ON_nil_uuid == m_component_id) ? manifest->ItemFromComponentRuntimeSerialNumber(m_runtime_serial_number) : manifest->ItemFromId(m_component_id))
: ON_ComponentManifestItem::UnsetItem;
const bool bComponentInManifest
= nullptr != manifest
&& manifest_item.Id() == m_component_id
&& (false == bDeleted || manifest_item.ComponentRuntimeSerialNumber() == this->m_runtime_serial_number);
if (nullptr != manifest && false == bComponentInManifest )
{
ON_ERROR("component is not in manifest.");
}
if (bDeleted)
{
// delete component name
if (DeletedNameIsSet())
{
ON_ERROR("component name is already deleted");
}
else if (NameIsSet())
{
if (false == DeleteName())
{
ON_ERROR("component name cannot be deleted.");
}
}
if (bComponentInManifest)
{
// delete manifest item
if (manifest_item.IsDeleted())
{
ON_ERROR("manifest item deleted status is already true.");
}
else
{
const ON_ComponentManifestItem& deleted_manifest_item = manifest->DeleteComponent(m_runtime_serial_number);
if (false == deleted_manifest_item.IsDeleted())
{
ON_ERROR("unable to change manifest item deleted status to true.");
}
}
}
}
else
{
// undelete component name
ON_wString candidate_name;
if (NameIsSet())
{
ON_ERROR("model_component name is already set");
candidate_name = Name();
}
else if (DeletedNameIsSet())
{
candidate_name = DeletedName();
if (false == UndeleteName())
{
ON_ERROR("cannot model_component deleted name cannot be restored.");
}
}
if (bComponentInManifest)
{
// undelete manifest item
if (false == manifest_item.IsDeleted())
{
ON_ERROR("doc_manifest item deleted status is already false.");
}
else
{
// When an component is being replaced, it is common for the old an new component
// to have the same id but different RuntimeSerialNumber() values.
ON_wString assigned_name;
const ON_ComponentManifestItem& undeleted_manifest_item = manifest->UndeleteComponentAndChangeRuntimeSerialNumber(
Id(),
ParentId(),
RuntimeSerialNumber(),
candidate_name,
assigned_name
);
if (false != undeleted_manifest_item.IsDeleted())
{
ON_ERROR("unable to change manifest item deleted status to false.");
}
SetName(assigned_name);
}
}
}
return (bDeleted == IsDeleted());
}
bool ON_ModelComponent::IsLocked() const
{
return m_component_status.IsLocked();
}
void ON_ModelComponent::SetLockedModelComponentState(
bool bLockedState
)
{
ON_ComponentStatus component_status = ModelComponentStatus();
if (bLockedState != component_status.IsLocked())
{
component_status.SetLockedState(bLockedState);
if (false == SetModelComponentStatus(component_status))
{
ON_ERROR("cannot change component locked state.");
}
}
}
bool ON_ModelComponent::IsHidden() const
{
return m_component_status.IsHidden();
}
void ON_ModelComponent::SetHiddenModelComponentState(
bool bHiddenState
)
{
ON_ComponentStatus component_status = ModelComponentStatus();
if (bHiddenState != component_status.IsHidden())
{
component_status.SetHiddenState(bHiddenState);
if (false == SetModelComponentStatus(component_status))
{
ON_ERROR("cannot change component hidden state.");
}
}
}
///////////////////////////////////////////////////////////////////////////////
//
// Index interface
//
// The component index is intended to be unique among components with identical
// types in the context of a model.
//
int ON_ModelComponent::Index() const
{
return m_component_index;
}
int ON_ModelComponent::Index(
int unset_index_value
) const
{
return IndexIsSet() ? m_component_index : unset_index_value;
}
bool ON_ModelComponent::SetIndex(
int component_index
)
{
const unsigned int bit = ON_ModelComponent::Attributes::IndexAttribute;
if (0 != (bit & m_locked_status))
return false;
const bool bContentChange = (m_component_index != component_index);
m_component_index = component_index;
m_set_status |= bit;
if ( bContentChange )
IncrementContentVersionNumber();
return true;
}
bool ON_ModelComponent::ClearIndex()
{
const unsigned int bit = ON_ModelComponent::Attributes::IndexAttribute;
return (bit == ClearModelComponentAttributes(bit));
}
void ON_ModelComponent::LockIndex()
{
m_locked_status |= ON_ModelComponent::Attributes::IndexAttribute;
}
bool ON_ModelComponent::IndexIsLocked() const
{
const unsigned int bit = ON_ModelComponent::Attributes::IndexAttribute;
return (0 != (bit & m_locked_status));
}
bool ON_ModelComponent::IndexIsSet() const
{
const unsigned int bit = ON_ModelComponent::Attributes::IndexAttribute;
return (0 != (bit & m_set_status));
}
///////////////////////////////////////////////////////////////////////////////
//
// ParentId interface
//
// The component parent_id is intended to be unique among components with identical
// types in the context of a model.
//
const ON_UUID& ON_ModelComponent::ParentId() const
{
return m_component_parent_id;
}
bool ON_ModelComponent::ParentIdIsNil() const
{
return (ON_nil_uuid == m_component_parent_id);
}
bool ON_ModelComponent::ParentIdIsNotNil() const
{
return (!(ON_nil_uuid == m_component_parent_id));
}
bool ON_ModelComponent::SetParentId(
const ON_UUID& component_parent_id
)
{
const unsigned int bit = ON_ModelComponent::Attributes::ParentIdAttribute;
if (0 != (bit & m_locked_status))
return false;
const bool bContentChange = (m_component_parent_id != component_parent_id);
m_component_parent_id = component_parent_id;
m_set_status |= bit;
if (bContentChange)
{
if (ON_ModelComponent::UniqueNameIncludesParent(m_component_type))
{
// The name hash includes the parent id for this type of component (like layers).
// Lazy evaluation is used to set m_component_name_hash.
m_component_name_hash = ON_NameHash::EmptyNameHash;
}
IncrementContentVersionNumber();
}
return true;
}
bool ON_ModelComponent::ClearParentId()
{
const unsigned int bit = ON_ModelComponent::Attributes::ParentIdAttribute;
return (bit == ClearModelComponentAttributes(bit));
}
void ON_ModelComponent::LockParentId()
{
m_locked_status |= ON_ModelComponent::Attributes::ParentIdAttribute;
}
bool ON_ModelComponent::ParentIdIsLocked() const
{
const unsigned int bit = ON_ModelComponent::Attributes::ParentIdAttribute;
return (0 != (bit & m_locked_status));
}
bool ON_ModelComponent::ParentIdIsSet() const
{
const unsigned int bit = ON_ModelComponent::Attributes::ParentIdAttribute;
return (0 != (bit & m_set_status));
}
///////////////////////////////////////////////////////////////////////////////
//
// General attributes interface
//
//
unsigned int ON_ModelComponent::ClearModelComponentAttributes(
unsigned int attributes_filter
)
{
const unsigned int locked_status = (unsigned int)m_locked_status;
unsigned int rc = 0;
unsigned int bit;
// Cannot modify locked attributes.
attributes_filter &= ~locked_status;
const unsigned int set_status0 = m_set_status;
bit = ON_ModelComponent::Attributes::ModelSerialNumberAttribute & attributes_filter;
if ( 0 != bit )
{
m_model_serial_number = ON_ModelComponent::Unset.m_model_serial_number;
m_reference_model_serial_number = ON_ModelComponent::Unset.m_reference_model_serial_number;
m_linked_idef_serial_number = ON_ModelComponent::Unset.m_linked_idef_serial_number;
m_set_status &= ~bit;
rc |= bit;
}
bit = ON_ModelComponent::Attributes::IdAttribute & attributes_filter;
if ( 0 != bit )
{
m_component_id = ON_ModelComponent::Unset.m_component_id;
m_set_status ^= bit;
rc |= bit;
}
bit = ON_ModelComponent::Attributes::ParentIdAttribute & attributes_filter;
if ( 0 != bit )
{
m_component_parent_id = ON_ModelComponent::Unset.m_component_id;
m_set_status &= ~bit;
rc |= bit;
}
bit = ON_ModelComponent::Attributes::TypeAttribute & attributes_filter;
if ( 0 != bit )
{
m_component_type = ON_ModelComponent::Unset.m_component_type;
m_set_status &= ~bit;
rc |= bit;
}
bit = ON_ModelComponent::Attributes::ComponentStatusAttribute & attributes_filter;
if ( 0 != bit )
{
m_component_status = ON_ModelComponent::Unset.m_component_status;
m_set_status &= ~bit;
rc |= bit;
}
bit = ON_ModelComponent::Attributes::IndexAttribute & attributes_filter;
if ( 0 != bit )
{
m_component_index = ON_ModelComponent::Unset.m_component_index;
m_set_status &= ~bit;
rc |= bit;
}
bit = ON_ModelComponent::Attributes::NameAttribute & attributes_filter;
if ( 0 != bit )
{
if (0 == (m_set_status & ON_ModelComponent::Attributes::DeletedNameAttribute))
{
m_component_name = ON_wString::EmptyString;
m_component_name_hash = ON_NameHash::EmptyNameHash;
}
m_set_status &= ~bit;
rc |= bit;
}
bit = ON_ModelComponent::Attributes::DeletedNameAttribute & attributes_filter;
if ( 0 != bit )
{
if (0 == (m_set_status & ON_ModelComponent::Attributes::NameAttribute))
{
m_component_name = ON_wString::EmptyString;
m_component_name_hash = ON_NameHash::EmptyNameHash;
}
m_set_status &= ~bit;
rc |= bit;
}
if ( set_status0 != m_set_status )
IncrementContentVersionNumber();
return rc;
}
bool ON_BinaryArchive::ReadModelComponentAttributes(
ON_ModelComponent& model_component,
unsigned int* attributes_filter
)
{
unsigned int read_bits = 0;
if ( nullptr != attributes_filter )
*attributes_filter = read_bits;
if (m_SetModelComponentSerialNumbers)
{
model_component.SetModelSerialNumber(
this->m_model_serial_number,
this->m_reference_model_serial_number,
this->m_instance_definition_model_serial_number
);
}
int major_version = 0;
int minor_version = 0;
if (false == BeginRead3dmChunk(TCODE_MODEL_ATTRIBUTES_CHUNK,&major_version,&minor_version))
return false;
bool rc = false;
for (;;)
{
if ( 1 != major_version )
break;
unsigned int bit;
unsigned char read_status;
bit = ON_ModelComponent::Attributes::ModelSerialNumberAttribute;
read_status = 0;
if (!ReadChar(&read_status))
break;
if (2 == read_status)
model_component.ClearModelSerialNumber();
else if (1 == read_status)
{
unsigned int model_serial_number = 0;
unsigned int reference_model_serial_number = 0;
unsigned int instance_definition_model_serial_number = 0;
if ( !ReadInt(&model_serial_number) )
break;
if ( !ReadInt(&reference_model_serial_number) )
break;
if ( !ReadInt(&instance_definition_model_serial_number) )
break;
model_component.SetModelSerialNumber(
model_serial_number,
reference_model_serial_number,
instance_definition_model_serial_number
);
read_bits |= bit;
}
bit = ON_ModelComponent::Attributes::IdAttribute;
read_status = 0;
if (!ReadChar(&read_status))
break;
if (2 == read_status)
{
model_component.ClearId();
}
else if (1 == read_status)
{
ON_UUID component_id = ON_nil_uuid;
if ( !ReadUuid(component_id) )
break;
model_component.SetId(component_id);
read_bits |= bit;
}
bit = ON_ModelComponent::Attributes::TypeAttribute;
read_status = 0;
if (!ReadChar(&read_status))
break;
if (2 == read_status)
model_component.ClearComponentType();
else if (1 == read_status)
{
unsigned int component_type_as_unsigned = 0;
if ( !ReadInt(&component_type_as_unsigned) )
break;
model_component.SetComponentType(ON_ModelComponent::ComponentTypeFromUnsigned(component_type_as_unsigned));
read_bits |= bit;
}
bit = ON_ModelComponent::Attributes::IndexAttribute;
read_status = 0;
if (!ReadChar(&read_status))
break;
if (2 == read_status)
model_component.ClearIndex();
else if (1 == read_status)
{
int component_index = 0;
if ( !ReadInt(&component_index) )
break;
model_component.SetIndex(component_index);
read_bits |= bit;
}
bit = ON_ModelComponent::Attributes::NameAttribute;
read_status = 0;
if (!ReadChar(&read_status))
break;
if (2 == read_status)
model_component.ClearName();
else if (1 == read_status)
{
ON_wString component_name;
if ( !ReadString(component_name) )
break;
model_component.SetName(static_cast<const wchar_t*>(component_name));
read_bits |= bit;
}
rc = true;
break;
}
if ( nullptr != attributes_filter)
*attributes_filter = read_bits;
if (false == EndRead3dmChunk())
rc = false;
return rc;
}
class ON_ModelComponentOverrideStackElement
{
public:
ON_ModelComponentOverrideStackElement(
const ON_ModelComponent& original_model_component,
const ON_ModelComponent& model_component_override
)
: m_original_model_component(original_model_component)
, m_model_component_override(model_component_override)
{}
~ON_ModelComponentOverrideStackElement() = default;
const ON_ModelComponent& m_original_model_component;
const ON_ModelComponent& m_model_component_override;
ON_ModelComponentOverrideStackElement* m_next = nullptr;
private:
ON_ModelComponentOverrideStackElement(const ON_ModelComponentOverrideStackElement&) = delete;
ON_ModelComponentOverrideStackElement& operator=(const ON_ModelComponentOverrideStackElement&) = delete;
};
bool ON_BinaryArchive::WriteModelComponentAttributes(
const class ON_ModelComponent& model_component,
unsigned int attributes_filter
)
{
if (false == BeginWrite3dmChunk(TCODE_MODEL_ATTRIBUTES_CHUNK,1,0))
return false;
bool rc = false;
for (;;)
{
unsigned int bit = ON_ModelComponent::Attributes::ModelSerialNumberAttribute & attributes_filter;
unsigned char write_status = (0 != bit) ? 1 : 0;
if ( 0 != write_status && false == model_component.ModelSerialNumberIsSet() )
write_status = 2;
if (!WriteChar(write_status))
break;
if (1 == write_status )
{
const unsigned int model_serial_number = model_component.ModelSerialNumber();
const unsigned int reference_model_serial_number = model_component.ReferenceModelSerialNumber();
const unsigned int instance_definition_model_serial_number = model_component.InstanceDefinitionModelSerialNumber();
if ( !WriteInt(model_serial_number) )
break;
if ( !WriteInt(reference_model_serial_number) )
break;
if ( !WriteInt(instance_definition_model_serial_number) )
break;
}
bit = ON_ModelComponent::Attributes::IdAttribute & attributes_filter;
write_status = (0 != bit) ? 1 : 0;
if ( 0 != write_status && false == model_component.IdIsSet() )
write_status = 2;
if (!WriteChar(write_status))
break;
if (1 == write_status )
{
ON_UUID component_id = model_component.Id();
if ( !WriteUuid(component_id) )
break;
}
bit = ON_ModelComponent::Attributes::TypeAttribute & attributes_filter;
write_status = (0 != bit) ? 1 : 0;
if ( 0 != write_status && false == model_component.ComponentTypeIsSet() )
write_status = 2;
if (!WriteChar(write_status))
break;
if (1 == write_status )
{
unsigned int component_type_as_unsigned = static_cast<unsigned int>(model_component.ComponentType());
if ( !WriteInt(component_type_as_unsigned) )
break;
}
bit = ON_ModelComponent::Attributes::IndexAttribute & attributes_filter;
write_status = (0 != bit) ? 1 : 0;
if ( 0 != write_status && false == model_component.IndexIsSet() )
write_status = 2;
if (!WriteChar(write_status))
break;
if (1 == write_status )
{
if ( !Write3dmReferencedComponentIndex( model_component ) )
break;
}
bit = ON_ModelComponent::Attributes::NameAttribute & attributes_filter;
write_status = (0 != bit) ? 1 : 0;
if ( 0 != write_status && false == model_component.NameIsSet() )
write_status = 2;
if (!WriteChar(write_status))
break;
if (1 == write_status )
{
if (false == this->WriteModelComponentName(model_component) )
break;
}
rc = true;
break;
}
if (false == EndWrite3dmChunk())
rc = false;
return rc;
}
bool ON_BinaryArchive::Write3dmReferencedComponentIndex(
const ON_ModelComponent& model_component
)
{
if (ReferencedComponentIndexMapping())
{
// During writing, the m_manifest member stores
// the model id and index as the "Component" values and
// the archive id and index as the "Manifest" values.
const ON_UUID component_id = model_component.Id();
return
(ON_nil_uuid == component_id)
? Write3dmReferencedComponentIndex(model_component.ComponentType(), model_component.Index())
: Write3dmReferencedComponentIndex(model_component.ComponentType(), component_id);
}
// no component mapping.
return WriteInt(model_component.Index());
}
bool ON_BinaryArchive::Read3dmReferencedComponentIndexArray(
ON_ModelComponent::Type component_type,
ON_SimpleArray<int>& component_index_array
)
{
if (!ReadArray(component_index_array))
return false;
if (false == ReferencedComponentIndexMapping())
return true; // true means continue reading
int count = 0;
for (int i = 0; i < component_index_array.Count(); i++)
{
int archive_index = component_index_array[i];
if (ON_ModelComponent::Type::TextStyle == component_type
&& archive_index >= 0
&& archive_index < m_text_style_to_dim_style_archive_index_map.Count()
)
{
const ON_2dex ts_to_ds = m_text_style_to_dim_style_archive_index_map[archive_index];
if (archive_index == ts_to_ds.i && ts_to_ds.j >= 0)
{
archive_index = ts_to_ds.j;
component_type = ON_ModelComponent::Type::DimStyle;
}
}
int component_index = archive_index;
component_index_array[i] = 0;
const ON_ManifestMapItem& map_item = ManifestMap().MapItemFromSourceIndex(component_type, archive_index);
if (false == map_item.SourceAndDestinationAreSet() || ON_UNSET_INT_INDEX == map_item.DestinationIndex())
{
ON_ERROR("Unable to update component reference index.");
continue;
}
component_index = map_item.DestinationIndex();
component_index_array[count++] = component_index;
}
component_index_array.SetCount(count);
return true; // true means continue reading
}
bool ON_BinaryArchive::Read3dmReferencedComponentIndex(
ON_ModelComponent::Type component_type,
int* component_index
)
{
if (nullptr != component_index)
*component_index = ON_UNSET_INT_INDEX;
int archive_component_index = ON_UNSET_INT_INDEX;
if (!ReadInt(&archive_component_index))
return false;
if (archive_component_index < 0 || false == ReferencedComponentIndexMapping() )
{
// system component with a persistent negative index
if (nullptr != component_index)
*component_index = archive_component_index;
return true;
}
int updated_component_index = archive_component_index;
if (ON_ModelComponent::Type::TextStyle == component_type)
{
component_type = ON_ModelComponent::Type::DimStyle;
const int archive_text_style_index = archive_component_index;
archive_component_index = ON_UNSET_INT_INDEX;
if (archive_text_style_index >= 0
&& archive_text_style_index < m_text_style_to_dim_style_archive_index_map.Count()
)
{
const ON_2dex ts_to_ds = m_text_style_to_dim_style_archive_index_map[archive_text_style_index];
if (archive_text_style_index == ts_to_ds.i && ts_to_ds.j >= 0)
{
archive_component_index = ts_to_ds.j;
}
}
}
if (ON_ModelComponent::Type::DimStyle == component_type)
{
if (this->Archive3dmVersion() <= 50)
{
if (nullptr != component_index)
*component_index = archive_component_index;
return true;
}
const int archive_dim_style_index = archive_component_index;
if (archive_dim_style_index >= 0
&& archive_dim_style_index < m_archive_dim_style_table.Count()
)
{
const ON_DimStyle* archive_dim_style = m_archive_dim_style_table[archive_dim_style_index];
if (nullptr != archive_dim_style)
{
if (archive_dim_style->ParentIdIsNotNil())
{
// override dimstyle - not in manifests or dimstyle table.
if (nullptr != component_index)
*component_index = archive_component_index;
return true;
}
const ON_ComponentManifestItem& item = m_manifest.ItemFromId(ON_ModelComponent::Type::DimStyle,archive_dim_style->Id());
if ( item.Id() == archive_dim_style->Id() )
{
archive_component_index = item.Index();
}
}
}
}
const ON_ManifestMapItem& map_item = m_manifest_map.MapItemFromSourceIndex(component_type,archive_component_index);
if (map_item.SourceAndDestinationAreSet() && ON_UNSET_INT_INDEX != map_item.DestinationIndex())
{
updated_component_index = map_item.DestinationIndex();
}
else
{
ON_ERROR("Unable to update component index.");
// Get something that might work when possible
switch (component_type)
{
case ON_ModelComponent::Type::Image:
break;
case ON_ModelComponent::Type::TextureMapping:
break;
case ON_ModelComponent::Type::Material:
updated_component_index = ON_Material::Default.Index();
break;
case ON_ModelComponent::Type::LinePattern:
updated_component_index = ON_Linetype::Continuous.Index();
break;
case ON_ModelComponent::Type::Layer:
break;
case ON_ModelComponent::Type::Group:
break;
case ON_ModelComponent::Type::TextStyle:
case ON_ModelComponent::Type::DimStyle:
if (nullptr != m_archive_current_dim_style)
{
const ON_ManifestMapItem& archive_current_dim_style_map_item = m_manifest_map.MapItemFromSourceIndex(ON_ModelComponent::Type::DimStyle,m_archive_current_dim_style->Index());
if (archive_current_dim_style_map_item.SourceAndDestinationAreSet()
&& ON_UNSET_INT_INDEX != archive_current_dim_style_map_item.DestinationIndex()
)
{
updated_component_index = archive_current_dim_style_map_item.DestinationIndex();
}
}
break;
case ON_ModelComponent::Type::RenderLight:
break;
case ON_ModelComponent::Type::HatchPattern:
break;
case ON_ModelComponent::Type::InstanceDefinition:
break;
case ON_ModelComponent::Type::ModelGeometry:
break;
case ON_ModelComponent::Type::HistoryRecord:
break;
default:
break;
}
}
if (nullptr != component_index)
*component_index = updated_component_index;
return true; // true indicates the read worked, even if the component index cannot be updated.
}
bool ON_BinaryArchive::Write3dmReferencedComponentIndex(
ON_ModelComponent::Type component_type,
int model_index
)
{
// When writing 3dm archives, the model index needs to be converted
// to an archive index. This function is used when the model component
// id is not known (for example, when writing ON_Layer material and
// line pattern indexes.
int archive_index = model_index;
if (model_index >= 0)
{
if (ON_ModelComponent::Type::TextStyle == component_type)
{
// In version 6, August 2016, text style information was moved to ON_DimStyle.
//
// In order to write files that can be read by earlier versions of Rhino,
// a text style table that is parallel to the dimstyle table is saved in the 3d archive.
if (ON_3dmArchiveTableType::dimension_style_table == m_3dm_active_table)
{
// The text style index of a dimstyle is being written. This is needed
// so V5 and V6 Rhino WIPs built before August 2016 will be able to read
// the file.
const int text_style_count = m_manifest.ActiveComponentCount(ON_ModelComponent::Type::TextStyle);
const int dim_style_count = m_manifest.ActiveComponentCount(ON_ModelComponent::Type::DimStyle);
if (dim_style_count > 0 && dim_style_count <= text_style_count)
archive_index = dim_style_count - 1;
else if (text_style_count > 0)
archive_index = 0;
else
archive_index = -1;
return WriteInt(archive_index);
}
if (ON_3dmArchiveTableType::text_style_table != m_3dm_active_table)
{
// We are finished writing the text style and dim style tables.
// There is a parallel set of text styles and dimension styles.
// To get the right index in the archive for older versions of Rhino, change the component type to dimstyle.
component_type = ON_ModelComponent::Type::DimStyle;
}
}
if ( ReferencedComponentIndexMapping() )
{
const ON_ManifestMapItem& map_item = ManifestMap().MapItemFromSourceIndex(component_type, model_index);
if (
component_type == map_item.ComponentType()
&& ON_UNSET_INT_INDEX != map_item.DestinationIndex()
)
{
archive_index = map_item.DestinationIndex();
}
else
{
ON_ERROR("unable to convert model index to archive index.");
archive_index = model_index;
}
}
}
return WriteInt(archive_index);
}
bool ON_BinaryArchive::Write3dmReferencedComponentIndex(
ON_ModelComponent::Type component_type,
ON_UUID model_id
)
{
// When writing 3dm archives, the model index needs to be converted
// to an archive index. This function is used when the model component
// id is known.
int archive_index = ON_UNSET_INT_INDEX;
if (ON_nil_uuid == model_id)
{
ON_ERROR("model_id is nil.");
}
else
{
const ON_ManifestMapItem& map_item = ManifestMap().MapItemFromSourceId(model_id);
if (component_type != map_item.ComponentType()
|| false == map_item.SourceIsSet()
)
{
ON_ERROR("model_id not in arcive manifest map.");
}
else if (false == ReferencedComponentIndexMapping())
{
// component reference mapping is disabled (rare)
archive_index = map_item.SourceIndex();
}
else
{
// adjust component reference to use the index in the archive (common)
if (ON_UNSET_INT_INDEX != map_item.DestinationIndex())
{
archive_index = map_item.DestinationIndex();
}
else
{
ON_ERROR("Unable to get archive component reference index.");
}
}
}
return WriteInt(archive_index);
}
bool ON_BinaryArchive::ReferencedComponentIndexMapping() const
{
return m_bReferencedComponentIndexMapping;
}
void ON_BinaryArchive::SetReferencedComponentIndexMapping(
bool bEnableReferencedComponentIndexMapping
)
{
const bool b = bEnableReferencedComponentIndexMapping ? true : false;
if (b != m_bReferencedComponentIndexMapping)
m_bReferencedComponentIndexMapping = b;
}
bool ON_BinaryArchive::Write3dmReferencedComponentId(
ON_ModelComponent::Type component_type,
ON_UUID model_component_id
)
{
return WriteUuid(model_component_id);
}
bool ON_BinaryArchive::Write3dmReferencedComponentId(
const ON_ModelComponent& model_component
)
{
return WriteUuid(model_component.Id());
}
bool ON_BinaryArchive::Read3dmReferencedComponentId(
ON_ModelComponent::Type component_type,
ON_UUID* component_id
)
{
ON_UUID id = ON_nil_uuid;
const bool rc = ReadUuid(id);
ON_UUID default_id = ON_nil_uuid;
bool bConvertToModelId = true;
switch (component_type)
{
case ON_ModelComponent::Type::Unset:
bConvertToModelId = false;
break;
case ON_ModelComponent::Type::Image:
break;
case ON_ModelComponent::Type::TextureMapping:
break;
case ON_ModelComponent::Type::Material:
break;
case ON_ModelComponent::Type::RenderContent: // JohnC: I have no idea what to do here.
break;
case ON_ModelComponent::Type::EmbeddedFile: // JohnC: I have no idea what to do here.
break;
case ON_ModelComponent::Type::LinePattern:
break;
case ON_ModelComponent::Type::Layer:
break;
case ON_ModelComponent::Type::Group:
break;
case ON_ModelComponent::Type::TextStyle:
break;
case ON_ModelComponent::Type::DimStyle:
default_id = this->ArchiveCurrentDimStyleId();
break;
case ON_ModelComponent::Type::RenderLight:
break;
case ON_ModelComponent::Type::HatchPattern:
break;
case ON_ModelComponent::Type::InstanceDefinition:
break;
case ON_ModelComponent::Type::ModelGeometry:
break;
case ON_ModelComponent::Type::HistoryRecord:
break;
case ON_ModelComponent::Type::Mixed:
bConvertToModelId = false;
break;
default:
bConvertToModelId = false;
break;
}
if (false == rc || ON_nil_uuid == id )
{
id = default_id;
}
else if ( ON_nil_uuid != id && bConvertToModelId )
{
const ON_ComponentManifestItem& item = this->Manifest().ItemFromId(component_type, id);
if (component_type == item.ComponentType() && item.Id() == id )
{
// expected ...
const ON_ManifestMapItem& map_item = this->ManifestMap().MapItemFromSourceId(id);
if (component_type == map_item.ComponentType()
&& map_item.SourceId() == id
&& ON_nil_uuid != map_item.DestinationId()
)
{
// ... everything is as it should be. Assign id used in model.
id = map_item.DestinationId();
}
// else
// {
// Either the id was unchanged or the reading code failed
// to set as (source,destination) pair in the manifest map.
// It's not an error condition.
// }
}
else
{
// complicated situations
switch (component_type)
{
case ON_ModelComponent::Type::Unset:
break;
case ON_ModelComponent::Type::Image:
break;
case ON_ModelComponent::Type::TextureMapping:
break;
case ON_ModelComponent::Type::Material:
break;
case ON_ModelComponent::Type::LinePattern:
break;
case ON_ModelComponent::Type::Layer:
break;
case ON_ModelComponent::Type::Group:
break;
case ON_ModelComponent::Type::TextStyle:
break;
case ON_ModelComponent::Type::DimStyle:
if (ON_ModelComponent::Type::DimStyle != item.ComponentType()
&& ON_DimStyle::SystemDimstyleFromId(id).Id() != id
)
{
const unsigned int fixed_version = ON_VersionNumberConstruct(6, 0, 2017, 1, 15, 0);
const unsigned int archive_version = this->ArchiveOpenNURBSVersion();
if (archive_version >= fixed_version)
{
// Should not happen
ON_ERROR("dimstyle id not in archive.");
}
id = default_id;
}
break;
case ON_ModelComponent::Type::RenderLight:
break;
case ON_ModelComponent::Type::HatchPattern:
break;
case ON_ModelComponent::Type::InstanceDefinition:
break;
case ON_ModelComponent::Type::ModelGeometry:
break;
case ON_ModelComponent::Type::HistoryRecord:
break;
case ON_ModelComponent::Type::Mixed:
break;
default:
break;
}
}
}
if (nullptr != component_id)
*component_id = id;
return rc;
}
bool ON_BinaryArchive::ReferencedComponentIdMapping() const
{
return m_bReferencedComponentIdMapping;
}
void ON_BinaryArchive::SetReferencedComponentIdMapping(
bool bEnableReferenceComponentIdMapping
)
{
m_bReferencedComponentIdMapping
= bEnableReferenceComponentIdMapping
? true
: false;
}
const ON_ComponentManifest& ON_BinaryArchive::Manifest() const
{
return m_manifest;
}
const ON_ManifestMap& ON_BinaryArchive::ManifestMap() const
{
return m_manifest_map;
}
bool ON_BinaryArchive::UpdateManifestMapItemDestination(
const class ON_ManifestMapItem& map_item
)
{
if (ON::archive_mode::read3dm != this->Mode())
{
ON_ERROR("archive mode != ON::archive_mode::read3dm");
return false;
}
if (map_item.SourceIsUnset())
{
ON_ERROR("map_item source information is not set.");
return false;
}
const bool bIgnoreSourceIndex = (ON_ModelComponent::Type::Group == map_item.ComponentType());
return m_manifest_map.UpdatetMapItemDestination(map_item, bIgnoreSourceIndex);
}
bool ON_BinaryArchive::Internal_Write3dmUpdateManifest(
const ON_ModelComponent& model_component
)
{
bool rc = false;
for (;;)
{
const ON_ComponentManifestItem& manifest_item = m_manifest.AddComponentToManifest(model_component, false, nullptr);
if (manifest_item.IsUnset())
break;
ON_ManifestMapItem map_item;
if (!map_item.SetSourceIdentification(&model_component))
break;
if (!map_item.SetDestinationIdentification(&manifest_item))
break;
rc = m_manifest_map.AddMapItem(map_item);
break;
}
if (!rc)
{
ON_ERROR("Unable to update archive manifest and map.");
}
return rc;
}
bool ON_BinaryArchive::Internal_Write3dmLightOrGeometryUpdateManifest(
ON_ModelComponent::Type component_type,
ON_UUID component_id,
int component_index,
const ON_wString& component_name
)
{
bool rc = false;
for (;;)
{
const ON__UINT64 no_serial_number_yet = 0;
const ON_NameHash component_name_hash = ON_NameHash::Create(ON_nil_uuid, component_name);
const ON_ComponentManifestItem& manifest_item = m_manifest.AddComponentToManifest(component_type, no_serial_number_yet, component_id, component_name_hash);
if (manifest_item.IsUnset())
break;
if (ON_ModelComponent::IndexRequired(component_type))
{
if (component_index < 0)
{
ON_ERROR("component_index should have value >= 0");
component_index = manifest_item.Index();
}
}
else
{
if (ON_UNSET_INT_INDEX != component_index)
{
ON_ERROR("component_index should have value ON_UNSET_INT_INDEX");
component_index = ON_UNSET_INT_INDEX;
}
}
ON_ManifestMapItem map_item;
if (!map_item.SetSourceIdentification(component_type, component_id, component_index))
break;
if (!map_item.SetDestinationIdentification(&manifest_item))
break;
rc = m_manifest_map.AddMapItem(map_item);
break;
}
if (!rc)
{
ON_ERROR("Unable to update archive manifest and map.");
}
return rc;
}
bool ON_BinaryArchive::Internal_Read3dmUpdateManifest(
ON_ModelComponent& model_component
)
{
const bool bResolveIdAndNameCollisions = true;
bool rc = false;
for (;;)
{
const ON_ComponentManifestItem& item_from_id
= model_component.IdIsNotNil()
? m_manifest.ItemFromId(model_component.Id())
: ON_ComponentManifestItem::UnsetItem;
const ON_ComponentManifestItem& item_from_name
= ( model_component.NameIsNotEmpty() && ON_ModelComponent::UniqueNameRequired(model_component.ComponentType()) )
? m_manifest.ItemFromName(&model_component)
: ON_ComponentManifestItem::UnsetItem;
if (item_from_id.IsValid())
{
// id conflict - this is bad
ON_WARNING("id conflict - 3dm file is not valid.");
if (item_from_id.ComponentType() == model_component.ComponentType())
{
// duplicate components - first one wins and no remapping the id
model_component.ClearId();
model_component.SetId(); // generates new id
}
}
if (item_from_name.IsValid() && false == item_from_name.IsSystemComponent() )
{
// name conflict but not id conflict - still bad
// first name wins - no remapping
if (false == item_from_id.IsValid())
{
// one warning is enough
ON_WARNING("name conflict - 3dm file is not valid.");
}
model_component.SetName(m_manifest.UnusedName(model_component));
}
const bool bIndexRequired = ON_ModelComponent::IndexRequired(model_component.ComponentType());
const int archive_index = model_component.Index();
ON_wString assigned_name;
const ON_ComponentManifestItem& manifest_item = m_manifest.AddComponentToManifest(model_component, bResolveIdAndNameCollisions, &assigned_name);
if (manifest_item.IsUnset())
break;
if (bResolveIdAndNameCollisions && manifest_item.IsValid())
{
if (manifest_item.Id() != model_component.Id())
{
ON_WARNING("new id assigned to model component.");
model_component.SetId(manifest_item.Id());
}
if (false == ON_wString::EqualOrdinal(model_component.Name(),assigned_name,false))
{
ON_WARNING("new name assigned to model component.");
model_component.SetName(assigned_name);
}
// In damaged files, the index values are a mess.
// Fix them here.
const int manifest_index = manifest_item.Index();
const int assigned_index
= bIndexRequired
? (manifest_index >= 0 ? manifest_index : archive_index)
: ON_UNSET_INT_INDEX;
if (assigned_index != archive_index)
{
if (bIndexRequired) // This is a good location for a debugger breakpoint when debugging file reading index issues.
model_component.SetIndex(manifest_item.Index());
else
model_component.ClearIndex();
}
}
ON_ComponentManifestItem source_item(manifest_item);
if (ON_ModelComponent::Type::Group == model_component.ComponentType()
&& archive_index >= 0
&& manifest_item.Index() >= 0
&& archive_index != manifest_item.Index()
)
{
// group index values are not always the zero based index of the
// group element's location in the archive.
source_item.SetIndex(archive_index);
}
ON_ManifestMapItem map_item;
// Rhino will update destination identification if it changes when added to the model.
if (!map_item.SetSourceIdentification(&source_item))
break;
if (!map_item.SetDestinationIdentification(&model_component))
break;
rc = m_manifest_map.AddMapItem(map_item);
break;
}
if (!rc)
{
ON_ERROR("Unable to update archive manifest and map.");
}
return rc;
}
bool ON_BinaryArchive::Internal_Read3dmLightOrGeometryUpdateManifest(
ON_ModelComponent::Type component_type,
ON_UUID component_id,
int component_index,
const ON_wString& component_name
)
{
bool rc = false;
for (;;)
{
const ON__UINT64 no_serial_number_yet = 0;
const ON_NameHash component_name_hash = ON_NameHash::Create(ON_nil_uuid, component_name);
const ON_ComponentManifestItem& manifest_item = m_manifest.AddComponentToManifest(component_type, no_serial_number_yet, component_id, component_name_hash);
if (manifest_item.IsUnset())
break;
if (ON_ModelComponent::IndexRequired(component_type))
{
if (component_index < 0)
{
ON_ERROR("component_index should have value >= 0");
component_index = manifest_item.Index();
}
}
else
{
if (ON_UNSET_INT_INDEX != component_index)
{
ON_ERROR("component_index should have value ON_UNSET_INT_INDEX");
component_index = ON_UNSET_INT_INDEX;
}
}
ON_ManifestMapItem map_item;
// Rhino will update destination if it changes id or index
if (!map_item.SetDestinationIdentification(component_type, component_id, component_index))
break;
if (!map_item.SetSourceIdentification(&manifest_item))
break;
rc = m_manifest_map.AddMapItem(map_item);
break;
}
if (!rc)
{
ON_ERROR("Unable to update archive manifest and map.");
}
return rc;
}
bool ON_BinaryArchive::AddManifestMapItem(
const class ON_ManifestMapItem& map_item
)
{
if (false == map_item.SourceAndDestinationAreSet() )
{
ON_ERROR("map_item source and destination are not set.");
return false;
}
const bool bIndexRequired = ON_ModelComponent::IndexRequired(map_item.ComponentType());
if (bIndexRequired && map_item.SourceIndex() < 0)
{
ON_ERROR("map_item.m_source_component_index is not set.");
return false;
}
switch (Mode())
{
case ON::archive_mode::read3dm:
{
const ON_ComponentManifestItem& archive_item_from_id = m_manifest.ItemFromId(map_item.SourceId());
if (
map_item.ComponentType() != archive_item_from_id.ComponentType()
|| map_item.SourceId() != archive_item_from_id.Id()
|| map_item.SourceIndex() != archive_item_from_id.Index()
)
{
ON_ERROR("map_item.m_source_component_id is not in the archive manifest.");
return false;
}
if (bIndexRequired)
{
const ON_ComponentManifestItem& archive_item_from_index = m_manifest.ItemFromIndex(map_item.ComponentType(), map_item.SourceIndex());
if (
map_item.ComponentType() != archive_item_from_index.ComponentType()
|| map_item.SourceId() != archive_item_from_index.Id()
|| map_item.SourceIndex() != archive_item_from_index.Index()
)
{
ON_ERROR("map_item.m_source_component_index is not in the archive manifest.");
return false;
}
}
}
break;
case ON::archive_mode::write3dm:
{
const ON_ComponentManifestItem& archive_item_from_id = m_manifest.ItemFromId(map_item.DestinationId());
if (
map_item.ComponentType() != archive_item_from_id.ComponentType()
|| map_item.DestinationId() != archive_item_from_id.Id()
|| map_item.DestinationIndex() != archive_item_from_id.Index()
)
{
ON_ERROR("map_item.m_destination_component_id is not in the archive manifest.");
return false;
}
if (bIndexRequired)
{
const ON_ComponentManifestItem& archive_item_from_index = m_manifest.ItemFromIndex(map_item.ComponentType(), map_item.DestinationIndex());
if (
map_item.ComponentType() != archive_item_from_index.ComponentType()
|| map_item.DestinationId() != archive_item_from_index.Id()
|| map_item.DestinationIndex() != archive_item_from_index.Index()
)
{
ON_ERROR("map_item.m_destination_component_index is not in the archive manifest.");
return false;
}
}
}
break;
default:
break;
}
if (!m_manifest_map.AddMapItem(map_item))
{
ON_ERROR("m_manifest_map.AddMapItem(map_item) failed.");
}
return true;
}
//////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
// Explicit implementation to insure m_sp is completely managed in the openurbs DLL.
ON_ModelComponentWeakReference::ON_ModelComponentWeakReference() ON_NOEXCEPT
{}
// Explicit implementation to insure m_sp is completely managed in the openurbs DLL.
ON_ModelComponentWeakReference::~ON_ModelComponentWeakReference()
{}
// Explicit implementation to insure m_sp is completely managed in the openurbs DLL.
ON_ModelComponentWeakReference::ON_ModelComponentWeakReference(const ON_ModelComponentWeakReference& src) ON_NOEXCEPT
: m_wp(src.m_wp)
{}
// Explicit implementation to insure m_sp is completely managed in the openurbs DLL.
ON_ModelComponentWeakReference& ON_ModelComponentWeakReference::operator=(const ON_ModelComponentWeakReference& src)
{
if ( this != &src)
m_wp = src.m_wp;
return *this;
}
#if defined(ON_HAS_RVALUEREF)
ON_ModelComponentWeakReference::ON_ModelComponentWeakReference( ON_ModelComponentWeakReference&& src ) ON_NOEXCEPT
: m_wp(std::move(src.m_wp))
{}
ON_ModelComponentWeakReference& ON_ModelComponentWeakReference::operator=(ON_ModelComponentWeakReference&& src)
{
if ( this != &src )
{
m_wp.reset();
m_wp = std::move(src.m_wp);
}
return *this;
}
#endif
ON_ModelComponentWeakReference::ON_ModelComponentWeakReference(const ON_ModelComponentReference& src) ON_NOEXCEPT
: m_wp(src.m_sp)
{}
ON_ModelComponentWeakReference& ON_ModelComponentWeakReference::operator=(const ON_ModelComponentReference& src)
{
m_wp = src.m_sp;
return *this;
}
//////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
// Explicit implementation to insure m_sp is completely managed in the openurbs DLL.
ON_ModelComponentReference::ON_ModelComponentReference() ON_NOEXCEPT
{}
// Explicit implementation to insure m_sp is completely managed in the openurbs DLL.
ON_ModelComponentReference::~ON_ModelComponentReference()
{}
// Explicit implementation to insure m_sp is completely managed in the openurbs DLL.
ON_ModelComponentReference::ON_ModelComponentReference(const ON_ModelComponentReference& src) ON_NOEXCEPT
: m_sp(src.m_sp)
{}
// Explicit implementation to insure m_sp is completely managed in the openurbs DLL.
ON_ModelComponentReference& ON_ModelComponentReference::operator=(const ON_ModelComponentReference& src)
{
if ( this != &src)
m_sp = src.m_sp;
return *this;
}
#if defined(ON_HAS_RVALUEREF)
ON_ModelComponentReference::ON_ModelComponentReference( ON_ModelComponentReference&& src ) ON_NOEXCEPT
: m_sp(std::move(src.m_sp))
{}
ON_ModelComponentReference& ON_ModelComponentReference::operator=(ON_ModelComponentReference&& src)
{
if ( this != &src )
{
m_sp.reset();
m_sp = std::move(src.m_sp);
}
return *this;
}
#endif
ON_ModelComponentReference::ON_ModelComponentReference(const ON_ModelComponentWeakReference& src) ON_NOEXCEPT
: m_sp(src.m_wp.lock())
{
// NOTE WELL:
// std::shared_ptr<T>(std::weak_ptr<T>) throws an exception when weak_ptr is empty.
// std::shared_ptr<T>(std::weak_ptr<T>.lock()) constructs and empty shared_ptr when weak_ptr is empty.
}
ON_ModelComponentReference& ON_ModelComponentReference::operator=(const ON_ModelComponentWeakReference& src)
{
m_sp = src.m_wp.lock();
return *this;
}
ON_ModelComponentReference::ON_ModelComponentReference(
std::shared_ptr<ON_ModelComponent>& sp
) ON_NOEXCEPT
: m_sp(sp)
{}
ON_ModelComponentReference& ON_ModelComponentReference::operator=(std::shared_ptr<ON_ModelComponent>& sp)
{
m_sp = sp;
return *this;
}
ON_ModelComponentReference ON_ModelComponentReference::CreateConstantSystemComponentReference(
const class ON_ModelComponent& system_model_component
) ON_NOEXCEPT
{
if ( system_model_component.IsSystemComponent())
return CreateForExperts(const_cast<ON_ModelComponent*>(&system_model_component),false);
ON_ERROR("Invalid system_model_component parameter.");
return ON_ModelComponentReference::Empty;
}
ON_ModelComponentReference ON_ModelComponentReference::CreateForExperts(
class ON_ModelComponent* model_component,
bool bManagedComponentReference
) ON_NOEXCEPT
{
if ( nullptr == model_component )
return ON_ModelComponentReference::Empty;
if (bManagedComponentReference && model_component->IsSystemComponent())
{
// If you get this error, you have const cast a system component
// and there will be a hard to diagnose crash when the the
// last shared pointer attempts to delete the constant system component.
//
// You should be using ON_ModelComponentReference::CreateConstantSystemComponentReference.
ON_ERROR("The future attempt to delete model_component will crash the application.");
return ON_ModelComponentReference::Empty;
}
ON_ModelComponentReference r;
r.m_sp
= bManagedComponentReference
? ON_MANAGED_SHARED_PTR(ON_ModelComponent,model_component) // default calls delete model_component
: ON_UNMANAGED_SHARED_PTR(ON_ModelComponent,model_component);
return r;
}
const class ON_ModelComponent* ON_ModelComponentReference::ModelComponent() const ON_NOEXCEPT
{
return m_sp.get();
}
class ON_ModelComponent* ON_ModelComponentReference::ExclusiveModelComponent() const ON_NOEXCEPT
{
return
(1 == m_sp.use_count())
? m_sp.get()
: nullptr;
}
ON__UINT64 ON_ModelComponentReference::ModelComponentRuntimeSerialNumber() const ON_NOEXCEPT
{
const ON_ModelComponent* model_component = m_sp.get();
return (nullptr != model_component) ? model_component->RuntimeSerialNumber() : 0;
}
const ON_UUID ON_ModelComponentReference::ModelComponentId() const ON_NOEXCEPT
{
const ON_ModelComponent* model_component = m_sp.get();
return (nullptr != model_component) ? model_component->Id() : ON_nil_uuid;
}
int ON_ModelComponentReference::ModelComponentIndex() const ON_NOEXCEPT
{
const ON_ModelComponent* model_component = m_sp.get();
return (nullptr != model_component) ? model_component->Index() : ON_UNSET_INT_INDEX;
}
const ON_NameHash ON_ModelComponentReference::ModelComponentNameHash() const ON_NOEXCEPT
{
const ON_ModelComponent* model_component = m_sp.get();
return (nullptr != model_component) ? model_component->NameHash() : ON_NameHash::UnsetNameHash;
}
bool ON_ModelComponentReference::IsEmpty() const ON_NOEXCEPT
{
return (nullptr == m_sp.get());
}
unsigned int ON_ModelComponentReference::ReferenceCount() const ON_NOEXCEPT
{
return (unsigned int)(m_sp.use_count());
}
ON_ModelComponentContentMark::ON_ModelComponentContentMark(
const ON_ModelComponent& model_component
)
{
Set(model_component);
}
ON_ModelComponentContentMark::ON_ModelComponentContentMark(
const ON_ModelComponent* model_component
)
{
Set(model_component);
}
void ON_ModelComponentContentMark::Set(
const class ON_ModelComponent& model_component
)
{
m_component_id = model_component.Id();
m_component_serial_number = model_component.RuntimeSerialNumber();
m_component_content_version_number = model_component.ContentVersionNumber();
m_component_type = model_component.ComponentType();
}
void ON_ModelComponentContentMark::Set(
const class ON_ModelComponent* model_component
)
{
if (nullptr == model_component)
*this = ON_ModelComponentContentMark::Unset;
else
Set(*model_component);
}
bool ON_ModelComponentContentMark::EqualContent(
const class ON_ModelComponent& model_component
) const
{
const ON_ModelComponentContentMark rhs(model_component);
return EqualContent(*this, rhs);
}
bool ON_ModelComponentContentMark::EqualContent(
const class ON_ModelComponent* model_component
) const
{
const ON_ModelComponentContentMark rhs(model_component);
return EqualContent(*this, rhs);
}
bool ON_ModelComponentContentMark::EqualContent(
const ON_ModelComponentContentMark& lhs,
const ON_ModelComponentContentMark& rhs
)
{
return
lhs.m_component_serial_number == rhs.m_component_serial_number
&& lhs.m_component_content_version_number == rhs.m_component_content_version_number
&& lhs.m_component_id == rhs.m_component_id
&& lhs.m_component_type == rhs.m_component_type
;
}
bool operator==(
const ON_ModelComponentContentMark& lhs,
const ON_ModelComponentContentMark& rhs
)
{
return ON_ModelComponentContentMark::EqualContent(lhs, rhs);
}
bool operator!=(
const ON_ModelComponentContentMark& lhs,
const ON_ModelComponentContentMark& rhs
)
{
return ON_ModelComponentContentMark::EqualContent(lhs, rhs) ? false : true;
}
ON_UUID ON_ModelComponentContentMark::ComponentId() const
{
return m_component_id;
}
ON__UINT64 ON_ModelComponentContentMark::ComponentRuntimeSerialNumber() const
{
return m_component_serial_number;
}
ON__UINT64 ON_ModelComponentContentMark::ComponentContentVersionNumber() const
{
return m_component_content_version_number;
}
ON_ModelComponent::Type ON_ModelComponentContentMark::ComponentType() const
{
return m_component_type;
}
bool ON_ModelComponentContentMark::IsSet() const
{
return (0 != m_component_serial_number);
}
bool ON_ModelComponentContentMark::IsUnset() const
{
return (0 == m_component_serial_number);
}
Reference in New Issue View Git Blame Copy Permalink