export mesh, vertices, faces, colors

ProjectCollection is now a FinishCollector (accumulates the finishes to write the material proxies at the end)

SpeckleConnector/Connector.vcxproj

@@ -127,8 +127,9 @@
     <ClCompile Include="Connector\Interface\Browser\Bridge\Test\TriggerEvent.cpp" />
     <ClCompile Include="Connector\Interface\ConnectorMenu.cpp" />
     <ClCompile Include="Connector\Interface\ConnectorPalette.cpp" />
+    <ClCompile Include="Connector\Record\Collection\FinishProxy.cpp" />
+    <ClCompile Include="Connector\Record\Collection\ProjectCollection.cpp" />
     <ClCompile Include="Connector\Record\Collection\RecordCollection.cpp" />
-    <ClCompile Include="Connector\Record\Collection\RootCollection.cpp" />
     <ClCompile Include="Connector\Record\Model\CardMover.cpp" />
     <ClCompile Include="Connector\Record\Model\CardSetting.cpp" />
     <ClCompile Include="Connector\Record\Model\Filter\DirectSelectionSendFilter.cpp" />
@@ -178,8 +179,9 @@
     <ClInclude Include="Connector\Interface\Browser\Bridge\Test\TriggerEvent.h" />
     <ClInclude Include="Connector\Interface\ConnectorMenu.h" />
     <ClInclude Include="Connector\Interface\ConnectorPalette.h" />
+    <ClInclude Include="Connector\Record\Collection\FinishProxy.h" />
+    <ClInclude Include="Connector\Record\Collection\ProjectCollection.h" />
     <ClInclude Include="Connector\Record\Collection\RecordCollection.h" />
-    <ClInclude Include="Connector\Record\Collection\RootCollection.h" />
     <ClInclude Include="Connector\Record\Model\CardMover.h" />
     <ClInclude Include="Connector\Record\Model\CardSetting.h" />
     <ClInclude Include="Connector\Record\Model\Filter\ArchicadEverythingFilter.h" />

SpeckleConnector/Connector.vcxproj.filters

@@ -207,9 +207,6 @@
     <ClCompile Include="Connector\Record\Collection\RecordCollection.cpp">
       <Filter>Connector\Record\Collection</Filter>
     </ClCompile>
-    <ClCompile Include="Connector\Record\Collection\RootCollection.cpp">
-      <Filter>Connector\Record\Collection</Filter>
-    </ClCompile>
     <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\ConversionResult.cpp">
       <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
     </ClCompile>
@@ -225,6 +222,12 @@
     <ClCompile Include="Connector\Interface\Browser\Bridge\Send\GetSendSettings.cpp">
       <Filter>Connector\Interface\Browser\Bridge\Send</Filter>
     </ClCompile>
+    <ClCompile Include="Connector\Record\Collection\FinishProxy.cpp">
+      <Filter>Connector\Record\Collection</Filter>
+    </ClCompile>
+    <ClCompile Include="Connector\Record\Collection\ProjectCollection.cpp">
+      <Filter>Connector\Record\Collection</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Connector\ConnectorResource.h">
@@ -363,9 +366,6 @@
     <ClInclude Include="Connector\Record\Collection\RecordCollection.h">
       <Filter>Connector\Record\Collection</Filter>
     </ClInclude>
-    <ClInclude Include="Connector\Record\Collection\RootCollection.h">
-      <Filter>Connector\Record\Collection</Filter>
-    </ClInclude>
     <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\ConversionResult.h">
       <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
     </ClInclude>
@@ -381,5 +381,11 @@
     <ClInclude Include="Connector\Interface\Browser\Bridge\Send\GetSendSettings.h">
       <Filter>Connector\Interface\Browser\Bridge\Send</Filter>
     </ClInclude>
+    <ClInclude Include="Connector\Record\Collection\FinishProxy.h">
+      <Filter>Connector\Record\Collection</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Record\Collection\ProjectCollection.h">
+      <Filter>Connector\Record\Collection</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

SpeckleConnector/Connector.xcodeproj/project.pbxproj

@@ -29,8 +29,9 @@
 		215F082E2C94C5C000CD343B /* FilterMover.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F082C2C94C5C000CD343B /* FilterMover.cpp */; };
 		215F08372C95808B00CD343B /* ReceiverModelCard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08362C95808B00CD343B /* ReceiverModelCard.cpp */; };
 		215F08462C9633A800CD343B /* EverythingSendFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08452C9633A800CD343B /* EverythingSendFilter.cpp */; };
-		2192460D2CA3469D00CF5703 /* RootCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2192460B2CA3469D00CF5703 /* RootCollection.cpp */; };
+		2192460D2CA3469D00CF5703 /* ProjectCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2192460B2CA3469D00CF5703 /* ProjectCollection.cpp */; };
 		219F30422C769283009834E9 /* ConfigTests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219F30402C769282009834E9 /* ConfigTests.cpp */; };
+		21A0FB982CB723240023F24E /* FinishProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21A0FB942CB723240023F24E /* FinishProxy.cpp */; };
 		21AEF9EB2CAB56E5000B8681 /* SendError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9E32CAB56E5000B8681 /* SendError.cpp */; };
 		21AEF9EC2CAB56E5000B8681 /* SendViaBrowserArgs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9E52CAB56E5000B8681 /* SendViaBrowserArgs.cpp */; };
 		21AEF9EF2CAB5720000B8681 /* SendObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9EE2CAB5720000B8681 /* SendObject.cpp */; };
@@ -305,12 +306,14 @@
 		215F08452C9633A800CD343B /* EverythingSendFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EverythingSendFilter.cpp; sourceTree = "<group>"; };
 		215F084A2C9782F100CD343B /* ArchicadEverythingFilter.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ArchicadEverythingFilter.h; sourceTree = "<group>"; };
 		2161FD902BF2600C006D9527 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = README.md; sourceTree = "<group>"; };
-		2192460B2CA3469D00CF5703 /* RootCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RootCollection.cpp; sourceTree = "<group>"; };
-		2192460C2CA3469D00CF5703 /* RootCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RootCollection.h; sourceTree = "<group>"; };
+		2192460B2CA3469D00CF5703 /* ProjectCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProjectCollection.cpp; sourceTree = "<group>"; };
+		2192460C2CA3469D00CF5703 /* ProjectCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProjectCollection.h; sourceTree = "<group>"; };
 		219388682C4E5DE2002A0180 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
 		219F30352C768F0A009834E9 /* Connector-AC27-Test.bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "Connector-AC27-Test.bundle"; sourceTree = BUILT_PRODUCTS_DIR; };
 		219F30402C769282009834E9 /* ConfigTests.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 4; path = ConfigTests.cpp; sourceTree = "<group>"; };
 		219F30432C7693B6009834E9 /* Connector-AC27-Debug.xctestplan */ = {isa = PBXFileReference; lastKnownFileType = text; path = "Connector-AC27-Debug.xctestplan"; sourceTree = SOURCE_ROOT; };
+		21A0FB942CB723240023F24E /* FinishProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FinishProxy.cpp; sourceTree = "<group>"; };
+		21A0FB972CB723240023F24E /* FinishProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FinishProxy.h; sourceTree = "<group>"; };
 		21AEF9E32CAB56E5000B8681 /* SendError.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SendError.cpp; sourceTree = "<group>"; };
 		21AEF9E42CAB56E5000B8681 /* SendError.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SendError.h; sourceTree = "<group>"; };
 		21AEF9E52CAB56E5000B8681 /* SendViaBrowserArgs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SendViaBrowserArgs.cpp; sourceTree = "<group>"; };
@@ -1231,10 +1234,12 @@
 		21FF70482CA1A7F400AAD99A /* Collection */ = {
 			isa = PBXGroup;
 			children = (
+				21A0FB942CB723240023F24E /* FinishProxy.cpp */,
+				21A0FB972CB723240023F24E /* FinishProxy.h */,
 				21FF70462CA1A7F400AAD99A /* RecordCollection.cpp */,
 				21FF70472CA1A7F400AAD99A /* RecordCollection.h */,
-				2192460B2CA3469D00CF5703 /* RootCollection.cpp */,
-				2192460C2CA3469D00CF5703 /* RootCollection.h */,
+				2192460B2CA3469D00CF5703 /* ProjectCollection.cpp */,
+				2192460C2CA3469D00CF5703 /* ProjectCollection.h */,
 			);
 			path = Collection;
 			sourceTree = "<group>";
@@ -1456,11 +1461,12 @@
 				21B67CF72C78D4DE00FD64FC /* GetComplexType.cpp in Sources */,
 				21D0BDDC2C93897B0077E104 /* SenderModelCard.cpp in Sources */,
 				21B67CAE2C77329800FD64FC /* GetSourceApplicationVersion.cpp in Sources */,
+				21A0FB982CB723240023F24E /* FinishProxy.cpp in Sources */,
 				21B67CC32C77649F00FD64FC /* GetDocumentState.cpp in Sources */,
 				21D0BD602C89BFEA0077E104 /* SendBridge.cpp in Sources */,
 				21D0BD972C8F13F30077E104 /* GetSendFilters.cpp in Sources */,
 				21B67CAC2C77329800FD64FC /* BaseBridge.cpp in Sources */,
-				2192460D2CA3469D00CF5703 /* RootCollection.cpp in Sources */,
+				2192460D2CA3469D00CF5703 /* ProjectCollection.cpp in Sources */,
 				21D0BD6A2C8A0DB40077E104 /* GetIsDevMode.cpp in Sources */,
 				210CC8832C80E6A300610F58 /* TriggerEvent.cpp in Sources */,
 				21B67CEB2C78D27200FD64FC /* DocumentInfo.cpp in Sources */,

SpeckleConnector/Connector/ConnectorResource.h

@@ -28,6 +28,7 @@ enum StringResource {
 enum TitleString {
 	addonNameID = 1,
 	addonDescriptionID,
+	noStoreyID,
 };
 
 

SpeckleConnector/Connector/Interface/Browser/Bridge/Base/Arg/DocumentInfo.h

@@ -39,20 +39,20 @@ namespace connector::interfac::browser::bridge {
 		// MARK: - Serialisation
 		
 		/*!
-			Fill an inventory with the package items
-			@param inventory The inventory to receive the package items
-			@return True if the package has added items to the inventory
-		*/
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const override;
 		/*!
-			Get the specified cargo
-			@param item The inventory item to retrieve
-			@return The requested cargo (nullptr on failure)
-		*/
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
 		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
 		/*!
-			Set to the default package content
-		*/
+		 Set to the default package content
+		 */
 		void setDefault() override;
 	};
 

SpeckleConnector/Connector/Interface/Browser/Bridge/Send/Send.cpp

@@ -7,6 +7,7 @@
 #include "Connector/Database/ModelCardDatabase.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendViaBrowserArgs.h"
+#include "Connector/Record/Collection/ProjectCollection.h"
 #include "Speckle/Database/AccountDatabase.h"
 #include "Speckle/Database/Content/BIMRecord.h"
 #include "Speckle/Interface/Browser/Bridge/BrowserBridge.h"
@@ -23,6 +24,7 @@ using namespace speckle::record::element;
 
 using namespace active::serialise;
 using namespace connector::interfac::browser::bridge;
+using namespace connector::record;
 using namespace speckle::database;
 using namespace speckle::serialise;
 using namespace speckle::utility;
@@ -68,27 +70,20 @@ void Send::run(const String& modelCardID) const {
 					std::make_unique<SendError>(connector()->getLocalString(errorString, noProjectOpenID), modelCardID));
 		return;
 	}
-		//Collect targeted elements here
-
-	
-		//NB: This is a testing placeholder
-	
-	Element::Unique element;
-	if (auto project = connector::connector()->getActiveProject().lock(); project) {
-		auto elementDatabase = project->getElementDatabase();
-		auto selected = elementDatabase->getSelection();
-		for (const auto& link : selected)
-			if (element = elementDatabase->getElement(link); element)
-				break;
-	}
-	if (!element) {
+		//Build a collection from the selected elements
+	auto collection = std::make_unique<ProjectCollection>(project);
+	auto elementDatabase = project->getElementDatabase();
+	auto selected = elementDatabase->getSelection();
+	if (selected.empty()) {
 		getBridge()->sendEvent("setModelError",
 					std::make_unique<SendError>(connector()->getLocalString(errorString, noSelectedModelItemsID), modelCardID));
 		return;
 	}
-	
-	
+	for (const auto& link : selected) {
+		if (auto element = elementDatabase->getElement(link); element)
+			collection->addElement(*element);
+	}
 		//Send the collected information
-	auto result = std::make_unique<SendViaBrowserArgs>(*modelCard, *account, SendObject{std::move(element)});	//NB: Using a placeholder object for now
+	auto result = std::make_unique<SendViaBrowserArgs>(*modelCard, *account, SendObject{std::move(collection)});
 	getBridge()->sendEvent("sendByBrowser", std::move(result));
 } //Send::run

SpeckleConnector/Connector/Record/Collection/FinishProxy.cpp

@@ -0,0 +1,66 @@
+#include "Connector/Record/Collection/FinishProxy.h"
+
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+
+#include <array>
+
+using namespace active::serialise;
+using namespace connector::record;
+using namespace speckle::utility;
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		materialID,
+		linkedMeshID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"value"},
+		Identity{"objects"},
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+ 
+	inventory: The inventory to receive the package items
+ 
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool FinishProxy::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[materialID], materialID, element },
+			{ fieldID[linkedMeshID], linkedMeshID, m_meshID.size(), std::nullopt },
+		},
+	}.withType(&typeid(FinishProxy)));
+	return true;
+} //FinishProxy::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique FinishProxy::getCargo(const active::serialise::Inventory::Item& item) const {
+	if (item.ownerType != &typeid(FinishProxy))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case materialID:
+			return std::make_unique<PackageWrap>(m_finish);
+		case linkedMeshID:
+			return std::make_unique<ContainerWrap<std::vector<active::utility::Guid>>>(m_meshID);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //FinishProxy::getCargo

SpeckleConnector/Connector/Record/Collection/FinishProxy.h

@@ -0,0 +1,50 @@
+#ifndef CONNECTOR_RECORD_COLLECTION_MATERIAL_PROXY
+#define CONNECTOR_RECORD_COLLECTION_MATERIAL_PROXY
+
+#include "Active/Serialise/Package/Package.h"
+#include "Speckle/Record/Attribute/Finish.h"
+#include "Speckle/Utility/String.h"
+
+namespace connector::record {
+	
+	/*!
+	 A proxy record binding a surface finishes to meshes
+	 */
+	class FinishProxy : public active::serialise::Package {
+	public:
+				
+		// MARK: - Constructors
+		
+		/*!
+			Constructor
+			@param finish The proxy surface finish
+			@param meshID The list of mesh IDs the finish is applied to
+		*/
+		FinishProxy(const speckle::record::attribute::Finish& finish, const std::unordered_set<active::utility::Guid>& meshID) :
+				m_finish{finish} { std::copy(meshID.begin(), meshID.end(), std::back_inserter(m_meshID)); }
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		
+	private:
+			///The proxy surface finish
+		speckle::record::attribute::Finish m_finish;
+			///The list of mesh IDs the finish is applied to
+		std::vector<active::utility::Guid> m_meshID;
+	};
+
+}
+
+#endif	//CONNECTOR_RECORD_COLLECTION_MATERIAL_PROXY

SpeckleConnector/Connector/Record/Collection/ProjectCollection.cpp

@@ -0,0 +1,191 @@
+#include "Connector/Record/Collection/ProjectCollection.h"
+
+#include "Active/Serialise/CargoHold.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Connector/Connector.h"
+#include "Connector/ConnectorResource.h"
+#include "Connector/Record/Collection/FinishProxy.h"
+#include "Speckle/Database/BIMAttributeDatabase.h"
+#include "Speckle/Database/BIMElementDatabase.h"
+#include "Speckle/Record/Element/Element.h"
+
+#ifdef ARCHICAD
+#include <ModelMaterial.hpp>
+#endif
+
+using namespace active::serialise;
+using namespace connector::record;
+using namespace speckle::database;
+using namespace speckle::record::attribute;
+using namespace speckle::utility;
+
+#ifdef ARCHICAD
+namespace connector::record {
+	class ProjectCollection::FinishCache : public std::unordered_map<active::utility::Guid, Finish::Unique> {};
+}
+#endif
+
+namespace {
+
+		///Serialisation fields
+	enum FieldIndex {
+		finishProxyID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"renderMaterialProxies"},
+	};
+
+	using WrappedProxy = CargoHold<PackageWrap, FinishProxy>;
+
+}
+
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	project: The source project
+  --------------------------------------------------------------------*/
+ProjectCollection::ProjectCollection(speckle::environment::Project::Shared project) : base{project->getInfo().name, project} {
+	m_finishes = std::make_unique<FinishCache>();
+} //ProjectCollection::ProjectCollection
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+ProjectCollection::~ProjectCollection() {
+} //ProjectCollection::~ProjectCollection
+
+
+/*--------------------------------------------------------------------
+	Add an element to the collection hierarchy
+ 
+	index The index of the element to add
+
+	return: True if the element was added (false typically means the element already exists)
+  --------------------------------------------------------------------*/
+bool ProjectCollection::addElement(const speckle::database::BIMIndex& index) {
+		//Lookup the element in the element database of the active project
+	auto elementDbase = m_project->getElementDatabase();
+	if (elementDbase == nullptr)
+		return false;
+	if (auto element = elementDbase->getElement(index); element) {
+		addElement(*element);	//Add the element to the collection hierarchy
+		return true;
+	}
+	return false;
+} //ProjectCollection::addElement
+
+
+/*--------------------------------------------------------------------
+	Add an element to the collection hierarchy
+ 
+	element: The element to add
+ 
+	return: True if the element was added (false typically means the element already exists)
+  --------------------------------------------------------------------*/
+bool ProjectCollection::addElement(const speckle::record::element::Element& element) {
+	std::vector<String> collectionNames;
+		//The first collection hierarchy level is the element storey/level
+	auto storey = element.getStorey();
+	collectionNames.emplace_back(storey ? storey->getName() : connector()->getLocalString(titleString, noStoreyID));
+		//The next level is the name of the element type
+	collectionNames.emplace_back(element.getTypeName());
+		//Add any future levels here as required
+	RecordCollection* collection = this;
+	for (const auto& childName : collectionNames)
+		collection = collection->getChild(childName);
+	return collection->addIndex(BIMIndex{element.getBIMID(), element.getTableID()});
+} //ProjectCollection::addElement
+
+
+/*--------------------------------------------------------------------
+	Add a material proxy record to the collection
+ 
+	materialIndex: The index of the material to add
+	objectID: The object the material is applied to
+ 
+	return: True if the material proxy was added (false typically means the record already exists)
+  --------------------------------------------------------------------*/
+bool ProjectCollection::addMaterialProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) {
+	auto iter = m_finishProxies.find(materialIndex);
+	if (iter == m_finishProxies.end())
+		iter = m_finishProxies.insert({materialIndex, {}}).first;
+	return iter->second.insert(objectID).second;
+} //ProjectCollection::addMaterialProxy
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Add a ModelerAPI material to the collection (NB: These are not persistent so need to be captured by this method)
+ 
+	material: A material
+	objectID: The object the material is applied to
+ 
+	return: True if the material proxy was added (false typically means the record already exists)
+  --------------------------------------------------------------------*/
+bool ProjectCollection::addMaterialProxy(const ModelerAPI::Material& material, const speckle::database::BIMRecordID& objectID) {
+	auto finishID = Guid::fromInt(material.GenerateHashValue());
+	if (m_finishes->find(finishID) != m_finishes->end())
+		return false;
+	auto finish = std::make_unique<Finish>(material);
+	return m_finishes->insert({finishID, std::move(finish)}).second;
+} //ProjectCollection::addMaterialProxy
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+ 
+	inventory: The inventory to receive the package items
+ 
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool ProjectCollection::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	base::fillInventory(inventory);
+	inventory.merge(Inventory{
+		{
+			{ Identity{fieldID[finishProxyID]}, finishProxyID, m_finishProxies.size(), std::nullopt },
+		},
+	}.withType(&typeid(ProjectCollection)));
+	return true;
+} //ProjectCollection::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique ProjectCollection::getCargo(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(ProjectCollection))
+		return base::getCargo(item);
+	using namespace active::serialise;
+		//TODO: This is only currently coded to write collection content - reading can be added as required in future
+	switch (item.index) {
+		case finishProxyID: {
+			if (item.available < m_finishProxies.size()) {
+				auto iter = m_finishProxies.begin();
+				std::advance(iter, item.available);
+				const Finish* finish = nullptr;
+				if (auto fin = m_finishes->find(iter->first); fin != m_finishes->end())
+					finish = fin->second.get();
+				else if (auto attribute = m_project->getAttributeDatabase()->getAttribute(iter->first, iter->first.tableID); attribute)
+					finish = dynamic_cast<const Finish*>(attribute.get());
+				if (finish != nullptr) {
+					auto proxy = std::make_unique<FinishProxy>(*finish, iter->second);
+					return std::make_unique<WrappedProxy>(std::move(proxy));
+				}
+			}
+			break;
+		}
+		default:
+			break;
+	}
+	return nullptr;	//Requested an unknown index
+} //ProjectCollection::getCargo

