add support for inline pointed-to-object representation (no indexing)

Archive.cpp

@@ -199,34 +199,45 @@ ArchiveMode ArchiveWriter::GetMode() const
 	return ArchiveModes::Write;
 }
 
-bool ArchiveWriter::Identify( Object* object, Name& identity )
+bool ArchiveWriter::Identify( const ObjectPtr& object, Name* identity )
 {
-	if ( !m_Identifier || !m_Identifier->Identify( object, identity ))
+	if ( m_Identifier )
 	{
-		size_t index = Invalid< size_t >();
-		for ( DynamicArray< ObjectPtr >::ConstIterator itr = m_Objects.Begin(), end = m_Objects.End(); itr != end; ++itr )
+		return m_Identifier->Identify( object, identity );
+	}
+
+	bool strictOwnership = reinterpret_cast< RefCountProxy< Reflect::Object >* >( object.GetProxy() )->GetStrongRefCount() == 1;
+	if ( !strictOwnership )
+	{
+		if ( identity )
 		{
-			if ( itr->Ptr() == object )
+			size_t index = Invalid< size_t >();
+			for ( DynamicArray< ObjectPtr >::ConstIterator itr = m_Objects.Begin(), end = m_Objects.End(); itr != end; ++itr )
 			{
-				index = m_Objects.GetIndex( itr );
-				break;
+				if ( itr->Ptr() == object )
+				{
+					index = m_Objects.GetIndex( itr );
+					break;
+				}
 			}
-		}
 
-		if ( index == Invalid< size_t >() )
-		{
-			index = m_Objects.GetSize();
+			if ( index == Invalid< size_t >() )
+			{
+				index = m_Objects.GetSize();
+
+				// this will cause it to be written after the current object-in-progress (see Write)
+				m_Objects.Push( object );
+			}
 
-			// this will cause it to be written after the current object-in-progress (see Write)
-			m_Objects.Push( object );
+			String str;
+			str.Format( "%d", index );
+			identity->Set( str );
 		}
 
-		String str;
-		str.Format( "%d", index );
-		identity.Set( str );
+		return true;
 	}
 
-	return true;
+	return false;
 }
 
 SmartPtr< ArchiveReader > ArchiveReader::GetReader( const FilePath& path, ObjectResolver* resolver, ArchiveType archiveType )

Archive.h

@@ -140,7 +140,7 @@ namespace Helium
 
 		protected:
 			virtual void Write( const Reflect::ObjectPtr* objects, size_t count ) = 0;
-			virtual bool Identify( Reflect::Object* object, Name& identity ) HELIUM_OVERRIDE;
+			virtual bool Identify( const Reflect::ObjectPtr& object, Name* identity ) HELIUM_OVERRIDE;
 
 			DynamicArray< Reflect::ObjectPtr > m_Objects;
 			Reflect::ObjectIdentifier*         m_Identifier;

ArchiveJson.cpp

@@ -192,10 +192,26 @@ void ArchiveWriterJson::SerializeTranslator( Pointer pointer, Translator* transl
 {
 	switch ( translator->GetMetaId() )
 	{
+	case MetaIds::PointerTranslator:
+		{
+			const ObjectPtr& pointed ( pointer.As< ObjectPtr >() );
+			if ( !Identify( pointed, NULL ) )
+			{
+				m_Writer.StartObject();
+				m_Writer.String( pointed->GetMetaClass()->m_Name );
+				SerializeInstance( pointed, pointed->GetMetaClass(), pointed );
+				m_Writer.EndObject();
+				break;
+			}
+			else
+			{
+				// fall through!!
+			}
+		}
+
 	case MetaIds::ScalarTranslator:
 	case MetaIds::SimpleTranslator:
 	case MetaIds::EnumerationTranslator:
-	case MetaIds::PointerTranslator:
 	case MetaIds::TypeTranslator:
 		{
 			ScalarTranslator* scalar = static_cast< ScalarTranslator* >( translator );
@@ -716,7 +732,39 @@ void ArchiveReaderJson::DeserializeTranslator( rapidjson::Value& value, Pointer
 	}
 	else if ( value.IsObject() )
 	{
-		if ( translator->GetMetaId() == MetaIds::StructureTranslator )
+		if ( translator->GetMetaId() == MetaIds::PointerTranslator )
+		{
+			ObjectPtr& object ( pointer.As<ObjectPtr>() );
+
+			rapidjson::Value::Member* member = value.MemberBegin();
+			if ( HELIUM_VERIFY( member != value.MemberEnd() ) )
+			{
+				uint32_t objectClassCrc = 0;
+				if ( member->name.IsString() )
+				{
+					String typeStr;
+					typeStr = member->name.GetString();
+					objectClassCrc = Helium::Crc32( typeStr.GetData() );
+				}
+
+				const MetaClass* objectClass = NULL;
+				if ( objectClassCrc != 0 )
+				{
+					objectClass = Registry::GetInstance()->GetMetaClass( objectClassCrc );
+				}
+
+				if ( !object && objectClass )
+				{
+					object = objectClass->m_Creator();
+				}
+
+				if ( object.ReferencesObject() )
+				{
+					DeserializeInstance( member->value, object, object->GetMetaClass(), object );
+				}
+			}
+		}
+		else if ( translator->GetMetaId() == MetaIds::StructureTranslator )
 		{
 			StructureTranslator* structure = static_cast< StructureTranslator* >( translator );
 			DeserializeInstance( value, pointer.m_Address,  structure->GetMetaStruct(), object );