SpeckleConnector/Connector/Record/Collection/ProjectCollection.h

@@ -0,0 +1,108 @@
+#ifndef CONNECTOR_RECORD_ROOT_COLLECTiON
+#define CONNECTOR_RECORD_ROOT_COLLECTiON
+
+#include "Connector/Record/Collection/RecordCollection.h"
+#include "Speckle/Serialise/Collection/FinishCollector.h"
+
+#include <stack>
+
+namespace speckle::record::element {
+	class Element;
+}
+
+namespace connector::record {
+	
+	/*!
+	 Root collection for sending a project model to a Speckle server
+	 
+	 Additional information is anticipated at the root level that will not apply at any other level in the container hierarchy, e.g.:
+	 - Classification hierarchy
+	 - Layers
+	 - Other attributes, e.g. materials
+	 Add all this supplementary data to the root container as required
+	 */
+	class ProjectCollection : public RecordCollection, public speckle::serialise::FinishCollector {
+	public:
+		
+		// MARK: - Types
+		
+		using base = RecordCollection;
+		
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param project The source project
+		 */
+		ProjectCollection(speckle::environment::Project::Shared project);
+		ProjectCollection(const ProjectCollection&) = delete;
+		/*!
+		 Destructor
+		 */
+		~ProjectCollection();
+		
+		using base::base;
+				
+		// MARK: - Functions (const)
+				
+		// MARK: - Functions (mutating)
+
+		/*!
+		 Add an element to the collection hierarchy
+		 @param index The index of the element to add
+		 @return True if the element was added (false typically means the element already exists)
+		 */
+		bool addElement(const speckle::database::BIMIndex& index);
+		/*!
+		 Add an element to the collection hierarchy
+		 @param element The element to add
+		 @return True if the element was added (false typically means the element already exists)
+		 */
+		bool addElement(const speckle::record::element::Element& element);
+		/*!
+		 Add a material proxy record to the collection
+		 @param materialIndex The index of the material to add
+		 @param objectID The object the material is applied to
+		 @return True if the material proxy was added (false typically means the record already exists)
+		 */
+		bool addMaterialProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) override;
+#ifdef ARCHICAD
+		/*!
+		 Add a ModelerAPI material to the collection (NB: These are not persistent so need to be captured by this method)
+		 @param material A material
+		 @param objectID The object the material is applied to
+		 @return True if the material proxy was added (false typically means the record already exists)
+		 */
+		bool addMaterialProxy(const ModelerAPI::Material& material, const speckle::database::BIMRecordID& objectID) override;
+#endif
+		
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		
+	private:
+		using FinishProxies = std::unordered_map<speckle::database::BIMIndex, std::unordered_set<active::utility::Guid>>;
+		
+			///Finish proxies accumulated from meshes generated from the collection elements
+		FinishProxies m_finishProxies;
+#ifdef ARCHICAD
+		class FinishCache;
+			///Finishes cached from ModelerAPI materials
+		std::unique_ptr<FinishCache> m_finishes;
+#endif
+	};
+	
+}
+
+#endif	//CONNECTOR_RECORD_ROOT_COLLECTiON

SpeckleConnector/Connector/Record/Collection/RecordCollection.cpp

@@ -1,11 +1,15 @@
 #include "Connector/Record/Collection/RecordCollection.h"
 
+#include "Active/Serialise/CargoHold.h"
 #include "Active/Serialise/Item/Wrapper/ValueWrap.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Speckle/Database/BIMElementDatabase.h"
 
 using namespace active::serialise;
 using namespace connector::record;
 using namespace speckle::database;
+using namespace speckle::environment;
+using namespace speckle::record::element;
 using namespace speckle::utility;
 
 #include <array>
@@ -16,18 +20,55 @@ namespace {
 	enum FieldIndex {
 		nameID,
 		elementID,
-		childrenID,
 	};
 
 		///Serialisation field IDs
 	static std::array fieldID = {
 		Identity{"name"},
-		Identity{"element"},
-		Identity{"child"},
+		Identity{"elements"},
 	};
 
+	using WrappedElement = CargoHold<PackageWrap, Element>;
+
 }
 
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	name: The collection name
+	project: The source project
+  --------------------------------------------------------------------*/
+RecordCollection::RecordCollection(const speckle::utility::String& name, Project::Shared project) : m_name{name}, m_project{project} {
+} //RecordCollection::RecordCollection
+
+
+/*--------------------------------------------------------------------
+	Get a child collection by name (adding if missing)
+ 
+	name: The child name
+ 
+	return: A pointer to the requested child (nullptr on failure, caller does not take ownership)
+  --------------------------------------------------------------------*/
+RecordCollection* RecordCollection::getChild(const speckle::utility::String& name) {
+		//Return an existing child if possible
+	if (auto iter = m_children.find(name); iter != m_children.end())
+		return &iter->second;
+		//Otherwise insert and return a new collection with the requested name
+	return &m_children.insert({name, RecordCollection{name, m_project}}).first->second;
+} //RecordCollection::getChild
+
+
+/*--------------------------------------------------------------------
+	Add an index to the collection
+ 
+	index: The index to add
+ 
+	return: True if the index was added (false typically means the index already exists)
+  --------------------------------------------------------------------*/
+bool RecordCollection::addIndex(const speckle::database::BIMIndex& index) {
+	return m_indices.insert(index).second;
+} //RecordCollection::addIndex
+
 
 /*--------------------------------------------------------------------
 	Fill an inventory with the package items
@@ -36,13 +77,13 @@ namespace {
  
 	return: True if the package has added items to the inventory
   --------------------------------------------------------------------*/
-bool RecordCollection::fillInventory(Inventory& inventory) const {
+bool RecordCollection::fillInventory(active::serialise::Inventory& inventory) const {
 	using enum Entry::Type;
+	base::fillInventory(inventory);
 	inventory.merge(Inventory{
 		{
-			{ fieldID[nameID], nameID, element },
-			{ fieldID[elementID], elementID, base::size(), std::nullopt, !base::empty() },
-			{ fieldID[childrenID], childrenID, m_children.size(), std::nullopt, !m_children.empty() },
+			{ Identity{fieldID[nameID]}, nameID, element },
+			{ Identity{fieldID[elementID]}, elementID, m_children.size() + m_indices.size(), std::nullopt },
 		},
 	}.withType(&typeid(RecordCollection)));
 	return true;
@@ -58,18 +99,29 @@ bool RecordCollection::fillInventory(Inventory& inventory) const {
   --------------------------------------------------------------------*/
 Cargo::Unique RecordCollection::getCargo(const Inventory::Item& item) const {
 	if (item.ownerType != &typeid(RecordCollection))
-		return nullptr;
+		return base::getCargo(item);
 	using namespace active::serialise;
+		//TODO: This is only currently coded to write collection content - reading can be added as required in future
 	switch (item.index) {
 		case nameID:
 			return std::make_unique<StringWrap>(m_name);
-		case elementID:
-			return nullptr;	//TODO: Implement - need to interrogate BIM database for element and return as cargo
-		case childrenID:
-			if (item.available < m_children.size())
-				return std::make_unique<PackageWrap>(m_children[item.available]);
-			return nullptr;
+		case elementID: {
+			if (item.available < m_children.size()) {
+				auto iter = m_children.begin();
+				std::advance(iter, item.available);
+				return std::make_unique<PackageWrap>(iter->second);
+			}
+			auto index = item.available - m_children.size();
+			if (index < m_indices.size()) {
+				auto iter = m_indices.begin();
+				std::advance(iter, index);
+				if (auto element = m_project->getElementDatabase()->getElement(*iter, iter->tableID); element)
+					return std::make_unique<WrappedElement>(std::move(element));
+			}
+			break;
+		}
 		default:
-			return nullptr;	//Requested an unknown index
+			break;
 	}
+	return nullptr;	//Requested an unknown index
 } //RecordCollection::getCargo

SpeckleConnector/Connector/Record/Collection/RecordCollection.h

@@ -1,13 +1,18 @@
 #ifndef CONNECTOR_RECORD_RECORD_COLLECTiON
 #define CONNECTOR_RECORD_RECORD_COLLECTiON
 
-#include "Active/Container/Vector.h"
-#include "Active/Serialise/Package/Package.h"
-#include "Speckle/Database/Identity/RecordID.h"
+#include "Speckle/Database/Content/Record.h"
+#include "Speckle/Database/Identity/BIMIndex.h"
+#include "Speckle/Environment/Project.h"
 #include "Speckle/Utility/String.h"
 
+#include <unordered_set>
+#include <unordered_map>
+
 namespace connector::record {
 	
+	class ProjectCollection;
+	
 	/*!
 	 Container for a collection of elements (and potentially tables of associated attributes) for Speckle commits
 	 
@@ -26,43 +31,38 @@ namespace connector::record {
 	 
 	 Note that the serialisation is currently implemented for sending only. Receive can be added as required
 	 */
-	class RecordCollection : public std::vector<speckle::database::RecordID>, public active::serialise::Package {
+	class RecordCollection : public speckle::database::Record {
 	public:
-		
+
 		// MARK: - Types
-		
-		using base = std::vector<speckle::database::RecordID>;
-		using Children = std::vector<RecordCollection>;
-		
+
+		using base = speckle::database::Record;
+
 		// MARK: - Constructors
 		
-		using base::base;
+		/*!
+		 Destructor
+		 */
+		~RecordCollection() {}
 				
 		// MARK: - Functions (const)
 		
+		/*!
+		 Get the speckle type identifier
+		 @return The speckle type (relevant objects should override as required, but "Base" is still considered a type on its own)
+		 */
+		speckle::utility::String getSpeckleType() const override { return "Speckle.Core.Models.Collections.Collection"; }
 		/*!
 		 Get the container name
 		 @return The container name
 		 */
 		const speckle::utility::String& getName() const { return m_name; }
 		/*!
-		 Get the child collections
-		 @return The child collections nested under this collection
+		 Find a child by name
+		 @param name The required child name
+		 @return A pointer to the requested child (nullptr if not found)
 		 */
-		const Children& getChildren() const;
-				
-		// MARK: - Functions (mutating)
-		
-		/*!
-		 Set the container name
-		 @param name The container name
-		 */
-		void setName(const speckle::utility::String& name) { m_name = name; }
-		/*!
-		 Add a child collection
-		 @param child The child collection to add
-		 */
-		void addChild(RecordCollection&& child);
+		RecordCollection* findChild(const speckle::utility::String& name) const;
 		
 		// MARK: - Serialisation
 		
@@ -70,20 +70,51 @@ namespace connector::record {
 		 Fill an inventory with the package items
 		 @param inventory The inventory to receive the package items
 		 @return True if the package has added items to the inventory
-		*/
+		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const override;
 		/*!
 		 Get the specified cargo
 		 @param item The inventory item to retrieve
 		 @return The requested cargo (nullptr on failure)
-		*/
+		 */
 		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
 		
 	private:
-			///Child nodes of this collection
-		Children m_children;
+		friend ProjectCollection;
+
+		// MARK: - Types
+		
+		using Indices = std::unordered_set<speckle::database::BIMIndex>;
+		using Children = std::unordered_map<speckle::utility::String, RecordCollection>;
+
+		/*!
+		 Constructor
+		 @param name The collection name
+		 @param project The source project
+		 */
+		RecordCollection(const speckle::utility::String& name, speckle::environment::Project::Shared project);
+		
+		/*!
+		 Get a child collection by name (adding if missing)
+		 @param name The child name
+		 @return A pointer to the requested child (nullptr on failure, caller does not take ownership)
+		 */
+		RecordCollection* getChild(const speckle::utility::String& name);
+		/*!
+		 Add an index to the collection
+		 @param index The index to add
+		 @return True if the index was added (false typically means the index already exists)
+		 */
+		bool addIndex(const speckle::database::BIMIndex& index);
+		
+			///The source project for the collection
+		speckle::environment::Project::Shared m_project;
 			///The collection name
 		speckle::utility::String m_name;
+			///Child nodes of this collection
+		Children m_children;
+			///Indices of records in this collection
+		Indices m_indices;
 	};
 	
 }

SpeckleConnector/Connector/Record/Collection/RootCollection.cpp

@@ -1,34 +0,0 @@
-#include "Connector/Record/Collection/RootCollection.h"
-
-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-
-using namespace active::serialise;
-using namespace connector::record;
-using namespace speckle::database;
-using namespace speckle::utility;
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the package items
- 
-	inventory: The inventory to receive the package items
- 
-	return: True if the package has added items to the inventory
-  --------------------------------------------------------------------*/
-bool RootCollection::fillInventory(Inventory& inventory) const {
-		//Extend with supplementary data as required
-	return base::fillInventory(inventory);
-} //RootCollection::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
- 
-	item: The inventory item to retrieve
- 
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique RootCollection::getCargo(const Inventory::Item& item) const {
-		//Extend with supplementary data as required
-	return base::getCargo(item);
-} //RootCollection::getCargo

SpeckleConnector/Connector/Record/Collection/RootCollection.h

@@ -1,52 +0,0 @@
-#ifndef CONNECTOR_RECORD_ROOT_COLLECTiON
-#define CONNECTOR_RECORD_ROOT_COLLECTiON
-
-#include "Connector/Record/Collection/RecordCollection.h"
-
-namespace connector::record {
-	
-	/*!
-	 Root container for sending model data to a Speckle server
-	 
-	 Additional information is anticipated at the root level that will not apply at any other level in the container hierarchy, e.g.:
-	 - Classification hierarchy
-	 - Layers
-	 - Other attributes, e.g. materials
-	 Add all this supplementary data to the root container as required
-	 */
-	class RootCollection : public RecordCollection {
-	public:
-		
-		// MARK: - Types
-		
-		using base = RecordCollection;
-		
-		// MARK: - Constructors
-		
-		using base::base;
-				
-		// MARK: - Functions (const)
-		
-				
-		// MARK: - Functions (mutating)
-		
-		
-		// MARK: - Serialisation
-		
-		/*!
-		 Fill an inventory with the package items
-		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
-		*/
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-		 Get the specified cargo
-		 @param item The inventory item to retrieve
-		 @return The requested cargo (nullptr on failure)
-		*/
-		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-	};
-	
-}
-
-#endif	//CONNECTOR_RECORD_ROOT_COLLECTiON

SpeckleConnector/RINT/Connector.grc

@@ -1,6 +1,7 @@
 'STR#' 32600 "Title strings" {
 /* [  1] */		"Speckle Connector"
 /* [  2] */		"Connector to share model content with Speckle"
+/* [  3] */		"No level"
 }
 
 'STR#' 32604 "Error strings" {

SpeckleLib/RINT/Speckle.grc

@@ -1,3 +1,4 @@
 'STR#' 32700 "Speckle Title strings" {
 /* [  1] */		"Untitled"
+/* [  2] */		"Unknown"
 }

SpeckleLib/Speckle/Database/BIMAttributeDatabase.cpp

@@ -0,0 +1,155 @@
+#include "Speckle/Database/BIMAttributeDatabase.h"
+
+#include "Active/Database/Storage/Storage.h"
+#include "Active/Serialise/UnboxedTransport.h"
+#include "Speckle/Database/Identity/RecordID.h"
+#include "Speckle/Database/Storage/ArchicadDBase/Attribute/ArchicadAttributeDBaseEngine.h"
+#include "Speckle/Record/Attribute/Attribute.h"
+
+#include <array>
+
+using namespace active::container;
+using namespace active::database;
+using namespace active::event;
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::record;
+using namespace speckle::record::attribute;
+using namespace speckle::database;
+using namespace speckle::utility;
+
+namespace speckle::database {
+	
+	///Define other platform engines here as required
+#ifdef ARCHICAD
+	using AttributeDatabaseEngine = ArchicadAttributeDBaseEngine;
+#endif
+
+		///Attribute database engine declaration
+	class BIMAttributeDatabase::Engine : public AttributeDatabaseEngine {
+		using base = ArchicadAttributeDBaseEngine;
+		using base::base;
+	};
+
+		///Attribute database storage declaration
+	class BIMAttributeDatabase::Store : public Storage<Attribute, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID> {
+		using base = Storage<Attribute, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID>;
+		using base::base;
+	};
+	
+}
+
+namespace {
+	
+		///The database storage identifier for attributes
+	const char* attributeDBaseName = "speckle::database::BIMAttributeDatabase";
+		///The primary model table, e.g. floor plan in Archicad
+	const char* modelTableName = "Model";
+
+}
+
+/*--------------------------------------------------------------------
+	Constructor
+  --------------------------------------------------------------------*/
+BIMAttributeDatabase::BIMAttributeDatabase() {
+	m_engine = std::make_shared<Engine>(attributeDBaseName,
+			//Schema
+		 DBaseSchema{active::utility::String{attributeDBaseName},
+				//Tables
+			{
+					//Model attribute table
+				{
+					modelTableName, 0, 0, {}	//The primary model. Additonal tables could be linked to other drawings/layouts in future
+				}
+			}
+		}
+	);
+	m_store = std::make_shared<Store>(m_engine);
+} //BIMAttributeDatabase::BIMAttributeDatabase
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+BIMAttributeDatabase::~BIMAttributeDatabase() {}
+
+
+/*--------------------------------------------------------------------
+	Get a specified attribute
+ 
+	attributeID: The ID of the target attribute
+ 
+	return: The requested attribute (nullptr on failure)
+  --------------------------------------------------------------------*/
+Attribute::Unique BIMAttributeDatabase::getAttribute(const BIMRecordID& attributeID, std::optional<BIMRecordID> tableID,
+											   std::optional<BIMRecordID> documentID) const {
+	return m_engine->getObject(attributeID, tableID, documentID);
+} //BIMAttributeDatabase::getAttribute
+
+
+/*--------------------------------------------------------------------
+	Get all attributes
+ 
+	return: All the attributes
+  --------------------------------------------------------------------*/
+Vector<Attribute> BIMAttributeDatabase::getAttributes() const {
+	return m_store->getObjects();
+} //BIMAttributeDatabase::getAttributes
+
+
+/*--------------------------------------------------------------------
+	Write an attribute to storage
+ 
+	attribute: The attribute to write
+  --------------------------------------------------------------------*/
+void BIMAttributeDatabase::write(const Attribute& attribute) const {
+	m_store->write(attribute);
+} //BIMAttributeDatabase::write
+
+
+/*--------------------------------------------------------------------
+	Erase an attribute
+ 
+	attributeID: The ID of the attribute to erase
+  --------------------------------------------------------------------*/
+void BIMAttributeDatabase::erase(const Guid& attributeID) const {
+	m_store->erase(attributeID);
+} //BIMAttributeDatabase::erase
+
+		
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get attribute data direct from the AC API. For internal use - avoid direct use
+ 
+	link: A link to the required attribute
+ 
+	return: The AC API attribute data
+  --------------------------------------------------------------------*/
+std::optional<API_Attribute> BIMAttributeDatabase::getAPIData(const BIMLink& link) const {
+	return m_engine->getAPIData(link);
+} //BIMAttributeDatabase::getAPIData
+
+
+/*--------------------------------------------------------------------
+	Get storey data direct from the AC API. For internal use - avoid direct use
+ 
+	link: A link to the required storey
+ 
+	return: The AC API storey data
+  --------------------------------------------------------------------*/
+std::optional<API_StoryType> BIMAttributeDatabase::getAPIStorey(const BIMLink& link) const {
+	return m_engine->getAPIStorey(link);
+} //BIMAttributeDatabase::getAPIData
+
+
+/*--------------------------------------------------------------------
+	Get the ID of a storey from a specified index
+ 
+	index: The storey index
+ 
+	return: The storey ID (nullopt on failure)
+  --------------------------------------------------------------------*/
+std::optional<BIMRecordID> BIMAttributeDatabase::getStoreyID(short index) const {
+	return m_engine->getStoreyID(index);
+} //BIMAttributeDatabase::getStoreyID
+#endif

SpeckleLib/Speckle/Database/BIMAttributeDatabase.h

@@ -0,0 +1,101 @@
+#ifndef CONNECTOR_DATABASE_BIM_ATTRIBUTE_DATABASE
+#define CONNECTOR_DATABASE_BIM_ATTRIBUTE_DATABASE
+
+#include "Speckle/Database/Identity/BIMLink.h"
+#include "Speckle/Record/Attribute/Attribute.h"
+#include "Speckle/Utility/Guid.h"
+
+namespace active::event {
+	class Subscriber;
+}
+
+namespace speckle::database {
+	
+	/*!
+	 Database of model attributes relating to a specific project
+	 */
+	class BIMAttributeDatabase {
+	public:
+
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 */
+		BIMAttributeDatabase();
+		BIMAttributeDatabase(const BIMAttributeDatabase&) = delete;
+		/*!
+		 Destructor
+		 */
+		~BIMAttributeDatabase();
+		
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get the current user attribute selection
+		 @return A list of selected attribute IDs
+		 */
+		BIMLinkList getSelection() const;
+		/*!
+		 Get a specified attribute
+		 @param attributeID The ID of the target attribute
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (when the object is bound to a specific document)
+		 @return The requested attribute (nullptr on failure)
+		 */
+		record::attribute::Attribute::Unique getAttribute(const BIMRecordID& attributeID, std::optional<BIMRecordID> tableID = std::nullopt,
+													std::optional<BIMRecordID> documentID = std::nullopt) const;
+		/*!
+		 Get a specified attribute
+		 @param link A link to the target attribute
+		 @return The requested attribute (nullptr on failure)
+		 */
+		record::attribute::Attribute::Unique getAttribute(const BIMLink& link) const { return getAttribute(link, link.tableID, link.docID); }
+		/*!
+		 Get all model attributes
+		 @return All the attributes
+		 */
+		active::container::Vector<record::attribute::Attribute> getAttributes() const;
+		/*!
+		 Write an attribute to storage
+		 @param attribute The attribute to write
+		 */
+		void write(const record::attribute::Attribute& attribute) const;
+		/*!
+		 Erase an attribute
+		 @param attributeID The ID of the attribute to erase
+		 */
+		void erase(const speckle::utility::Guid& attributeID) const;
+		
+#ifdef ARCHICAD
+		/*!
+		 Get attribute data direct from the AC API. For internal use - avoid direct use
+		 @param link A link to the required attribute
+		 @return The AC API attribute data
+		 */
+		std::optional<API_Attribute> getAPIData(const BIMLink& link) const;
+		/*!
+		 Get storey data direct from the AC API. For internal use - avoid direct use
+		 @param link A link to the required storey
+		 @return The AC API storey data
+		 */
+		std::optional<API_StoryType> getAPIStorey(const BIMLink& link) const;
+		/*!
+		 Get the ID of a storey from a specified index
+		 @param index The storey index
+		 @return The storey ID (nullopt on failure)
+		 */
+		std::optional<BIMRecordID> getStoreyID(short index) const;
+#endif
+		
+	private:
+		class Engine;
+		class Store;
+			///Model attribute database storage
+		std::shared_ptr<Engine> m_engine;
+		std::shared_ptr<Store> m_store;
+	};
+
+}
+
+#endif	//CONNECTOR_DATABASE_BIM_ATTRIBUTE_DATABASE

SpeckleLib/Speckle/Database/BIMElementDatabase.h

@@ -1,5 +1,5 @@
-#ifndef CONNECTOR_DATABASE_BIM_DATABASE
-#define CONNECTOR_DATABASE_BIM_DATABASE
+#ifndef CONNECTOR_DATABASE_BIM_ELEMENT_DATABASE
+#define CONNECTOR_DATABASE_BIM_ELEMENT_DATABASE
 
 #include "Speckle/Database/Identity/BIMLink.h"
 #include "Speckle/Record/Element/Element.h"
@@ -77,4 +77,4 @@ namespace speckle::database {
 
 }
 
-#endif	//CONNECTOR_DATABASE_BIM_DATABASE
+#endif	//CONNECTOR_DATABASE_BIM_ELEMENT_DATABASE

SpeckleLib/Speckle/Database/Content/BIMRecord.cpp

@@ -1,5 +1,7 @@
 #include "Speckle/Database/Content/BIMRecord.h"
 
+#include "Active/Serialise/Item/Wrapper/ValueOptionWrap.h"
+#include "Speckle/Serialise/Units/LengthUnit.h"
 #include "Speckle/Utility/Guid.h"
 
 #include <array>
@@ -8,16 +10,20 @@ using namespace active::serialise;
 using namespace speckle::database;
 using namespace speckle::utility;
 
+using enum active::measure::LengthType;
+
 namespace {
 
 		///Serialisation fields
 	enum FieldIndex {
 		applicID,
+		unitID,
 	};
 
 		///Serialisation field IDs
 	static std::array fieldID = {
 		Identity{"applicationId"},
+		Identity{"unit"},
 	};
 
 }
@@ -33,7 +39,8 @@ bool BIMRecord::fillInventory(Inventory& inventory) const {
 	using enum Entry::Type;
 	inventory.merge(Inventory{
 		{
-			{ Identity{fieldID[applicID]}, applicID, element },
+			{ Identity{fieldID[applicID]}, applicID, element, !m_applicationID.empty() },
+			{ Identity{fieldID[unitID]}, unitID, element, m_unit.operator bool() },
 		},
 	}.withType(&typeid(BIMRecord)));
 	return base::fillInventory(inventory);
@@ -54,7 +61,18 @@ Cargo::Unique BIMRecord::getCargo(const Inventory::Item& item) const {
 	switch (item.index) {
 		case applicID:
 			return std::make_unique<ValueWrap<BIMRecordID>>(m_applicationID);
+		case unitID:
+			return std::make_unique<ValueOptionWrap<active::measure::LengthType>>(m_unit);
 		default:
 			return nullptr;	//Requested an unknown index
 	}
 } //BIMRecord::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void BIMRecord::setDefault() {
+	m_applicationID.clear();
+	m_unit.reset();
+} //BIMRecord::setDefault

SpeckleLib/Speckle/Database/Content/BIMRecord.h

@@ -1,8 +1,10 @@
 #ifndef SPECKLE_DATABASE_BIM_RECORD
 #define SPECKLE_DATABASE_BIM_RECORD
 
+#include "Active/Setting/Values/Measurement/Units/LengthUnit.h"
 #include "Speckle/Database/Content/Record.h"
-#include "Speckle/Database/Identity/Link.h"
+#include "Speckle/Database/Identity/BIMIndex.h"
+#include "Speckle/Database/Identity/BIMLink.h"
 #include "Speckle/Database/Identity/BIMRecordID.h"
 
 namespace speckle::database {
@@ -27,13 +29,18 @@ namespace speckle::database {
 		
 		/*!
 		 Default constructor
+		 @param unit The recordc unit type
 		 */
-		BIMRecord() : base{} {}
+		BIMRecord(active::measure::LengthType unit = active::measure::LengthType::metre) : base{}, m_unit{unit} {}
 		/*!
 		 Constructor
 		 @param ID The record ID
+		 @param tableID The parent table ID
+		 @param unit The record unit type
 		 */
-		BIMRecord(speckle::utility::Guid ID) : base{}, m_applicationID{ID} {}
+		BIMRecord(const speckle::utility::Guid& ID, const speckle::utility::Guid& tableID,
+				  active::measure::LengthType unit = active::measure::LengthType::metre) :
+				base{}, m_applicationID{ID}, m_applicationTableID{tableID}, m_unit{unit} {}
 		/*!
 		 Destructor
 		 */
@@ -46,6 +53,16 @@ namespace speckle::database {
 		 @return The BIM application ID
 		 */
 		BIMRecordID getBIMID() const { return m_applicationID; }
+		/*!
+		 Get the BIM application parent table ID
+		 @return The BIM table ID
+		 */
+		BIMRecordID getTableID() const { return m_applicationTableID; }
+		/*!
+		 Get a link to the BIM record
+		 @return The BIM record link
+		 */
+		BIMLink getBIMLink() const { return BIMLink{ BIMLink::base{m_applicationID, m_applicationTableID} }; }
 		
 		// MARK: - Functions (mutating)
 
@@ -54,25 +71,48 @@ namespace speckle::database {
 		 @param ID The BIM application ID
 		 */
 		void setBIMID(const BIMRecordID& ID) { m_applicationID = ID; }
+		/*!
+		 Set the BIM application parent table ID
+		 @param tableID The BIM table ID
+		 */
+		void setTableID(const BIMRecordID& tableID) { m_applicationTableID = tableID; }
 		
 		// MARK: - Serialisation
 		
 		/*!
-			Fill an inventory with the package items
-			@param inventory The inventory to receive the package items
-			@return True if the package has added items to the inventory
-		*/
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const override;
 		/*!
-			Get the specified cargo
-			@param item The inventory item to retrieve
-			@return The requested cargo (nullptr on failure)
-		*/
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
 		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+
+	protected:
+		/*!
+		 Reset the BIM index (used in lazy loading contexts where the index cannot otherwise be established)
+		 @param index The BIM application index
+		 */
+		void resetIndex(const BIMIndex& index) const {
+			m_applicationID = index;
+			m_applicationTableID = index.tableID;
+		}
 		
 	private:
 			///The BIM application record ID
-		BIMRecordID m_applicationID;
+		mutable BIMRecordID m_applicationID;
+			///The BIM application parent table ID
+		mutable BIMRecordID m_applicationTableID;
+			///The BIM record unit of length measurement
+		std::optional<active::measure::LengthType> m_unit = active::measure::LengthType::metre;
 	};
 	
 }

SpeckleLib/Speckle/Database/Content/Record.cpp

@@ -35,7 +35,7 @@ bool Record::fillInventory(active::serialise::Inventory& inventory) const {
 	using enum Entry::Type;
 	inventory.merge(Inventory{
 		{
-			{ Identity{fieldID[speckleIDID]}, active::database::record::FieldIndex::idIndex, element },
+			{ Identity{fieldID[speckleIDID]}, active::database::record::FieldIndex::idIndex, element, !getID().empty() },
 		},
 	}.withType(&typeid(base)));
 	inventory.merge(Inventory{

SpeckleLib/Speckle/Database/Content/Record.h

@@ -31,8 +31,7 @@ namespace speckle::database {
 		 @param globID The global ID
 		 */
 		Record(speckle::utility::String::Option ID = std::nullopt, speckle::utility::String::Option globID = std::nullopt) :
-				base{ID.value_or(active::utility::Guid{true}.operator active::utility::String()),
-					globID.value_or(active::utility::Guid{true}.operator active::utility::String())} {}
+				base{ID.value_or(speckle::utility::String{}), globID.value_or(speckle::utility::String{})} {}
 		/*!
 		 Destructor
 		 */
@@ -44,7 +43,7 @@ namespace speckle::database {
 		 Get the speckle type identifier
 		 @return The speckle type (relevant objects should override as required, but "Base" is still considered a type on its own)
 		 */
-		virtual speckle::utility::String getSpeckleType() const { return "Base"; }
+		virtual speckle::utility::String getSpeckleType() const { return "speckle::database::Record"; }
 		
 		// MARK: - Functions (mutating)
 
@@ -52,16 +51,16 @@ namespace speckle::database {
 		// MARK: - Serialisation
 		
 		/*!
-			Fill an inventory with the package items
-			@param inventory The inventory to receive the package items
-			@return True if the package has added items to the inventory
-		*/
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const override;
 		/*!
-			Get the specified cargo
-			@param item The inventory item to retrieve
-			@return The requested cargo (nullptr on failure)
-		*/
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
 		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
 		/*!
 		 Set to the default package content

SpeckleLib/Speckle/Database/Identity/BIMIndex.h

@@ -2,7 +2,7 @@
 #define SPECKLE_DATABASE_BIM_INDEX
 
 #include "Active/Database/Identity/Index.h"
-#include "Speckle/Database/Identity/RecordID.h"
+#include "Speckle/Database/Identity/BIMRecordID.h"
 
 namespace speckle::database {
 	
@@ -13,25 +13,30 @@ namespace speckle::database {
 	 this is typically a guid, for Revit a string and for Vectorworks a handle. Note that this index is not necessarily persistent between
 	 sessions.
 	 */
-	class BIMIndex : public active::database::Index<BIMRecordID> {
+	class BIMIndex : public active::database::Index<BIMRecordID, BIMRecordID> {
 	public:
 
 		// MARK: - Types
 		
-		using base = active::database::Index<BIMRecordID>;
+		using base = active::database::Index<BIMRecordID, BIMRecordID>;
 
 		// MARK: - Constructors
 		
 		using base::base;
-		
-		// MARK: - Public variables
-		
-			//The table identifier
-		BIMTableID table;
-			//The document identifier
-		BIMDocID document;
 	};
 	
 }
 
+
+	///Hashing for BIMIndex class, e.g. to use as a key in unordered_map
+template<>
+struct std::hash<speckle::database::BIMIndex> {
+	std::size_t operator() (const speckle::database::BIMIndex& index) const {
+		std::size_t h1 = std::hash<active::utility::Guid>{}(index);
+		std::size_t h2 = std::hash<active::utility::Guid>{}(index.tableID);
+		return h1 ^ (h2 << 1);
+	}
+};
+
+
 #endif	//SPECKLE_DATABASE_BIM_INDEX

SpeckleLib/Speckle/Database/Identity/BIMLink.cpp

@@ -8,8 +8,9 @@ using namespace speckle::utility;
 	Constructor
  
 	selected: Information about a selected Archicad element
+	tableID: The ID of the parent table
   --------------------------------------------------------------------*/
-BIMLink::BIMLink(const API_Neig& selected) : base{Guid{selected.guid}} {
+BIMLink::BIMLink(const API_Neig& selected, const BIMRecordID& tableID) : base{Guid{selected.guid}, tableID} {
 	//More info should be extracted from API_Neig in future (as required) - extract into link settings, e.g. selection target etc
 } //Link::Link
 #endif

SpeckleLib/Speckle/Database/Identity/BIMLink.h

@@ -34,8 +34,9 @@ namespace speckle::database {
 		/*!
 		 Constructor
 		 @param selected Information about a selected Archicad element
+		 @param tableID The ID of the parent table
 		 */
-		BIMLink(const API_Neig& selected);
+		BIMLink(const API_Neig& selected, const BIMRecordID& tableID);
 #endif
 	};
 	

SpeckleLib/Speckle/Database/Storage/ArchicadDBase/Attribute/ArchicadAttributeDBaseEngine.cpp

@@ -0,0 +1,297 @@
+#include "Speckle/Database/Storage/ArchicadDBase/Attribute/ArchicadAttributeDBaseEngine.h"
+
+#ifdef ARCHICAD
+
+#include "Active/Utility/Defer.h"
+#include "Active/Utility/Memory.h"
+#include "Active/Utility/String.h"
+#include "Speckle/Record/Attribute/Finish.h"
+#include "Speckle/Record/Attribute/Storey.h"
+#include "Speckle/Database/Identity/BIMLink.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Environment/Project.h"
+#include "Speckle/Event/Type/DocStoreMergeEvent.h"
+#include "Speckle/Event/Type/ProjectEvent.h"
+#include "Speckle/Utility/Guid.h"
+#include "Speckle/Utility/String.h"
+
+#include <ACAPinc.h>
+#include <ACAPI_Database.h>
+#include <BM.hpp>
+
+using namespace active::event;
+using namespace active::setting;
+using namespace speckle::database;
+using namespace speckle::environment;
+using namespace speckle::event;
+using namespace speckle::record::attribute;
+using namespace speckle::utility;
+
+using enum ArchicadDBaseCore::Status;
+
+namespace speckle::database {
+	
+#ifdef ARCHICAD
+	/*!
+		A class to collect and manage a list of active Archicad storeys
+		NB: This list has to be rebuilt every time a storey has changed because Archicad reindexes storeys each time
+		This class also has to release memory used by the API to hold storey data
+	*/
+	class ArchicadAttributeDBaseEngine::StoreyCache : public std::vector<API_StoryType> {
+	public:
+		/*!
+			Constructor (NB: This automatically gathers information about the current storeys)
+		*/
+		StoreyCache() { rebuild(); }
+		
+		/*!
+			Rebuild the current storey list
+		*/
+		void rebuild() {
+			clear();
+			API_StoryInfo storeyInfo;
+			active::utility::Memory::erase(storeyInfo);
+			ACAPI_ProjectSetting_GetStorySettings(&storeyInfo);
+			auto storeyCount = storeyInfo.lastStory - storeyInfo.firstStory + 1;
+			for (auto i = 0; i < storeyCount; ++i)
+				push_back((*storeyInfo.data)[i]);
+			BMKillHandle(reinterpret_cast<GSHandle*>(&storeyInfo.data));
+		}
+		/*!
+			Find a storey by unique ID
+			@param id The storey unique ID
+			@return An iterator pointing to the found storey (end() on failure)
+		*/
+		const_iterator find(const Guid& id) const {
+			auto floorID = static_cast<short>(Guid::toInt(id));
+			return std::find_if(begin(), end(), [&](auto storey){ return storey.floorId == floorID; });
+		}
+		/*!
+			Find a storey by index
+			@param index The storey index
+			@return An iterator pointing to the found storey (end() on failure)
+		*/
+		const_iterator find(short index) const {
+			return std::find_if(begin(), end(), [&](auto storey){ return storey.index == index; });
+		}
+	};
+#endif
+	
+}
+
+namespace {
+	
+		///Attribute factory
+	std::unordered_map<active::utility::Guid, std::function<Attribute::Unique(API_Attribute, const active::utility::Guid&)>> attributeFactory;
+	
+#ifdef ARCHICAD
+	/*!
+	 Make a new attribute object
+	 @param attributeData The API attribute representation
+	 @return A new attribute object (nullptr on failure)
+	 */
+	Attribute::Unique makeAttribute(const API_Attribute& attributeData) {
+		auto tableID = active::utility::Guid::fromInt(static_cast<uint64_t>(attributeData.header.typeID));
+		if (attributeFactory.empty()) {
+			attributeFactory[active::utility::Guid::fromInt(static_cast<uint64_t>(attributeData.header.typeID))] =
+					[](API_Attribute attrData, const active::utility::Guid& tableID){ return std::make_unique<Finish>(attrData, tableID); };
+		}
+		if (auto iter = attributeFactory.find(tableID); iter != attributeFactory.end())
+			return iter->second(attributeData, tableID);
+		return nullptr;
+	}
+	
+	
+	/*!
+	 Get the AC API data for a specified attribute
+	 @param ID The attribute ID
+	 @param tableID The parent table ID
+	 @return A new attribute object (nullptr on failure)
+	 */
+	std::optional<API_Attribute> getAPIData(const BIMRecordID& ID, std::optional<BIMRecordID> tableID) {
+		API_Attribute attribute;
+		active::utility::Memory::erase(attribute);
+		attribute.header.index = ACAPI_CreateAttributeIndex(static_cast<int32_t>(Guid::toInt(ID)));
+		attribute.header.typeID = static_cast<API_AttrTypeID>(Guid::toInt(*tableID));
+		if (ACAPI_Attribute_Get(&attribute) != NoError)
+			return std::nullopt;
+		return attribute;
+	}
+#endif
+	
+}
+
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	id: The document storage identifier
+  --------------------------------------------------------------------*/
+ArchicadAttributeDBaseEngine::ArchicadAttributeDBaseEngine(const active::utility::NameID& id, ArchicadDBaseSchema&& schema) :
+		ArchicadDBaseCore{id, std::move(schema)} {
+} //ArchicadAttributeDBaseEngine::ArchicadAttributeDBaseEngine
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+ArchicadAttributeDBaseEngine::~ArchicadAttributeDBaseEngine() {
+} //ArchicadAttributeDBaseEngine::~ArchicadAttributeDBaseEngine
+
+
+/*--------------------------------------------------------------------
+	Get an object by ID
+ 
+	objID: The object index
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (when the object is bound to a specific document)
+ 
+	return: The requested object (nullptr on failure)
+  --------------------------------------------------------------------*/
+std::unique_ptr<Attribute> ArchicadAttributeDBaseEngine::getObject(const BIMRecordID& objID, std::optional<BIMRecordID> tableID,
+																   std::optional<BIMRecordID> documentID) const {
+	if (!tableID)
+		return nullptr;
+	if (auto attrData = ::getAPIData(objID, *tableID); attrData)
+		return makeAttribute(*attrData);
+	return nullptr;
+} //ArchicadAttributeDBaseEngine::getObject
+
+
+/*--------------------------------------------------------------------
+	Get an object in a transportable form, e.g. packaged for serialisation
+ 
+	index: The object index
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (when the object is bound to a specific document)
+ 
+	return: The requested wrapped cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+active::serialise::Cargo::Unique ArchicadAttributeDBaseEngine::getObjectCargo(const BIMRecordID& ID, std::optional<BIMRecordID> tableID,
+																		   std::optional<BIMRecordID> documentID)  const {
+	return nullptr; //TODO: Implement
+} //ArchicadAttributeDBaseEngine::getObject
+
+
+/*--------------------------------------------------------------------
+	Get all objects
+ 
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+ 
+	return: The requested objects (nullptr on failure)
+  --------------------------------------------------------------------*/
+active::container::Vector<Attribute> ArchicadAttributeDBaseEngine::getObjects(std::optional<BIMRecordID> tableID,
+																					  std::optional<BIMRecordID> documentID) const {
+	return {}; //TODO: Implement
+} //ArchicadAttributeDBaseEngine::getObjects
+
+
+/*--------------------------------------------------------------------
+	Get all objects
+ 
+	filter: The object filter
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+ 
+	return: The requested objects (nullptr on failure)
+  --------------------------------------------------------------------*/
+active::container::Vector<Attribute> ArchicadAttributeDBaseEngine::getObjects(const Filter& filter, std::optional<BIMRecordID> tableID,
+																					  std::optional<BIMRecordID> documentID) const {
+	return {}; //TODO: Implement
+} //ArchicadAttributeDBaseEngine::getObjects
+
+
+/*--------------------------------------------------------------------
+	Write an object to the database
+ 
+	object: The object to write
+	objID: The object ID
+	objDocID: The object document-specific ID (unique within a specific document - nullopt if not document-bound)
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (when the object is bound to a specific document)
+  --------------------------------------------------------------------*/
+void ArchicadAttributeDBaseEngine::write(const Attribute& object, const BIMRecordID& objID, std::optional<BIMRecordID> objDocID,
+																   std::optional<BIMRecordID> tableID, std::optional<BIMRecordID> documentID) const {
+		//TODO: Implement
+} //ArchicadAttributeDBaseEngine::write
+
+
+/*--------------------------------------------------------------------
+	Erase an object by index
+ 
+	objID: The object ID
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (when the object is bound to a specific document)
+ 
+	return: True if the object was successfully erased
+  --------------------------------------------------------------------*/
+void ArchicadAttributeDBaseEngine::erase(const BIMRecordID& ID, std::optional<BIMRecordID> tableID,
+													   std::optional<BIMRecordID> documentID) const {
+		//TODO: Implement
+} //ArchicadAttributeDBaseEngine::erase
+
+
+/*--------------------------------------------------------------------
+	Erase all objects
+ 
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+  --------------------------------------------------------------------*/
+void ArchicadAttributeDBaseEngine::erase(std::optional<BIMRecordID> tableID, std::optional<BIMRecordID> documentID) const {
+		//TODO: Implement
+} //ArchicadAttributeDBaseEngine::erase
+
+
+/*--------------------------------------------------------------------
+	Get the database outline
+ 
+	return: The database outline
+  --------------------------------------------------------------------*/
+ArchicadAttributeDBaseEngine::Outline ArchicadAttributeDBaseEngine::getOutline() const {
+	return {}; //TODO: Implement
+} //ArchicadAttributeDBaseEngine::getOutline
+
+
+/*--------------------------------------------------------------------
+	Get attribute data direct from the AC API. For internal use - avoid direct use
+ 
+	link: A link to the required attribute
+ 
+	return: The AC API attribute data
+  --------------------------------------------------------------------*/
+std::optional<API_Attribute> ArchicadAttributeDBaseEngine::getAPIData(const BIMLink& link) const {
+	return ::getAPIData(link, link.tableID);
+} //ArchicadAttributeDBaseEngine::getAPIData
+
+
+/*--------------------------------------------------------------------
+	Get storey data direct from the AC API. For internal use - avoid direct use
+ 
+	link: A link to the required storey
+ 
+	return: The AC API storey data
+  --------------------------------------------------------------------*/
+std::optional<API_StoryType> ArchicadAttributeDBaseEngine::getAPIStorey(const BIMLink& link) const {
+	if (!m_storeyCache)
+		m_storeyCache = std::make_unique<StoreyCache>();
+	if (auto iter = m_storeyCache->find(link); iter != m_storeyCache->end())
+		return *iter;
+	return std::nullopt;
+} //ArchicadAttributeDBaseEngine::getAPIStorey
+
+
+/*--------------------------------------------------------------------
+	Get the ID of a storey from a specified index
+ 
+	index: The storey index
+ 
+	return: The storey ID (nullopt on failure)
+  --------------------------------------------------------------------*/
+std::optional<BIMRecordID> ArchicadAttributeDBaseEngine::getStoreyID(short index) const {
+	if (!m_storeyCache)
+		m_storeyCache = std::make_unique<StoreyCache>();
+	if (auto iter = m_storeyCache->find(index); iter != m_storeyCache->end())
+		return Guid::fromInt(iter->floorId);
+	return std::nullopt;
+} //ArchicadAttributeDBaseEngine::getStoreyID
+#endif

SpeckleLib/Speckle/Database/Storage/ArchicadDBase/Attribute/ArchicadAttributeDBaseEngine.h

@@ -0,0 +1,148 @@
+#ifndef SPECKLE_DATABASE_ARCHICAD_ATTRIBUTE_DBASE_ENGINE
+#define SPECKLE_DATABASE_ARCHICAD_ATTRIBUTE_DBASE_ENGINE
+
+#include "Active/Database/Storage/DBaseEngine.h"
+#include "Active/Serialise/UnboxedTransport.h"
+#include "Speckle/Database/Storage/ArchicadDBase/ArchicadDBaseCore.h"
+#include "Speckle/Database/Identity/BIMLink.h"
+#include "Speckle/Record/Attribute/Attribute.h"
+#include "Speckle/Utility/Guid.h"
+#include "Speckle/Utility/String.h"
+
+#include <algorithm>
+#include <ranges>
+
+namespace speckle::database {
+	
+	/*!
+	 A database engine to read/write elements in an Archicad project database (local file or cloud-based)
+	 
+	 For attribute indices:
+	 - Each attribute type is considered to be stored in a dedicated table
+	 - For Archicad:
+	 	- The table ID is typically the attribute type ID
+	 	- The record ID is the attribute index
+	 	- Storeys are also treated as an attribute (the API treats them separately, although application to elements is virtually the identical)
+	 */
+	class ArchicadAttributeDBaseEngine : public ArchicadDBaseCore,
+			public active::database::DBaseEngine<record::attribute::Attribute, BIMRecordID, BIMRecordID, BIMRecordID>  {
+	public:
+		
+		// MARK: - Types
+		
+		using base = active::database::DBaseEngine<record::attribute::Attribute, BIMRecordID, BIMRecordID, BIMRecordID>;
+		using Attribute = record::attribute::Attribute;
+		using Filter = base::Filter;
+		using Outline = base::Outline;
+		
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param id The document storage identifier
+		 */
+		ArchicadAttributeDBaseEngine(const active::utility::NameID& id, ArchicadDBaseSchema&& schema);
+		ArchicadAttributeDBaseEngine(const ArchicadAttributeDBaseEngine&) = delete;
+		/*!
+		 Destructor
+		 */
+		~ArchicadAttributeDBaseEngine();
+		
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get an object by ID
+		 @param objID The object ID
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (when the object is bound to a specific document)
+		 @return The requested object (nullptr on failure)
+		 */
+		std::unique_ptr<Attribute> getObject(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Get an object in a transportable form, e.g. packaged for serialisation
+		 @param objID The object ID
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (when the object is bound to a specific document)
+		 @return: The requested wrapped cargo (nullptr on failure)
+		 */
+		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Get all objects
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return The requested objects (nullptr on failure)
+		 */
+		active::container::Vector<Attribute> getObjects(std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Get a filtered list of objects
+		 @param filter The object filter
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return The filtered objects (nullptr on failure)
+		 */
+		active::container::Vector<Attribute> getObjects(const Filter& filter, std::optional<BIMRecordID> tableID = std::nullopt,
+												  std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Write an object to the database
+		 @param object The object to write
+		 @param objID The object ID
+		 @param objDocID The object document-specific ID (unique within a specific document - nullopt if not document-bound)
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (when the object is bound to a specific document)
+		 */
+		void write(const Attribute& object, const BIMRecordID& objID, std::optional<BIMRecordID> objDocID = std::nullopt,
+				   std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Erase an object by index
+		 @param ID The object ID
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (when the object is bound to a specific document)
+		 @throw Exception thrown on SQL error
+		 */
+		void erase(const BIMRecordID& ID, std::optional<BIMRecordID> tableID = std::nullopt,
+				   std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Erase all objects
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (when the object is bound to a specific document)
+		 @throw Exception thrown on SQL error
+		 */
+		void erase(std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Get the database outline
+		 @return The database outline
+		 */
+		Outline getOutline() const override;
+				
+#ifdef ARCHICAD
+		/*!
+		 Get attribute data direct from the AC API. For internal use - avoid direct use
+		 @param link A link to the required attribute
+		 @return The AC API attribute data
+		 */
+		std::optional<API_Attribute> getAPIData(const BIMLink& link) const;
+		/*!
+		 Get storey data direct from the AC API. For internal use - avoid direct use
+		 @param link A link to the required storey
+		 @return The AC API storey data
+		 */
+		std::optional<API_StoryType> getAPIStorey(const BIMLink& link) const;
+		/*!
+		 Get the ID of a storey from a specified index
+		 @param index The storey index
+		 @return The storey ID (nullopt on failure)
+		 */
+		std::optional<BIMRecordID> getStoreyID(short index) const;
+#endif
+
+	private:
+		void setTable(std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt);
+
+		class StoreyCache;
+			///Cache of storeys in the database (saves repeated lookups)
+		mutable std::unique_ptr<StoreyCache> m_storeyCache;
+	};
+	
+}
+
+#endif	//SPECKLE_DATABASE_ARCHICAD_ATTRIBUTE_DBASE_ENGINE

SpeckleLib/Speckle/Database/Storage/ArchicadDBase/Element/ArchicadElementDBaseEngine.cpp

@@ -43,19 +43,6 @@ namespace {
 	} //getTableInfo
 
 	
-	/*!
-	 Get the ID of the active Archicad table
-	 @return The active table ID (nullopt on failure)
-	 */
-	std::optional<BIMRecordID> getActiveTable() {
-		API_WindowInfo dbaseInfo;
-		active::utility::Memory::erase(dbaseInfo);
-		if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError)
-			return dbaseInfo.databaseUnId.elemSetId;
-		return std::nullopt;
-	} //getActiveTable
-
-	
 	/*!
 	 Set the active Archicad table
 	 @param tableID The target table ID
@@ -64,7 +51,7 @@ namespace {
 	bool setActiveTable(const BIMRecordID& tableID) {
 		if (!tableID)
 			return false;	//Null guid doens't point to anything
-		if (auto activeTable = getActiveTable(); activeTable && *activeTable == tableID)
+		if (auto activeTable = ArchicadElementDBaseEngine::getActiveTable(); activeTable && *activeTable == tableID)
 			return true;
 		auto dbaseInfo = getTableInfo(tableID);
 		if (!dbaseInfo)
@@ -76,29 +63,47 @@ namespace {
 	/*!
 	 Make a new element object
 	 @param elementData The API element representation
+	 @param tableID The ID of the parent table (defaults to the active drawing)
 	 @return A new element object (nullptr on failure)
 	 */
-	Element::Unique makeElement(const API_Element& elementData) {
+	Element::Unique makeElement(const API_Element& elementData, const BIMRecordID& tableID) {
 			//Implement an object factory in future as classes for specific element types are implemented, e.g. Wall, Roof etc. using hash map
 			//The fallback for undefined element types will always be the base Element class
-		return std::make_unique<Element>(elementData);
+		return std::make_unique<Element>(elementData, tableID);
 	}
 
 }
 
+/*--------------------------------------------------------------------
+	Get the ID of the active Archicad table
+ 
+	return; The active table ID (nullopt on failure)
+  --------------------------------------------------------------------*/
+std::optional<BIMRecordID> ArchicadElementDBaseEngine::getActiveTable() {
+	API_WindowInfo dbaseInfo;
+	active::utility::Memory::erase(dbaseInfo);
+	if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError)
+		return dbaseInfo.databaseUnId.elemSetId;
+	return std::nullopt;
+} //ArchicadElementDBaseEngine::getActiveTable
+
+
 /*--------------------------------------------------------------------
 	Get the current user element selection
  
 	return: A list of selected element IDs
   --------------------------------------------------------------------*/
 BIMLinkList ArchicadElementDBaseEngine::getSelection() const {
+	auto tableID = getActiveTable();
+	if (!tableID)
+		return {};
 	BIMLinkList result;
 	API_SelectionInfo selectionInfo;
 	active::utility::Memory::erase(selectionInfo);
 	GS::Array<API_Neig> selection;
 	if (auto err = ACAPI_Selection_Get(&selectionInfo, &selection, true); err == NoError) {
 		for (const auto& item : selection)
-			result.push_back(BIMLink{item});
+			result.push_back(BIMLink{item, *tableID});
 	}
 	return result;
 } //ArchicadElementDBaseEngine::getSelection
@@ -115,12 +120,17 @@ BIMLinkList ArchicadElementDBaseEngine::getSelection() const {
   --------------------------------------------------------------------*/
 std::unique_ptr<Element> ArchicadElementDBaseEngine::getObject(const BIMRecordID& ID, std::optional<BIMRecordID> tableID,
 															   std::optional<BIMRecordID> documentID)  const {
+	if (!tableID) {
+		tableID = getActiveTable();
+		if (!tableID)
+			return nullptr;
+	}
 	API_Element element;
 	active::utility::Memory::erase(element);
 	API_Guid guid{ID.operator API_Guid()};
 	if (ACAPI_Element_GetElementFromAnywhere(&guid, &element) != NoError)
 		return nullptr;
-	return makeElement(element);
+	return makeElement(element, *tableID);
 } //ArchicadElementDBaseEngine::getObject
 
 

SpeckleLib/Speckle/Database/Storage/ArchicadDBase/Element/ArchicadElementDBaseEngine.h

@@ -28,6 +28,14 @@ namespace speckle::database {
 		using Filter = base::Filter;
 		using Outline = base::Outline;
 		
+		// MARK: - Static functions
+		
+		/*!
+		 Get the ID of the active Archicad table
+		 @return The active table ID (nullopt on failure)
+		 */
+		static std::optional<BIMRecordID> getActiveTable();
+				
 		// MARK: - Constructors
 		
 		/*!

SpeckleLib/Speckle/Environment/Project.cpp

@@ -1,5 +1,6 @@
 #include "Speckle/Environment/Project.h"
 
+#include "Speckle/Database/BIMAttributeDatabase.h"
 #include "Speckle/Database/BIMElementDatabase.h"
 #include "Speckle/Environment/Addon.h"
 #include "Speckle/SpeckleResource.h"
@@ -23,6 +24,7 @@ namespace {
   --------------------------------------------------------------------*/
 Project::Project() {
 	m_element = std::make_unique<BIMElementDatabase>();
+	m_attribute = std::make_unique<BIMAttributeDatabase>();
 } //Project::Project
 
 

SpeckleLib/Speckle/Environment/Project.h

@@ -5,6 +5,7 @@
 #include "Speckle/Utility/String.h"
 
 namespace speckle::database {
+	class BIMAttributeDatabase;
 	class BIMElementDatabase;
 }
 
@@ -59,6 +60,11 @@ namespace speckle::environment {
 		 @return The account database
 		 */
 		const database::BIMElementDatabase* getElementDatabase() const { return m_element.get(); }
+		/*!
+		 Get the account database
+		 @return The account database
+		 */
+		const database::BIMAttributeDatabase* getAttributeDatabase() const { return m_attribute.get(); }
 		
 		// MARK: - Functions (mutating)
 		
@@ -73,7 +79,10 @@ namespace speckle::environment {
 		Project();
 		
 	private:
+			///The BIM element database
 		std::unique_ptr<database::BIMElementDatabase> m_element;
+			///The BIM attribute database
+		std::unique_ptr<database::BIMAttributeDatabase> m_attribute;
 	};
 
 }

SpeckleLib/Speckle/Event/Subscriber/SelectionSubscriber.cpp

@@ -2,6 +2,7 @@
 
 #include "Speckle/Environment/Addon.h"
 #include "Speckle/Database/Identity/BIMLink.h"
+#include "Speckle/Database/Storage/ArchicadDBase/Element/ArchicadElementDBaseEngine.h"
 #include "Speckle/Event/Type/SelectionEvent.h"
 
 #ifdef ARCHICAD
@@ -23,8 +24,10 @@ namespace {
 	 */
 	GSErrCode __ACENV_CALL selectionCallback(const API_Neig* params) {
 		if (addon() != nullptr) {
-			auto selection = (params == nullptr) ? BIMLink{} : BIMLink{*params};
-			addon()->publishExternal(SelectionEvent{selection});
+			if (auto tableID = ArchicadElementDBaseEngine::getActiveTable(); tableID) {
+				auto selection = (params == nullptr) ? BIMLink{} : BIMLink{*params, *tableID};
+				addon()->publishExternal(SelectionEvent{selection});
+			}
 		}
 		return NoError;
 	}

SpeckleLib/Speckle/Primitive/Mesh/Mesh.cpp

@@ -44,7 +44,7 @@ bool Mesh::fillInventory(Inventory& inventory) const {
 			{ fieldID[colorID], colorID, element },
 		},
 	}.withType(&typeid(Mesh)));
-	return true;
+	return base::fillInventory(inventory);
 } //Mesh::fillInventory
 
 
@@ -57,7 +57,7 @@ bool Mesh::fillInventory(Inventory& inventory) const {
   --------------------------------------------------------------------*/
 Cargo::Unique Mesh::getCargo(const Inventory::Item& item) const {
 	if (item.ownerType != &typeid(Mesh))
-		return nullptr;
+		return base::getCargo(item);
 	using namespace active::serialise;
 	switch (item.index) {
 	case vertexID:

SpeckleLib/Speckle/Primitive/Mesh/Mesh.h

@@ -1,29 +1,46 @@
 #ifndef SPECKLE_PRIMITIVE_MESH
 #define SPECKLE_PRIMITIVE_MESH
 
-#include "Active/Serialise/Package/Package.h"
+#include "Speckle/Database/Content/BIMRecord.h"
 #include "Speckle/Utility/String.h"
 
 namespace speckle::primitive {
 	
 	/*!
 	 Class for a 3D mesh
-	*/
-	class Mesh : public active::serialise::Package {
+	 */
+	class Mesh : public speckle::database::BIMRecord {
 	public:
 
+		// MARK: - Types
+
+		using base = speckle::database::BIMRecord;
+
 		// MARK: - Constructors
 		
 		/*!
 		 Default constructor
+		 @param unit The mesh unit type
 		 */
-		Mesh() {}
-
-		Mesh(std::vector<double>&& vertices, std::vector<int>&& faces, std::vector<int>&& colors, utility::String units = "m")
-			: vertices{ std::move(vertices) }, faces{ std::move(faces) }, colors{ std::move(colors) }, units{ units } {}
+		Mesh(active::measure::LengthType unit = active::measure::LengthType::metre) : base{unit} {}
+		/*!
+		 Constructor
+		 @param vertices The mesh vertices
+		 @param faces The mesh faces (the number of indices in the face followed by the vertex indices)
+		 @param colors The mesh face colours
+		 @param unit The mesh unit type
+		 */
+		Mesh(std::vector<double>&& vertices, std::vector<int>&& faces, std::vector<int>&& colors,
+				active::measure::LengthType unit = active::measure::LengthType::metre) :
+				base{unit}, vertices {std::move(vertices)}, faces{std::move(faces)}, colors{std::move(colors)} {}
 
 		// MARK: - Functions (const)
 		
+		/*!
+		 Get the speckle type identifier
+		 @return The speckle type (relevant objects should override as required)
+		 */
+		speckle::utility::String getSpeckleType() const override { return "speckle::primitive::Mesh"; }
 		
 		// MARK: - Serialisation
 		
@@ -31,20 +48,19 @@ namespace speckle::primitive {
 		 Fill an inventory with the package items
 		 @param inventory The inventory to receive the package items
 		 @return True if the package has added items to the inventory
-		*/
+		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const override;
 		/*!
 		 Get the specified cargo
 		 @param item The inventory item to retrieve
 		 @return The requested cargo (nullptr on failure)
-		*/
+		 */
 		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
 		
 	private:
 		std::vector<double> vertices;
 		std::vector<int> faces;
 		std::vector<int> colors;
-		utility::String units;
 	};
 	
 }

SpeckleLib/Speckle/Record/Attribute/Attribute.cpp

@@ -0,0 +1,103 @@
+#include "Speckle/Record/Attribute/Attribute.h"
+
+#include "Speckle/Database/BIMAttributeDatabase.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Environment/Project.h"
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::environment;
+using namespace speckle::record::attribute;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		nameID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"name"},
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Attribute::Attribute() {
+} //Attribute::Attribute
+
+
+/*--------------------------------------------------------------------
+	Get the attribute name
+ 
+	return: The attribute name
+  --------------------------------------------------------------------*/
+speckle::utility::String Attribute::getName() const {
+#ifdef ARCHICAD
+	return getHead().name;
+#endif
+} //Attribute::getName
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+ 
+	inventory: The inventory to receive the package items
+ 
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Attribute::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[nameID], nameID, element },
+		},
+	}.withType(&typeid(Attribute)));
+	return base::fillInventory(inventory);
+} //Attribute::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Attribute::getCargo(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(Attribute))
+		return base::getCargo(item);
+	using namespace active::serialise;
+	switch (item.index) {
+		case nameID:
+			//return std::make_unique<active::serialise::ContainerWrap>(*body);
+			return std::make_unique<StringWrap>(getHead().name);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //Attribute::getCargo
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the attribute data from the host BIM application
+ 
+	return: The attribute data (for internal use to populate derived classes)
+  --------------------------------------------------------------------*/
+API_Attribute Attribute::getData() const {
+	if (auto project = addon()->getActiveProject().lock(); project) {
+		if (auto attr = project->getAttributeDatabase()->getAPIData(getBIMLink()); attr)
+			return *attr;
+	}
+	API_Attribute attr;
+	active::utility::Memory::erase(attr);
+	return attr;
+} //Attribute::getData
+#endif

SpeckleLib/Speckle/Record/Attribute/Attribute.h

@@ -0,0 +1,120 @@
+#ifndef SPECKLE_RECORD_ATTRIBUTE
+#define SPECKLE_RECORD_ATTRIBUTE
+
+#include "Speckle/Database/Content/BIMRecord.h"
+#include "Speckle/Utility/String.h"
+
+namespace speckle::record::attribute {
+	
+	/*!
+	 Base BIM attribute class
+	 */
+	class Attribute : public speckle::database::BIMRecord {
+	public:
+
+		// MARK: - Types
+		
+		using base = speckle::database::BIMRecord;
+			///Unique pointer
+		using Unique = std::unique_ptr<Attribute>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Attribute>;
+			///Optional
+		using Option = std::optional<Attribute>;
+
+		// MARK: - Constants
+		
+#ifdef ARCHICAD
+			///Archicad type identifier for a storey attribute table
+		static constexpr int32_t storeyTableID = 0x200;
+		/*!
+		 Get an attribute type ID from a table ID
+		 @param tableID The table ID
+		 @return The attribute type ID (NB: not strictly API_AttrTypeID - can be storeyTypeID)
+		 */
+		static API_AttrTypeID getTypeID(const active::utility::Guid& tableID) {
+			return static_cast<API_AttrTypeID>(active::utility::Guid::toInt(tableID));
+		}
+		/*!
+		 Get an Archicad attribute index from a record ID
+		 @param recordID The record ID
+		 @return An attribute index
+		 */
+		static API_AttributeIndex getIndex(const active::utility::Guid& recordID) {
+			return ACAPI_CreateAttributeIndex(static_cast<int32_t>(active::utility::Guid::toInt(recordID)));
+		}
+#endif
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Attribute();
+		/*!
+		 Constructor
+		 @param ID The attribute ID
+		 @param tableID The attribute table ID (attribute type)
+		 */
+		Attribute(const database::BIMRecordID& ID, const speckle::utility::Guid& tableID) : base{ID, tableID} {}
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the speckle type identifier
+		 @return The speckle type (relevant objects should override as required)
+		 */
+		speckle::utility::String getSpeckleType() const override { return "speckle::record::attribute::Attribute"; }
+		/*!
+		 Get the attribute name
+		 @return The attribute name
+		 */
+		speckle::utility::String getName() const;
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API attribute header data
+		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		virtual const API_Attr_Head& getHead() const = 0;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API attribute header data
+		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		virtual API_Attr_Head& getHead() = 0;
+#endif
+		
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+
+	protected:
+#ifdef ARCHICAD
+		/*!
+		 Get the attribute data from the host BIM application
+		 @return The attribute data (for internal use to populate derived classes)
+		 */
+		API_Attribute getData() const;
+#endif
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ATTRIBUTE

SpeckleLib/Speckle/Record/Attribute/Finish.cpp

@@ -0,0 +1,205 @@
+#include "Speckle/Record/Attribute/Finish.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Utility/BufferOut.h"
+#include "Speckle/Utility/Guid.h"
+
+#ifdef ARCHICAD
+#include <ModelMaterial.hpp>
+#endif
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::record::attribute;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::attribute {
+	
+	class Finish::Data {
+	public:
+#ifdef ARCHICAD
+		Data(const API_Attribute& attr) : root{attr.material} {}
+		Data(const Data& source) : root{source.root} {}
+		
+		API_MaterialType root;
+#endif
+	};
+	
+}
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		surfaceColourID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"surfaceColour"},
+	};
+
+#ifdef ARCHICAD
+	/*!
+	 Copy a ModelerAPI colour to an AC RGB colour
+	 */
+	void copyModelerColor(const ModelerAPI::Color& modelColour, API_RGBColor& colour) {
+		colour.f_red = modelColour.red;
+		colour.f_green = modelColour.green;
+		colour.f_blue = modelColour.blue;
+	} //copyModelerColor
+#endif
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Finish::Finish() {
+} //Finish::Finish
+
+
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	ID: The attribute ID
+  --------------------------------------------------------------------*/
+Finish::Finish(const database::BIMRecordID& ID) : base{ID, Finish::table} {
+} //Finish::Finish
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	attrData: Archicad attribute data
+	tableID: The ID of the parent table
+  --------------------------------------------------------------------*/
+Finish::Finish(const API_Attribute& attrData, const BIMRecordID& tableID) : base{attrData.header.guid, Finish::table} {
+	m_data = std::make_unique<Data>(attrData);
+}
+
+
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	material: A ModelerAPI material definition
+  --------------------------------------------------------------------*/
+Finish::Finish(const ModelerAPI::Material& material) {
+	API_Attribute attr;
+	active::utility::Memory::erase(attr);
+	String{material.GetName()}.writeUTF8(active::utility::BufferOut{attr.header.name});
+	attr.header.guid = Guid{Guid::fromInt(material.GenerateHashValue())};
+	attr.material.mtype = static_cast<API_MaterTypeID>(material.GetType());
+	attr.material.ambientPc = material.GetAmbientReflection();
+	attr.material.diffusePc = material.GetDiffuseReflection();
+	attr.material.specularPc = material.GetSpecularReflection();
+	attr.material.transpPc = material.GetTransparency();
+	attr.material.shine = material.GetShining();
+	attr.material.transpAtt = material.GetTransparencyAttenuation();
+	attr.material.emissionAtt = material.GetEmissionAttenuation();
+	copyModelerColor(material.GetSurfaceColor(), attr.material.surfaceRGB);
+	copyModelerColor(material.GetSpecularColor(), attr.material.specularRGB);
+	copyModelerColor(material.GetEmissionColor(), attr.material.emissionRGB);
+	m_data = std::make_unique<Data>(attr);
+} //Finish::Finish
+#endif
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+ 
+ 	source: The object to copy
+  --------------------------------------------------------------------*/
+Finish::Finish(const Finish& source) : base{source} {
+	m_data = source.m_data ? std::make_unique<Data>(*m_data) : nullptr;
+} //Finish::Finish
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Finish::~Finish() {}
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API attribute header data
+ 
+	return: The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Attr_Head& Finish::getHead() const {
+	confirmData();
+	return m_data->root.head;
+} //Finish::getHead
+
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API attribute header data
+ 
+	return: The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Attr_Head& Finish::getHead() {
+	confirmData();
+	return m_data->root.head;
+} //Finish::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+ 
+	inventory: The inventory to receive the package items
+ 
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Finish::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[surfaceColourID], surfaceColourID, element },	//TODO: implement other fields
+		},
+	}.withType(&typeid(Finish)));
+	return base::fillInventory(inventory);
+} //Finish::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Finish::getCargo(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(Finish))
+		return base::getCargo(item);
+	confirmData();
+	using namespace active::serialise;
+	switch (item.index) {
+		case surfaceColourID:
+			return nullptr;	//TODO: lookup surface colour
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //Finish::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Finish::setDefault() {
+
+} //Finish::setDefault
+
+
+/*--------------------------------------------------------------------
+	Confirm the internal data, either loading from the BIM application or setting a default
+  --------------------------------------------------------------------*/
+void Finish::confirmData() const {
+	if (m_data)
+		return;
+	m_data = std::make_unique<Data>(getData());
+} //Finish::confirmData

SpeckleLib/Speckle/Record/Attribute/Finish.h

@@ -0,0 +1,139 @@
+#ifndef SPECKLE_RECORD_ATTRIBUTE_FINISH
+#define SPECKLE_RECORD_ATTRIBUTE_FINISH
+
+#include "Speckle/Record/Attribute/Attribute.h"
+
+#ifdef ARCHICAD
+namespace ModelerAPI {
+	class Material;
+}
+#endif
+
+namespace speckle::record::attribute {
+	
+	/*!
+	 Class to represent the rendered finish on a 3D body, i.e. the surface colour/texture etc.
+	 
+	 In Archicad this attribute is represented by `API_MaterialType`
+	 */
+	class Finish : public Attribute {
+	public:
+
+		// MARK: - Types
+		
+		using base = Attribute;
+			///Unique pointer
+		using Unique = std::unique_ptr<Finish>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Finish>;
+			///Optional
+		using Option = std::optional<Finish>;
+		
+		// MARK: - Constants
+		
+#ifdef ARCHICAD
+			///The finishes table identifier
+		static constexpr active::utility::Guid table{active::utility::Guid::fromInt(API_MaterialID)};
+#endif
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Finish();
+		/*!
+		 Constructor
+		 @param ID The attribute ID
+		 */
+		Finish(const database::BIMRecordID& ID);
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param attrData Archicad attribute data
+		 @param tableID The ID of the parent table
+		 */
+		Finish(const API_Attribute& attrData, const database::BIMRecordID& tableID);
+		/*!
+		 Constructor
+		 @param material A ModelerAPI material definition
+		 */
+		Finish(const ModelerAPI::Material& material);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Finish(const Finish& source);
+		/*!
+		 Destructor
+		 */
+		~Finish();
+
+		/*!
+		 Object cloning
+		 @return A clone of this object
+		 */
+		Finish* clonePtr() const override { return new Finish{*this}; }
+
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the speckle type identifier
+		 @return The speckle type (relevant objects should override as required)
+		 */
+		speckle::utility::String getSpeckleType() const override { return "Objects.Other.RenderMaterial"; }
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API attribute header data
+		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		const API_Attr_Head& getHead() const override;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API attribute header data
+		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		API_Attr_Head& getHead() override;
+#endif
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+		
+	private:
+		/*!
+		 Confirm the internal data, either loading from the BIM application or setting a default
+		 */
+		void confirmData() const;
+		
+		class Data;
+			///The attribute data - mutable to support lazy loading
+		mutable std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ATTRIBUTE_FINISH

SpeckleLib/Speckle/Record/Attribute/Storey.cpp

@@ -0,0 +1,221 @@
+#include "Speckle/Record/Attribute/Storey.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Utility/BufferOut.h"
+#include "Speckle/Database/BIMAttributeDatabase.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Environment/Project.h"
+#include "Speckle/Utility/Guid.h"
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::environment;
+using namespace speckle::record::attribute;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::attribute {
+	
+	class Storey::Data {
+	public:
+#ifdef ARCHICAD
+		Data(const API_StoryType& storey) : root{storey} {}
+		Data(const Data& source) : root{source.root} {}
+		
+		API_StoryType root;
+		API_Attr_Head header;
+#endif
+	};
+	
+}
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		levelID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"level"},
+	};
+	
+	
+#ifdef ARCHICAD
+	/*!
+	 Fill in an Archicad API attribute header based on a storey
+	 @param header The attribute header to be populated
+	 @param storey The storey to be copied into the header
+	 */
+	void fillHeader(API_Attr_Head& header, const API_StoryType& storey) {
+		active::utility::Memory::erase(header);
+			//NB: This is not intended to be used for API attribute calls - it only transports core properties within this framework, e.g. name
+		header.typeID = static_cast<API_AttrTypeID>(Attribute::storeyTableID);
+		header.index = ACAPI_CreateAttributeIndex(storey.index);
+		header.guid = Guid{Guid::fromInt(storey.floorId)};
+		String{storey.uName}.writeUTF8(active::utility::BufferOut{header.name}, true);
+	}
+#endif
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Storey::Storey() {
+} //Storey::Storey
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	index: An index into the Archicad storey array
+  --------------------------------------------------------------------*/
+Storey::Storey(short index) {
+	m_storeyIndex = index;
+} //Storey::Storey
+#endif
+
+
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	ID: The attribute ID
+  --------------------------------------------------------------------*/
+Storey::Storey(const database::BIMRecordID& ID) : base{ID, storeyTableID} {
+} //Storey::Storey
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+ 
+ 	source: The object to copy
+  --------------------------------------------------------------------*/
+Storey::Storey(const Storey& source) : base{source} {
+	m_data = source.m_data ? std::make_unique<Data>(*m_data) : nullptr;
+#ifdef ARCHICAD
+	m_storeyIndex = source.m_storeyIndex;
+#endif
+} //Storey::Storey
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Storey::~Storey() {}
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API attribute header data
+ 
+	return: The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Attr_Head& Storey::getHead() const {
+	confirmData();
+	fillHeader(m_data->header, m_data->root);
+	return m_data->header;
+} //Storey::getHead
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API attribute header data
+ 
+	return: The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Attr_Head& Storey::getHead() {
+	confirmData();
+	fillHeader(m_data->header, m_data->root);
+	return m_data->header;
+} //Storey::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+ 
+	inventory: The inventory to receive the package items
+ 
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Storey::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[levelID], levelID, element },	//TODO: implement other fields
+		},
+	}.withType(&typeid(Storey)));
+	return base::fillInventory(inventory);
+} //Storey::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Storey::getCargo(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(Storey))
+		return base::getCargo(item);
+	confirmData();
+	using namespace active::serialise;
+	switch (item.index) {
+		case levelID:
+			return std::make_unique<DoubleWrap>(m_data->root.level);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //Storey::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Storey::setDefault() {
+
+} //Storey::setDefault
+
+
+/*--------------------------------------------------------------------
+	Confirm the internal data, either loading from the BIM application or setting a default
+  --------------------------------------------------------------------*/
+void Storey::confirmData() const {
+	if (m_data)
+		return;
+#ifdef ARCHICAD
+	m_data = std::make_unique<Data>(getStoreyData());
+#endif
+} //Storey::confirmData
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the storey data from the host BIM application
+ 
+	return: The storey data (for internal use to populate derived classes)
+  --------------------------------------------------------------------*/
+API_StoryType Storey::getStoreyData() const {
+	do {
+		if (auto project = addon()->getActiveProject().lock(); project) {
+			auto attributeDatabase = project->getAttributeDatabase();
+			if (m_storeyIndex) {
+				auto storeyID = attributeDatabase->getStoreyID(*m_storeyIndex);
+				m_storeyIndex.reset();
+				if (!storeyID)
+					break;
+				resetIndex({*storeyID, Attribute::storeyTableID});
+			}
+			if (auto storey = attributeDatabase->getAPIStorey(getBIMLink()); storey)
+				return *storey;
+		}
+	} while (false);
+	API_StoryType storey;
+	active::utility::Memory::erase(storey);
+	return storey;
+} //Storey::getStoreyData
+#endif

SpeckleLib/Speckle/Record/Attribute/Storey.h

@@ -0,0 +1,135 @@
+#ifndef SPECKLE_RECORD_ATTRIBUTE_STOREY
+#define SPECKLE_RECORD_ATTRIBUTE_STOREY
+
+#include "Speckle/Record/Attribute/Attribute.h"
+
+namespace speckle::record::attribute {
+	
+	/*!
+	 A storey or level in a building
+	 
+	 Represented in Archicad by `API_StoryType`
+	 */
+	class Storey : public Attribute {
+	public:
+
+		// MARK: - Types
+		
+		using base = Attribute;
+			///Unique pointer
+		using Unique = std::unique_ptr<Storey>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Storey>;
+			///Optional
+		using Option = std::optional<Storey>;
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Storey();
+		/*!
+		 Constructor
+		 @param ID The attribute ID
+		 */
+		Storey(const database::BIMRecordID& ID);
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param index An index into the Archicad storey array
+		 */
+		Storey(short index);
+		/*!
+		 Constructor
+		 @param attrData Archicad attribute data
+		 */
+		Storey(const API_StoryType& attrData);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Storey(const Storey& source);
+		/*!
+		 Destructor
+		 */
+		~Storey();
+
+		/*!
+		 Object cloning
+		 @return A clone of this object
+		 */
+		Storey* clonePtr() const override { return new Storey{*this}; }
+
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the speckle type identifier
+		 @return The speckle type (relevant objects should override as required)
+		 */
+		speckle::utility::String getSpeckleType() const override { return "speckle::record::attribute::Storey"; }
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API attribute header data
+		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		const API_Attr_Head& getHead() const override;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API attribute header data
+		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		API_Attr_Head& getHead() override;
+#endif
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+
+	private:
+		/*!
+		 Confirm the internal data, either loading from the BIM application or setting a default
+		 */
+		void confirmData() const;
+#ifdef ARCHICAD
+		/*!
+		 Get the storey data from the host BIM application
+		 @return The storey data (for internal use to populate derived classes)
+		 */
+		API_StoryType getStoreyData() const;
+		
+			///An index into the Archicad storey array - used temporarily for looking up the storey data on demand
+		mutable std::optional<short> m_storeyIndex;
+#endif
+		
+		class Data;
+			///The attribute data - mutable to support lazy loading
+		mutable std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ATTRIBUTE_STOREY

SpeckleLib/Speckle/Record/Element/Element.cpp

@@ -3,10 +3,22 @@
 #include "Active/Serialise/Item/Wrapper/ValueWrap.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
 #include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Environment/Addon.h"
 #include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/SpeckleResource.h"
 #include "Speckle/Utility/Guid.h"
 
+#include "Sight.hpp"
+#include "Model.hpp"
+#include "ModelMaterial.hpp"
+#include "ModelElement.hpp"
+#include "exp.h"
+#include "ModelMeshBody.hpp"
+#include "ConvexPolygon.hpp"
+
 using namespace active::serialise;
+using namespace speckle::environment;
+using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
 
@@ -14,41 +26,45 @@ using namespace speckle::utility;
 #include <memory>
 
 namespace speckle::record::element {
-	
+
 	class Element::Data {
 	public:
 		friend class Element;
-		
-		Data(const API_Element& elem) : root{std::make_unique<API_Element>(elem)} {}
-		Data(const Data& source) : root{std::make_unique<API_Element>(*source.root)} {}
-		
+
+#ifdef ARCHICAD
+		Data(const API_Element& elem) : root{ std::make_unique<API_Element>(elem) } {}
+		Data(const Data& source) : root{ std::make_unique<API_Element>(*source.root) } {}
+#endif
+
 	private:
 		std::unique_ptr<API_Element> root;
 		std::unique_ptr<Element::Body> m_cache;
 	};
-	
+
 }
 
 namespace {
-	
-		///Serialisation fields
+
+	///Serialisation fields
 	enum FieldIndex {
 		bodyID,
 	};
 
-		///Serialisation field IDs
+	///Serialisation field IDs
 	static std::array fieldID = {
 		Identity{"displayValue"},
 	};
 
-	void GetComponent(API_Component3D& component, API_3DTypeID typeId, Int32 index) {
-		component.header.typeID = typeId;
-		component.header.index = index;
-		if (ACAPI_ModelAccess_GetComponent(&component) != NoError) {
-			// TODO: throw
-		}
-	}
+	int32_t ARGBToInt(double alpha, double red, double green, double blue) {
+		// Convert double (0.0 - 1.0) to uint8_t (0 - 255)
+		uint8_t a = static_cast<uint8_t>(std::round(alpha * 255.0));
+		uint8_t r = static_cast<uint8_t>(std::round(red * 255.0));
+		uint8_t g = static_cast<uint8_t>(std::round(green * 255.0));
+		uint8_t b = static_cast<uint8_t>(std::round(blue * 255.0));
 
+		// Pack ARGB into a single 32-bit integer
+		return (a << 24) | (r << 16) | (g << 8) | b;
+	}
 }
 
 /*--------------------------------------------------------------------
@@ -60,20 +76,21 @@ Element::Element() {
 
 /*--------------------------------------------------------------------
 	Constructor
- 
+
 	elemData: Archicad element data
+	tableID: The attribute table ID (attribute type)
   --------------------------------------------------------------------*/
-Element::Element(const API_Element& elemData) : base{elemData.header.guid} {
+Element::Element(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
 	m_data = std::make_unique<Data>(elemData);
 } //Element::Element
 
 
 /*--------------------------------------------------------------------
 	Copy constructor
- 
- 	source: The object to copy
+
+	source: The object to copy
   --------------------------------------------------------------------*/
-Element::Element(const Element& source) : base{source} {
+Element::Element(const Element& source) : base{ source } {
 	m_data = source.m_data ? std::make_unique<Data>(*m_data) : nullptr;
 } //Element::Element
 
@@ -83,85 +100,131 @@ Element::Element(const Element& source) : base{source} {
   --------------------------------------------------------------------*/
 Element::~Element() {}
 
-Element::Body* Element::getBody() const {
 
+/*--------------------------------------------------------------------
+	Get the element storey
+
+	return: The element storey (nullopt if the element isn't linked to a storey)
+  --------------------------------------------------------------------*/
+Storey::Option Element::getStorey() const {
+#ifdef ARCHICAD
+	return Storey{ getHead().floorInd };
+#endif
+} //Element::getStorey
+
+
+/*--------------------------------------------------------------------
+	Get the element type name, e.g. "Wall", "Roof" etc
+
+	return: The type name
+  --------------------------------------------------------------------*/
+String Element::getTypeName() const {
+#ifdef ARCHICAD
+	GS::UniString typeName;
+	if (auto err = ACAPI_Element_GetElemTypeName(getHead().type, typeName); err != NoError)
+		return addon()->getLocalString(titleStringLib, unknownElementTypeID);
+	return typeName;
+#endif
+} //Element::getTypeName
+
+
+/*--------------------------------------------------------------------
+	Get the element body as a list of faces or Meshes
+
+	return: A pointer to the element body
+  --------------------------------------------------------------------*/
+Element::Body* Element::getBody() const {
+#ifdef ARCHICAD
 	if (m_data->m_cache) {
 		return m_data->m_cache.get();
 	}
 
-	auto elementBody = new Element::Body();
-	std::map<int, int> vertexIndexMap;
-	int currentVertexIndex = 0;
 
-	API_ElemInfo3D info3D = {};
-
-	if (ACAPI_ModelAccess_Get3DInfo(getHead(), &info3D) != NoError) {
-		// TODO: throw
+	void* dummy = nullptr;
+	GSErrCode err = ACAPI_Sight_GetCurrentWindowSight(&dummy);
+	if (err != NoError)
+	{
+		// TODO: should this throw?
 	}
 
-	for (Int32 ib = info3D.fbody; ib <= info3D.lbody; ib++) {
-		API_Component3D component = {};
-		GetComponent(component, API_BodyID, ib);
+	Modeler::SightPtr currentSightPtr((Modeler::Sight*)dummy); // init the shared ptr with the raw pointer
+	ModelerAPI::Model acModel;
+	Modeler::IAttributeReader* attrReader = ACAPI_Attribute_GetCurrentAttributeSetReader();
 
-		std::vector<double> vertices;
-		std::vector<int> faces;
-		std::vector<int> colors;
+	err = EXPGetModel(currentSightPtr, &acModel, attrReader);
+	if (err != NoError)
+	{
+		// TODO: should this throw?
+	}
 
-		vertices.clear();
-		faces.clear();
-		colors.clear();
+	auto elementBody = new Element::Body();
 
-		Int32 nPgon = component.body.nPgon;
-		for (Int32 ip = 1; ip <= nPgon; ip++) {
-			GetComponent(component, API_PgonID, ip);
+	Int32 nElements = acModel.GetElementCount();
+	for (Int32 iElement = 1; iElement <= nElements; iElement++)
+	{
+		ModelerAPI::Element elem{};
+		acModel.GetElement(iElement, &elem);
+		if (elem.GetElemGuid() != getHead().guid)
+			continue;
 
-			Int32 fpedg = component.pgon.fpedg;
-			Int32 lpedg = component.pgon.lpedg;
-			Int32 faceSize = lpedg - fpedg + 1;
-			faces.push_back(faceSize);
-			for (Int32 ie = fpedg; ie <= lpedg; ie++)
+		Int32 nBodies = elem.GetTessellatedBodyCount();
+		for (Int32 bodyIndex = 1; bodyIndex <= nBodies; ++bodyIndex)
+		{
+			ModelerAPI::MeshBody body{};
+			elem.GetTessellatedBody(bodyIndex, &body);
+
+			Int32 polyCount = body.GetPolygonCount();
+			for (Int32 polyIndex = 1; polyIndex <= polyCount; ++polyIndex)
 			{
-				GetComponent(component, API_PedgID, ie);
+				ModelerAPI::Polygon	polygon{};
+				body.GetPolygon(polyIndex, &polygon);
 
-				// TODO is this needed? need review, not sure how ACAPI_ModelAccess works
-				bool wasNegative = component.pedg.pedg < 0;
-				Int32 edgeIndex = std::abs(component.pedg.pedg);
-				GetComponent(component, API_EdgeID, edgeIndex);
+				ModelerAPI::Material material{};
+				polygon.GetMaterial(&material);
+				Int32 convexPolyCount = polygon.GetConvexPolygonCount();
 
-				// TODO is this needed? need review, not sure how ACAPI_ModelAccess works
-				Int32 vertexIndex = wasNegative ? component.edge.vert2 : component.edge.vert1;
-				/*auto materialIndex = component.pgon.iumat;
-				GetComponent(component, API_UmatID, materialIndex);
-				double R = component.umat.mater.surfaceRGB.f_red;
-				double G = component.umat.mater.surfaceRGB.f_green;
-				double B = component.umat.mater.surfaceRGB.f_blue;*/
-				// TODO: other material stuff
+				for (Int32 convPolyIndex = 1; convPolyIndex <= convexPolyCount; ++convPolyIndex)
+				{
+					std::vector<double> vertices;
+					std::vector<int> faces;
+					std::vector<int> colors;
 
-				GetComponent(component, API_VertID, vertexIndex);
+					ModelerAPI::ConvexPolygon convexPolygon{};
+					polygon.GetConvexPolygon(convPolyIndex, &convexPolygon);
+					Int32 vertexCount = convexPolygon.GetVertexCount();
 
-				if (vertexIndexMap.find(vertexIndex) == vertexIndexMap.end()) {
-					faces.push_back(currentVertexIndex);
-					vertexIndexMap[vertexIndex] = currentVertexIndex++;
+					faces.push_back(vertexCount);
+					for (Int32 vertexIndex = 1; vertexIndex <= vertexCount; ++vertexIndex)
+					{
+						ModelerAPI::Vertex vertex{};
+						body.GetVertex(convexPolygon.GetVertexIndex(vertexIndex), &vertex);
 
-					vertices.push_back(component.vert.x);
-					vertices.push_back(component.vert.y);
-					vertices.push_back(component.vert.z);
-				}
-				else {
-					faces.push_back(vertexIndexMap[vertexIndex]);
+						// TODO: change vertices array to hold Vertex instead of double values
+						vertices.push_back(vertex.x);
+						vertices.push_back(vertex.y);
+						vertices.push_back(vertex.z);
+
+						double alpha = material.GetTransparency();
+						ModelerAPI::Color color = material.GetSurfaceColor();
+						colors.push_back(ARGBToInt(alpha, color.red, color.green, color.blue));
+
+						faces.push_back(vertexIndex - 1);
+					}
+					elementBody->push_back(primitive::Mesh(std::move(vertices), std::move(faces), std::move(colors)));
 				}
 			}
 		}
-		elementBody->push_back(primitive::Mesh(std::move(vertices), std::move(faces), std::move(colors)));
 	}
 	m_data->m_cache.reset(elementBody);
 	return m_data->m_cache.get();
+#endif
 }
 
 
+#ifdef ARCHICAD
 /*--------------------------------------------------------------------
 	Get the (immutable) API element header data
- 
+
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
   --------------------------------------------------------------------*/
 const API_Elem_Head& Element::getHead() const {
@@ -170,19 +233,20 @@ const API_Elem_Head& Element::getHead() const {
 
 /*--------------------------------------------------------------------
 	Get the (mutable) API element header data
- 
+
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
   --------------------------------------------------------------------*/
 API_Elem_Head& Element::getHead() {
 	return m_data->root->header;
 } //Element::getHead
+#endif
 
 
 /*--------------------------------------------------------------------
 	Fill an inventory with the package items
- 
+
 	inventory: The inventory to receive the package items
- 
+
 	return: True if the package has added items to the inventory
   --------------------------------------------------------------------*/
 bool Element::fillInventory(Inventory& inventory) const {
@@ -190,18 +254,18 @@ bool Element::fillInventory(Inventory& inventory) const {
 	auto body = getBody();
 	inventory.merge(Inventory{
 		{
-			{ fieldID[bodyID], bodyID, body == nullptr ? 0 : static_cast<uint32_t>(body->size()) },	//TODO: implement other fields
+			{ fieldID[bodyID], bodyID, element },	//TODO: implement other fields
 		},
-	}.withType(&typeid(Element)));
+		}.withType(&typeid(Element)));
 	return base::fillInventory(inventory);
 } //Element::fillInventory
 
 
 /*--------------------------------------------------------------------
 	Get the specified cargo
- 
+
 	item: The inventory item to retrieve
- 
+
 	return: The requested cargo (nullptr on failure)
   --------------------------------------------------------------------*/
 Cargo::Unique Element::getCargo(const Inventory::Item& item) const {
@@ -209,17 +273,16 @@ Cargo::Unique Element::getCargo(const Inventory::Item& item) const {
 		return base::getCargo(item);
 	using namespace active::serialise;
 	switch (item.index) {
-		case bodyID:
-			if (auto body = getBody(); body != nullptr)
-			{
-				//return std::make_unique<active::serialise::ContainerWrap>(*body);
-				return Cargo::Unique{ new active::serialise::ContainerWrap{ *body } };
-			}
-			else
-				return nullptr;
-				
-		default:
-			return nullptr;	//Requested an unknown index
+	case bodyID:
+		if (auto body = getBody(); body != nullptr)
+		{
+			return Cargo::Unique{ new active::serialise::ContainerWrap{ *body } };
+		}
+		else
+			return nullptr;
+
+	default:
+		return nullptr;	//Requested an unknown index
 	}
 } //Element::getCargo
 

SpeckleLib/Speckle/Record/Element/Element.h

@@ -2,6 +2,7 @@
 #define SPECKLE_RECORD_ELEMENT
 
 #include "Speckle/Database/Content/BIMRecord.h"
+#include "Speckle/Record/Attribute/Storey.h"
 #include "Speckle/Utility/String.h"
 
 namespace speckle::primitive {
@@ -41,8 +42,9 @@ namespace speckle::record::element {
 		/*!
 		 Constructor
 		 @param elemData Archicad element data
+		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
 		 */
-		Element(const API_Element& elemData);
+		Element(const API_Element& elemData, const speckle::utility::Guid& tableID);
 #endif
 		/*!
 		 Copy constructor
@@ -55,24 +57,39 @@ namespace speckle::record::element {
 		~Element();
 
 		/*!
-			Object cloning
-			@return A clone of this object
-		*/
+		 Object cloning
+		 @return A clone of this object
+		 */
 		Element* clonePtr() const override { return new Element{*this}; }
 
 
 		// MARK: - Functions (const)
 
 		/*!
-			Get the element body
-			@return An array of meshes from the element body (nullptr if no body data is available)
-		*/
+		 Get the speckle type identifier
+		 @return The speckle type (relevant objects should override as required)
+		 */
+		virtual speckle::utility::String getSpeckleType() const override { return "Objects.BuiltElements.Element:Objects.BuiltElements.Element"; }
+		/*!
+		 Get the elmeent type name, e.g. "Wall", "Roof" etc
+		 @return The type name
+		 */
+		virtual speckle::utility::String getTypeName() const;
+		/*!
+		 Get the element storey
+		 @return The element storey (nullopt if the element isn't linked to a storey)
+		 */
+		virtual attribute::Storey::Option getStorey() const;
+		/*!
+		 Get the element body
+		 @return An array of meshes from the element body (nullptr if no body data is available)
+		 */
 		virtual Body* getBody() const;
 #ifdef ARCHICAD
 		/*!
-			Get the (immutable) API element header data
-			@return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		*/
+		 Get the (immutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
 		virtual const API_Elem_Head& getHead() const;
 #endif
 		
@@ -80,29 +97,29 @@ namespace speckle::record::element {
 
 #ifdef ARCHICAD
 		/*!
-			Get the (mutable) API element header data
-			@return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		*/
+		 Get the (mutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
 		virtual API_Elem_Head& getHead();
 #endif
 
 		// MARK: - Serialisation
 		
 		/*!
-			Fill an inventory with the package items
-			@param inventory The inventory to receive the package items
-			@return True if the package has added items to the inventory
-		*/
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const override;
 		/*!
-			Get the specified cargo
-			@param item The inventory item to retrieve
-			@return The requested cargo (nullptr on failure)
-		*/
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
 		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
 		/*!
-			Set to the default package content
-		*/
+		 Set to the default package content
+		 */
 		void setDefault() override;
 		
 	private:

SpeckleLib/Speckle/Serialise/Collection/FinishCollector.h

@@ -0,0 +1,48 @@
+#ifndef SPECKLE_SERIALISE_FINISH_COLLECTOR
+#define SPECKLE_SERIALISE_FINISH_COLLECTOR
+
+#include "Active/Serialise/Management/Manager.h"
+
+#ifdef ARCHICAD
+namespace ModelerAPI {
+	class Material;
+}
+#endif
+
+namespace speckle::serialise {
+	
+	/*!
+	 Collector for object finishes
+	 
+	 Used as a serialisation manager to collect finishes from serialised objects
+	 */
+	class FinishCollector : public active::serialise::Manager {
+	public:
+		/*!
+		 Destructor
+		 */
+		virtual ~FinishCollector() {}
+
+		// MARK: - Functions (mutating)
+
+		/*!
+		 Add a material proxy record to the collection
+		 @param materialIndex The index of the material to add
+		 @param objectID The object the material is applied to
+		 @return True if the material proxy was added (false typically means the record already exists)
+		 */
+		virtual bool addMaterialProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) = 0;
+#ifdef ARCHICAD
+		/*!
+		 Add a ModelerAPI material to the collection (NB: These are not persistent so need to be captured by this method)
+		 @param material A material
+		 @param objectID The object the material is applied to
+		 @return True if the material proxy was added (false typically means the record already exists)
+		 */
+		virtual bool addMaterialProxy(const ModelerAPI::Material& material, const speckle::database::BIMRecordID& objectID) = 0;
+#endif
+	};
+	
+}
+
+#endif	//SPECKLE_SERIALISE_FINISH_COLLECTOR

SpeckleLib/Speckle/Serialise/Detached/DetachedReference.cpp

@@ -64,7 +64,7 @@ Cargo::Unique DetachedReference::getCargo(const Inventory::Item& item) const {
 				//If we don't have an allocated string for receiving a reference (from 'setDefault') then we need to create one
 			if (!m_reference) {
 					//Ask a manager to send the detached data and provide a reference
-				auto detachmentManager = getManager<DetachmentManager>();
+				auto detachmentManager = (management() == nullptr) ? nullptr : management()->get<DetachmentManager>();
 				if (detachmentManager == nullptr)
 					return nullptr;	//TODO: Discuss if this is a serious error - possibly throwing an exception is warranted
 				m_reference = detachmentManager->send(std::forward<Package&&>(base::get()), item.identity());

SpeckleLib/Speckle/Serialise/Detached/DetachmentManager.h

@@ -1,7 +1,7 @@
 #ifndef SPECKLE_SERIALISE_DETACHMENT_MANAGER
 #define SPECKLE_SERIALISE_DETACHMENT_MANAGER
 
-#include "Active/Serialise/Manager.h"
+#include "Active/Serialise/Management/Manager.h"
 #include "Active/Serialise/Transport.h"
 #include "Speckle/Database/Identity/RecordID.h"
 

SpeckleLib/Speckle/Serialise/Units/LengthUnit.cpp

@@ -0,0 +1,55 @@
+#include "Speckle/Serialise/Units/LengthUnit.h"
+
+#include <algorithm>
+#include <map>
+
+using namespace active::measure;
+using namespace active::utility;
+
+using enum LengthType;
+
+namespace {
+	
+		//All recognised encoding types
+	std::map<LengthType, String> lengthNames = {
+		{ millimetre, "mm" },
+		{ centimetre, "cm" },
+		{ metre, "m" },
+		{ kilometre, "km" },
+		{ inch, "in" },
+		{ foot, "ft" },
+		{ yard, "yd" },
+		{ mile, "ml" },
+	};
+
+}  // namespace
+
+/*--------------------------------------------------------------------
+	Convert a length unit name to a type
+ 
+	name: The length unit name
+ 
+	return: The length unit type (nullopt if no match found)
+ --------------------------------------------------------------------*/
+std::optional<LengthType> speckle::serialise::lengthUnitFromName(const String& name) {
+	if (auto match = std::find_if(lengthNames.begin(), lengthNames.end(), [&](const auto& i){ return (i.second == name); });
+			match != lengthNames.end()) {
+		return match->first;
+	}
+	return std::nullopt;
+} //encodingFromName
+
+
+/*--------------------------------------------------------------------
+	Convert a length unit type to a name
+ 
+	lengthType: The length unit type
+ 
+	return: The name of the length unit type (nullopt if no match found)
+  --------------------------------------------------------------------*/
+std::optional<String> speckle::serialise::nameFromLengthUnit(LengthType lengthType) {
+	if (auto match = lengthNames.find(lengthType); match != lengthNames.end()) {
+		return match->second;
+	}
+	return std::nullopt;
+} //nameFromEncoding

SpeckleLib/Speckle/Serialise/Units/LengthUnit.h

@@ -0,0 +1,107 @@
+#ifndef SPECKLE_SERIALISE_LENGTH_UNIT
+#define SPECKLE_SERIALISE_LENGTH_UNIT
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Item/Wrapper/ValueOptionWrap.h"
+#include "Active/Setting/Values/Measurement/Units/LengthUnit.h"
+
+namespace speckle::serialise {
+	
+	/*!
+	 Convert a length unit name to a type
+	 @param name The length unit name
+	 @return The length unit type (nullopt if no match found)
+	 */
+	std::optional<active::measure::LengthType> lengthUnitFromName(const active::utility::String& name);
+
+	
+	/*!
+	 Convert a length unit type to a name
+	 @param lengthType The length unit type
+	 @return The name of the length unit type (nullopt if no match found)
+	 */
+	std::optional<active::utility::String> nameFromLengthUnit(active::measure::LengthType lengthType);
+	
+}
+
+
+namespace active::serialise {
+	
+	// MARK: - Specialisations for length types
+
+	/*!
+	 Read a length type value from the specified string
+	 @param source The string to read
+	 @return True if the data was successfully read
+	*/
+	inline std::pair<active::measure::LengthType, bool> readLengthTypeRefValue(const utility::String& source) {
+		using enum active::measure::LengthType;
+		if (auto converted = speckle::serialise::lengthUnitFromName(source); converted)
+			return {*converted, true};
+		return {metre, false};
+	} //ValueWrap<active::measure::LengthType>::read
+
+
+	/*!
+	 Import the object from the specified string (specialisation for length type)
+	 @param source The string to read
+	 @return True if the data was successfully read
+	*/
+	template<> inline
+	bool ValueWrap<active::measure::LengthType>::read(const utility::String& source) {
+		auto result = readLengthTypeRefValue(source);
+		if (result.second)
+			base::get() = result.first;
+		return result.second;
+	} //ValueWrap<active::measure::LengthType>::read
+	
+
+	/*!
+	 Import the object from the specified string (specialisation for length type)
+	 @param source The string to read
+	 @return True if the data was successfully read
+	*/
+	template<> inline
+	bool ValueOptionWrap<active::measure::LengthType>::read(const utility::String& source) {
+		auto result = readLengthTypeRefValue(source);
+		if (result.second)
+			base::get() = result.first;
+		return result.second;
+	} //ValueWrap<active::measure::LengthType>::read
+
+	
+	/*!
+	 Export the object to the specified string (specialisation for length type)
+	 @param dest The string to write the data to
+	 @return True if the data was successfully written
+	*/
+	template<> inline
+	bool ValueWrap<active::measure::LengthType>::write(utility::String& dest) const {
+		if (auto name = speckle::serialise::nameFromLengthUnit(base::get()); name) {
+			dest = *name;
+			return true;
+		}
+		return false;
+	} //ValueWrap<active::measure::LengthType>::write
+
+	
+	/*!
+	 Export the object to the specified string (specialisation for length type)
+	 @param dest The string to write the data to
+	 @return True if the data was successfully written
+	*/
+	template<> inline
+	bool ValueOptionWrap<active::measure::LengthType>::write(utility::String& dest) const {
+		if (!base::get())
+			return false;
+		if (auto name = speckle::serialise::nameFromLengthUnit(*base::get()); name) {
+			dest = *name;
+			return true;
+		}
+		return false;
+	} //ValueOptionWrap<active::measure::LengthType>::write
+	
+	
+}
+
+#endif	//SPECKLE_SERIALISE_LENGTH_UNIT

SpeckleLib/Speckle/SpeckleResource.h

@@ -14,6 +14,7 @@ enum SpeckleStringResource {
 	//Title strings (UI title/label for dialogs, controls, menu items etc)
 enum SpeckleTitleString {
 	untitledProjectID = 1,
+	unknownElementTypeID,
 };
 
 

SpeckleLib/SpeckleLib.xcodeproj/project.pbxproj

@@ -36,7 +36,19 @@
 		2193519B2C6278D900E5A69C /* SelectionSubscriber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219351992C6278D900E5A69C /* SelectionSubscriber.cpp */; };
 		219351B12C62CC1A00E5A69C /* Guid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219351AC2C62CC1A00E5A69C /* Guid.cpp */; };
 		219351B32C62CC1A00E5A69C /* String.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219351AE2C62CC1A00E5A69C /* String.cpp */; };
+		2196F2E32CB05BAF00450DFC /* LengthUnit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2196F2E22CB05BAF00450DFC /* LengthUnit.cpp */; };
+		2196F2EB2CB4816B00450DFC /* ArchicadAttributeDBaseEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2196F2E82CB4816B00450DFC /* ArchicadAttributeDBaseEngine.cpp */; };
+		2196F2EC2CB4816B00450DFC /* ArchicadAttributeDBaseEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 2196F2E92CB4816B00450DFC /* ArchicadAttributeDBaseEngine.h */; };
+		2196F2F02CB4823C00450DFC /* Attribute.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2196F2ED2CB4823C00450DFC /* Attribute.cpp */; };
+		2196F2F12CB4823C00450DFC /* Attribute.h in Headers */ = {isa = PBXBuildFile; fileRef = 2196F2EE2CB4823C00450DFC /* Attribute.h */; };
+		2196F2F42CB483D600450DFC /* Finish.h in Headers */ = {isa = PBXBuildFile; fileRef = 2196F2F22CB483D600450DFC /* Finish.h */; };
+		2196F2F52CB483D600450DFC /* Finish.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2196F2F32CB483D600450DFC /* Finish.cpp */; };
+		2196F2F82CB51ED400450DFC /* BIMAttributeDatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2196F2F62CB51ED400450DFC /* BIMAttributeDatabase.cpp */; };
+		2196F2F92CB51ED400450DFC /* BIMAttributeDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 2196F2F72CB51ED400450DFC /* BIMAttributeDatabase.h */; };
+		2196F3042CB57E8000450DFC /* Storey.h in Headers */ = {isa = PBXBuildFile; fileRef = 2196F3022CB57E7F00450DFC /* Storey.h */; };
+		2196F3052CB57E8000450DFC /* Storey.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2196F3032CB57E7F00450DFC /* Storey.cpp */; };
 		2199881E2BD833830035E5EA /* libArchicad27.a in CopyFiles */ = {isa = PBXBuildFile; fileRef = 21379E082AE47A6400A1584C /* libArchicad27.a */; };
+		21A0FBA42CB880690023F24E /* FinishCollector.h in Headers */ = {isa = PBXBuildFile; fileRef = 21A0FB9F2CB880690023F24E /* FinishCollector.h */; };
 		21AEF9BA2CA606B5000B8681 /* DetachedReference.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9B92CA606B4000B8681 /* DetachedReference.cpp */; };
 		21AEF9BC2CA6DF84000B8681 /* DetachmentManager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9BB2CA6DF84000B8681 /* DetachmentManager.cpp */; };
 		21AEF9BE2CA6FDA4000B8681 /* DetachedWrap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9BD2CA6FDA4000B8681 /* DetachedWrap.cpp */; };
@@ -162,7 +174,20 @@
 		219351AD2C62CC1A00E5A69C /* Guid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Guid.h; sourceTree = "<group>"; };
 		219351AE2C62CC1A00E5A69C /* String.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = String.cpp; sourceTree = "<group>"; };
 		219351AF2C62CC1A00E5A69C /* String.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = String.h; sourceTree = "<group>"; };
+		2196F2DE2CB0566500450DFC /* LengthUnit.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = LengthUnit.h; sourceTree = "<group>"; };
+		2196F2E22CB05BAF00450DFC /* LengthUnit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LengthUnit.cpp; sourceTree = "<group>"; };
+		2196F2E82CB4816B00450DFC /* ArchicadAttributeDBaseEngine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ArchicadAttributeDBaseEngine.cpp; sourceTree = "<group>"; };
+		2196F2E92CB4816B00450DFC /* ArchicadAttributeDBaseEngine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ArchicadAttributeDBaseEngine.h; sourceTree = "<group>"; };
+		2196F2ED2CB4823C00450DFC /* Attribute.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Attribute.cpp; sourceTree = "<group>"; };
+		2196F2EE2CB4823C00450DFC /* Attribute.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Attribute.h; sourceTree = "<group>"; };
+		2196F2F22CB483D600450DFC /* Finish.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Finish.h; sourceTree = "<group>"; };
+		2196F2F32CB483D600450DFC /* Finish.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Finish.cpp; sourceTree = "<group>"; };
+		2196F2F62CB51ED400450DFC /* BIMAttributeDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BIMAttributeDatabase.cpp; sourceTree = "<group>"; };
+		2196F2F72CB51ED400450DFC /* BIMAttributeDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BIMAttributeDatabase.h; sourceTree = "<group>"; };
+		2196F3022CB57E7F00450DFC /* Storey.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Storey.h; sourceTree = "<group>"; };
+		2196F3032CB57E7F00450DFC /* Storey.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Storey.cpp; sourceTree = "<group>"; };
 		219712682BE7E2D500D9EF7E /* Serialisation.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = Serialisation.md; sourceTree = "<group>"; };
+		21A0FB9F2CB880690023F24E /* FinishCollector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FinishCollector.h; sourceTree = "<group>"; };
 		21AEF9B32CA5F7CF000B8681 /* DetachedWrap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetachedWrap.h; sourceTree = "<group>"; };
 		21AEF9B52CA5FA02000B8681 /* DetachedReference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetachedReference.h; sourceTree = "<group>"; };
 		21AEF9B72CA5FCB6000B8681 /* DetachmentManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetachmentManager.h; sourceTree = "<group>"; };
@@ -267,8 +292,10 @@
 			isa = PBXGroup;
 			children = (
 				2167E27C2C49121F000827D3 /* CMakeLists.txt */,
+				21A0FBA02CB880690023F24E /* Collection */,
 				21AEF9C72CA818EA000B8681 /* Detached */,
 				21F69F3A2C6B880B008B6A06 /* JSBase */,
+				2196F2DF2CB0566500450DFC /* Units */,
 				219712682BE7E2D500D9EF7E /* Serialisation.md */,
 			);
 			path = Serialise;
@@ -319,6 +346,7 @@
 			children = (
 				215F08872CA195EC00CD343B /* ArchicadDBaseCore.cpp */,
 				215F08882CA195EC00CD343B /* ArchicadDBaseCore.h */,
+				2196F2EA2CB4816B00450DFC /* Attribute */,
 				219246062CA2D22D00CF5703 /* Element */,
 			);
 			path = ArchicadDBase;
@@ -407,6 +435,37 @@
 			path = Utility;
 			sourceTree = "<group>";
 		};
+		2196F2DF2CB0566500450DFC /* Units */ = {
+			isa = PBXGroup;
+			children = (
+				2196F2E22CB05BAF00450DFC /* LengthUnit.cpp */,
+				2196F2DE2CB0566500450DFC /* LengthUnit.h */,
+			);
+			path = Units;
+			sourceTree = "<group>";
+		};
+		2196F2EA2CB4816B00450DFC /* Attribute */ = {
+			isa = PBXGroup;
+			children = (
+				2196F2E82CB4816B00450DFC /* ArchicadAttributeDBaseEngine.cpp */,
+				2196F2E92CB4816B00450DFC /* ArchicadAttributeDBaseEngine.h */,
+			);
+			path = Attribute;
+			sourceTree = "<group>";
+		};
+		2196F2EF2CB4823C00450DFC /* Attribute */ = {
+			isa = PBXGroup;
+			children = (
+				2196F2ED2CB4823C00450DFC /* Attribute.cpp */,
+				2196F2EE2CB4823C00450DFC /* Attribute.h */,
+				2196F2F32CB483D600450DFC /* Finish.cpp */,
+				2196F2F22CB483D600450DFC /* Finish.h */,
+				2196F3032CB57E7F00450DFC /* Storey.cpp */,
+				2196F3022CB57E7F00450DFC /* Storey.h */,
+			);
+			path = Attribute;
+			sourceTree = "<group>";
+		};
 		219987FA2BD708BC0035E5EA /* SpeckleLibDoctest */ = {
 			isa = PBXGroup;
 			children = (
@@ -416,6 +475,14 @@
 			path = SpeckleLibDoctest;
 			sourceTree = "<group>";
 		};
+		21A0FBA02CB880690023F24E /* Collection */ = {
+			isa = PBXGroup;
+			children = (
+				21A0FB9F2CB880690023F24E /* FinishCollector.h */,
+			);
+			path = Collection;
+			sourceTree = "<group>";
+		};
 		21AEF9C72CA818EA000B8681 /* Detached */ = {
 			isa = PBXGroup;
 			children = (
@@ -444,6 +511,8 @@
 			children = (
 				21D0BD1D2C86F0280077E104 /* AccountDatabase.cpp */,
 				21D0BD1E2C86F0280077E104 /* AccountDatabase.h */,
+				2196F2F62CB51ED400450DFC /* BIMAttributeDatabase.cpp */,
+				2196F2F72CB51ED400450DFC /* BIMAttributeDatabase.h */,
 				215F08932CA19AF800CD343B /* BIMElementDatabase.cpp */,
 				215F08942CA19AF800CD343B /* BIMElementDatabase.h */,
 				21D0BD272C86FC350077E104 /* Content */,
@@ -580,6 +649,7 @@
 		21F69F952C71087A008B6A06 /* Record */ = {
 			isa = PBXGroup;
 			children = (
+				2196F2EF2CB4823C00450DFC /* Attribute */,
 				215F087A2CA18E1400CD343B /* Element */,
 				21F69F942C71087A008B6A06 /* Credentials */,
 			);
@@ -628,22 +698,28 @@
 				219246032CA2CE2700CF5703 /* BIMLink.h in Headers */,
 				21B67D0D2C7E0E8D00FD64FC /* ErrorReport.h in Headers */,
 				215F08962CA19AF800CD343B /* BIMElementDatabase.h in Headers */,
+				2196F2F12CB4823C00450DFC /* Attribute.h in Headers */,
 				21D0BD332C86FE090077E104 /* Link.h in Headers */,
 				21D0BD5A2C8910400077E104 /* UserInfo.h in Headers */,
 				21D0BD562C890B1C0077E104 /* ServerMigration.h in Headers */,
 				210CC88F2C81A98500610F58 /* Guid64.h in Headers */,
 				21AEF9DD2CAAA4EA000B8681 /* DetachedObjectStore.h in Headers */,
+				21A0FBA42CB880690023F24E /* FinishCollector.h in Headers */,
 				215F088D2CA195EC00CD343B /* ArchicadElementDBaseEngine.h in Headers */,
+				2196F2F42CB483D600450DFC /* Finish.h in Headers */,
 				21B67D002C7CE15100FD64FC /* Exception.h in Headers */,
 				21D0BD2C2C86FC350077E104 /* Record.h in Headers */,
 				21D0BDB42C8F8AB60077E104 /* DocumentStoreCore.h in Headers */,
 				215F087E2CA18E1400CD343B /* Element.h in Headers */,
+				2196F2F92CB51ED400450DFC /* BIMAttributeDatabase.h in Headers */,
 				215F08562C99DA8D00CD343B /* Project.h in Headers */,
 				219245FF2CA2CC4300CF5703 /* BIMRecord.h in Headers */,
 				210CC8802C80CD2A00610F58 /* BridgeChild.h in Headers */,
 				21D0BD4D2C8901A00077E104 /* ServerInfo.h in Headers */,
+				2196F3042CB57E8000450DFC /* Storey.h in Headers */,
 				21D0BDB52C8F8AB60077E104 /* DocumentStoreEngine.h in Headers */,
 				21D0BDC52C9241940077E104 /* ProjectSubscriber.h in Headers */,
+				2196F2EC2CB4816B00450DFC /* ArchicadAttributeDBaseEngine.h in Headers */,
 				21D0BD312C86FE090077E104 /* Index.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -775,18 +851,23 @@
 				21F69F812C6FF3B0008B6A06 /* BridgeArgumentWrap.cpp in Sources */,
 				215F088B2CA195EC00CD343B /* ArchicadDBaseCore.cpp in Sources */,
 				2193517B2C624FC100E5A69C /* MenuSubscriber.cpp in Sources */,
+				2196F2F02CB4823C00450DFC /* Attribute.cpp in Sources */,
 				21F69F612C6D0286008B6A06 /* GetBindingsMethodNames.cpp in Sources */,
 				215F08662C9B006800CD343B /* ProjectEvent.cpp in Sources */,
 				21D0BDBD2C90F2830077E104 /* DocStoreSubscriber.cpp in Sources */,
 				21D0BDB32C8F8AB60077E104 /* DocumentStoreCore.cpp in Sources */,
 				219246082CA2ED2F00CF5703 /* ArchicadElementDBaseEngine.cpp in Sources */,
+				2196F2E32CB05BAF00450DFC /* LengthUnit.cpp in Sources */,
 				21F93AEC2B2F406E009A2C5B /* Addon.cpp in Sources */,
 				215F087D2CA18E1400CD343B /* Element.cpp in Sources */,
+				2196F2F82CB51ED400450DFC /* BIMAttributeDatabase.cpp in Sources */,
 				21D0BD4E2C8901A00077E104 /* ServerInfo.cpp in Sources */,
 				21B67D0E2C7E0E8D00FD64FC /* ErrorReport.cpp in Sources */,
 				21F69F7E2C6FD9FC008B6A06 /* GetCallResult.cpp in Sources */,
+				2196F3052CB57E8000450DFC /* Storey.cpp in Sources */,
 				219245FE2CA2CC4300CF5703 /* BIMRecord.cpp in Sources */,
 				21AEF9BE2CA6FDA4000B8681 /* DetachedWrap.cpp in Sources */,
+				2196F2F52CB483D600450DFC /* Finish.cpp in Sources */,
 				2193519B2C6278D900E5A69C /* SelectionSubscriber.cpp in Sources */,
 				21D0BD2B2C86FC350077E104 /* Record.cpp in Sources */,
 				219246042CA2CE2700CF5703 /* BIMLink.cpp in Sources */,
@@ -801,6 +882,7 @@
 				21AEF9BC2CA6DF84000B8681 /* DetachmentManager.cpp in Sources */,
 				215F08552C99DA8D00CD343B /* Project.cpp in Sources */,
 				21F69F3B2C6B880C008B6A06 /* JSBaseTransport.cpp in Sources */,
+				2196F2EB2CB4816B00450DFC /* ArchicadAttributeDBaseEngine.cpp in Sources */,
 				210CC89F2C81E34400610F58 /* Platform.cpp in Sources */,
 				21D0BD202C86F0280077E104 /* AccountDatabase.cpp in Sources */,
 				21F69F962C71087A008B6A06 /* Account.cpp in Sources */,

SpeckleLib/SpeckleLib17.vcxproj

@@ -20,6 +20,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Speckle\Database\AccountDatabase.h" />
+    <ClInclude Include="Speckle\Database\BIMAttributeDatabase.h" />
     <ClInclude Include="Speckle\Database\BIMElementDatabase.h" />
     <ClInclude Include="Speckle\Database\Content\BIMRecord.h" />
     <ClInclude Include="Speckle\Database\Content\Record.h" />
@@ -29,6 +30,7 @@
     <ClInclude Include="Speckle\Database\Identity\Index.h" />
     <ClInclude Include="Speckle\Database\Identity\Link.h" />
     <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\ArchicadDBaseCore.h" />
+    <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\Attribute\ArchicadAttributeDBaseEngine.h" />
     <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\Element\ArchicadElementDBaseEngine.h" />
     <ClInclude Include="Speckle\Database\Storage\DocumentStore\DocumentStoreCore.h" />
     <ClInclude Include="Speckle\Database\Storage\DocumentStore\DocumentStoreEngine.h" />
@@ -62,6 +64,9 @@
     <ClInclude Include="Speckle\Interface\Browser\NamedFunction.h" />
     <ClInclude Include="Speckle\Interface\Browser\PlatformBinding.h" />
     <ClInclude Include="Speckle\Primitive\Mesh\Mesh.h" />
+    <ClInclude Include="Speckle\Record\Attribute\Attribute.h" />
+    <ClInclude Include="Speckle\Record\Attribute\Finish.h" />
+    <ClInclude Include="Speckle\Record\Attribute\Storey.h" />
     <ClInclude Include="Speckle\Record\Credentials\Account.h" />
     <ClInclude Include="Speckle\Record\Credentials\ServerInfo.h" />
     <ClInclude Include="Speckle\Record\Credentials\ServerMigration.h" />
@@ -73,6 +78,7 @@
     <ClInclude Include="Speckle\Serialise\Detached\Storage\DetachedMemoryStore.h" />
     <ClInclude Include="Speckle\Serialise\Detached\Storage\DetachedObjectStore.h" />
     <ClInclude Include="Speckle\Serialise\JSBase\JSBaseTransport.h" />
+    <ClInclude Include="Speckle\Serialise\Units\LengthUnit.h" />
     <ClInclude Include="Speckle\SpeckleResource.h" />
     <ClInclude Include="Speckle\Utility\Exception.h" />
     <ClInclude Include="Speckle\Utility\Guid.h" />
@@ -82,11 +88,13 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Speckle\Database\AccountDatabase.cpp" />
+    <ClCompile Include="Speckle\Database\BIMAttributeDatabase.cpp" />
     <ClCompile Include="Speckle\Database\BIMElementDatabase.cpp" />
     <ClCompile Include="Speckle\Database\Content\BIMRecord.cpp" />
     <ClCompile Include="Speckle\Database\Content\Record.cpp" />
     <ClCompile Include="Speckle\Database\Identity\BIMLink.cpp" />
     <ClCompile Include="Speckle\Database\Storage\ArchicadDBase\ArchicadDBaseCore.cpp" />
+    <ClCompile Include="Speckle\Database\Storage\ArchicadDBase\Attribute\ArchicadAttributeDBaseEngine.cpp" />
     <ClCompile Include="Speckle\Database\Storage\ArchicadDBase\Element\ArchicadElementDBaseEngine.cpp" />
     <ClCompile Include="Speckle\Database\Storage\DocumentStore\DocumentStoreCore.cpp" />
     <ClCompile Include="Speckle\Environment\Addon.cpp" />
@@ -105,6 +113,9 @@
     <ClCompile Include="Speckle\Interface\Browser\Bridge\Functions\GetCallResult.cpp" />
     <ClCompile Include="Speckle\Interface\Browser\Bridge\Functions\RunMethod.cpp" />
     <ClCompile Include="Speckle\Primitive\Mesh\Mesh.cpp" />
+    <ClCompile Include="Speckle\Record\Attribute\Attribute.cpp" />
+    <ClCompile Include="Speckle\Record\Attribute\Finish.cpp" />
+    <ClCompile Include="Speckle\Record\Attribute\Storey.cpp" />
     <ClCompile Include="Speckle\Record\Credentials\Account.cpp" />
     <ClCompile Include="Speckle\Record\Credentials\ServerInfo.cpp" />
     <ClCompile Include="Speckle\Record\Credentials\ServerMigration.cpp" />
@@ -114,6 +125,7 @@
     <ClCompile Include="Speckle\Serialise\Detached\DetachedWrap.cpp" />
     <ClCompile Include="Speckle\Serialise\Detached\DetachmentManager.cpp" />
     <ClCompile Include="Speckle\Serialise\JSBase\JSBaseTransport.cpp" />
+    <ClCompile Include="Speckle\Serialise\Units\LengthUnit.cpp" />
     <ClCompile Include="Speckle\Utility\Guid.cpp" />
     <ClCompile Include="Speckle\Utility\Guid64.cpp" />
     <ClCompile Include="Speckle\Utility\String.cpp" />

SpeckleLib/SpeckleLib17.vcxproj.filters

@@ -83,6 +83,15 @@
     <Filter Include="Speckle\Serialise\Detached\Storage">
       <UniqueIdentifier>{cb77e795-e8d8-4e31-9773-dd32beb694d3}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Speckle\Serialise\Units">
+      <UniqueIdentifier>{7d5ec9ba-bc7e-412c-9b14-16c37b183409}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Speckle\Database\Storage\ArchicadDBase\Attribute">
+      <UniqueIdentifier>{490a65bd-28e3-4282-bb33-67823e81e825}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Speckle\Record\Attribute">
+      <UniqueIdentifier>{525b6bd6-96e4-48c8-91e9-9710e1e54389}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Speckle\Environment\Addon.h">
@@ -265,6 +274,24 @@
     <ClInclude Include="Speckle\Serialise\Detached\Storage\DetachedObjectStore.h">
       <Filter>Speckle\Serialise\Detached\Storage</Filter>
     </ClInclude>
+    <ClInclude Include="Speckle\Serialise\Units\LengthUnit.h">
+      <Filter>Speckle\Serialise\Units</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\BIMAttributeDatabase.h">
+      <Filter>Speckle\Database</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\Attribute\ArchicadAttributeDBaseEngine.h">
+      <Filter>Speckle\Database\Storage\ArchicadDBase\Attribute</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Record\Attribute\Attribute.h">
+      <Filter>Speckle\Record\Attribute</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Record\Attribute\Finish.h">
+      <Filter>Speckle\Record\Attribute</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Record\Attribute\Storey.h">
+      <Filter>Speckle\Record\Attribute</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Speckle\Environment\Addon.cpp">
@@ -375,6 +402,24 @@
     <ClCompile Include="Speckle\Serialise\Detached\DetachmentManager.cpp">
       <Filter>Speckle\Serialise\Detached</Filter>
     </ClCompile>
+    <ClCompile Include="Speckle\Serialise\Units\LengthUnit.cpp">
+      <Filter>Speckle\Serialise\Units</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Database\BIMAttributeDatabase.cpp">
+      <Filter>Speckle\Database</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Database\Storage\ArchicadDBase\Attribute\ArchicadAttributeDBaseEngine.cpp">
+      <Filter>Speckle\Database\Storage\ArchicadDBase\Attribute</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Record\Attribute\Attribute.cpp">
+      <Filter>Speckle\Record\Attribute</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Record\Attribute\Finish.cpp">
+      <Filter>Speckle\Record\Attribute</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Record\Attribute\Storey.cpp">
+      <Filter>Speckle\Record\Attribute</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Text Include="Speckle\CMakeLists.txt">