Parse

UI/ViewPane/SmartViewPane.cpp

@@ -181,7 +181,7 @@ namespace viewpane
 
 		const auto iStructType = static_cast<parserType>(GetDropDownSelectionValue());
 		auto szSmartViewArray = std::vector<std::wstring>{};
-		treeData = std::make_shared<smartview::block>();
+		treeData = smartview::block::create();
 		auto svp = smartview::GetSmartViewParser(iStructType, nullptr);
 		auto source = 0;
 		for (auto& bin : m_bins)
@@ -191,22 +191,21 @@ namespace viewpane
 			{
 				svp->init(bin.size(), bin.data());
 				parsedData = svp->toString();
-				auto node = svp->getBlock();
-				node->setSource(source++);
+				svp->setSource(source++);
 				if (m_bins.size() == 1)
 				{
-					treeData = node;
+					treeData = svp;
 				}
 				else
 				{
-					treeData->addChild(node);
+					treeData->addChild(svp);
 				}
 			}
 
 			if (parsedData.empty())
 			{
-				parsedData =
-					smartview::InterpretBinaryAsString(SBinary{static_cast<ULONG>(bin.size()), bin.data()}, iStructType, nullptr);
+				parsedData = smartview::InterpretBinaryAsString(
+					SBinary{static_cast<ULONG>(bin.size()), bin.data()}, iStructType, nullptr);
 			}
 
 			szSmartViewArray.push_back(parsedData);

UI/ViewPane/SmartViewPane.h

@@ -2,7 +2,7 @@
 #include <UI/ViewPane/DropDownPane.h>
 #include <UI/ViewPane/SplitterPane.h>
 #include <UI/ViewPane/TreePane.h>
-#include <core/smartview/smartViewParser.h>
+#include <core/smartview/block/block.h>
 
 enum class parserType;
 
@@ -39,7 +39,7 @@ namespace viewpane
 			int iEditHeight) override; // height of an edit control
 
 		std::vector<std::vector<BYTE>> m_bins;
-		std::shared_ptr<smartview::block> treeData = std::make_shared<smartview::block>();
+		std::shared_ptr<smartview::block> treeData = smartview::block::create();
 		std::shared_ptr<SplitterPane> m_Splitter;
 		std::shared_ptr<TreePane> m_TreePane;
 		bool m_bHasData{false};

UnitTest/tests/blocktest.cpp

@@ -17,9 +17,9 @@ namespace blocktest
 		TEST_CLASS_INITIALIZE(initialize) { unittest::init(); }
 		TEST_METHOD(Test_block)
 		{
-			auto block1 = std::make_shared<smartview::block>(L"test");
-			auto block2 = std::make_shared<smartview::block>(L"block2");
-			auto block3 = std::make_shared<smartview::block>(L"");
+			auto block1 = smartview::block::create(L"test");
+			auto block2 = smartview::block::create(L"block2");
+			auto block3 = smartview::block::create(L"");
 			Assert::AreEqual(block1->isHeader(), true);
 			block1->setSize(5);
 			Assert::AreEqual(block1->isHeader(), false);
@@ -52,8 +52,7 @@ namespace blocktest
 
 			block1->addBlankLine();
 			block1->addLabeledChild(L"Label: ", block2);
-			Assert::AreEqual(
-				block1->toString(), std::wstring(L"hello world this that\r\nblock2\r\n\r\nLabel: block2\r\n"));
+			Assert::AreEqual(block1->toString(), std::wstring(L"hello world this that\r\nblock2\r\n\r\nLabel: block2"));
 
 			Assert::AreEqual(block3->hasData(), false);
 			block3->addChild(block1);
@@ -67,15 +66,13 @@ namespace blocktest
 		{
 			auto block1 = std::make_shared<smartview::blockStringA>();
 			Assert::AreEqual(block1->isSet(), false);
-			auto block2 = std::make_shared<smartview::blockStringA>(std::string("test"), 4, 5);
-			Assert::AreEqual(block2->length(), size_t(4));
 		}
 
 		TEST_METHOD(Test_blockStringW)
 		{
 			auto block1 = std::make_shared<smartview::blockStringW>();
 			Assert::AreEqual(block1->isSet(), false);
-			auto block2 = std::make_shared<smartview::blockStringW>(std::wstring(L"test"), 4, 5);
+			auto block2 = smartview::blockStringW::parse(std::wstring(L"test"), 4, 5);
 			Assert::AreEqual(block2->length(), size_t(4));
 		}
 	};

core/core.vcxproj

@@ -575,7 +575,8 @@
     <ClInclude Include="res\Resource.h" />
     <ClInclude Include="smartview\AdditionalRenEntryIDs.h" />
     <ClInclude Include="smartview\AppointmentRecurrencePattern.h" />
-    <ClInclude Include="smartview\binaryParser.h" />
+    <ClInclude Include="smartview\block\scratchBlock.h" />
+    <ClInclude Include="smartview\block\binaryParser.h" />
     <ClInclude Include="smartview\block\block.h" />
     <ClInclude Include="smartview\block\blockBytes.h" />
     <ClInclude Include="smartview\block\blockPV.h" />
@@ -602,7 +603,6 @@
     <ClInclude Include="smartview\SearchFolderDefinition.h" />
     <ClInclude Include="smartview\SIDBin.h" />
     <ClInclude Include="smartview\SmartView.h" />
-    <ClInclude Include="smartview\smartViewParser.h" />
     <ClInclude Include="smartview\TaskAssigners.h" />
     <ClInclude Include="smartview\TimeZone.h" />
     <ClInclude Include="smartview\TimeZoneDefinition.h" />
@@ -680,7 +680,7 @@
     <ClCompile Include="smartview\SearchFolderDefinition.cpp" />
     <ClCompile Include="smartview\SIDBin.cpp" />
     <ClCompile Include="smartview\SmartView.cpp" />
-    <ClCompile Include="smartview\smartViewParser.cpp" />
+    <ClCompile Include="smartview\block\block.cpp" />
     <ClCompile Include="smartview\TaskAssigners.cpp" />
     <ClCompile Include="smartview\TimeZone.cpp" />
     <ClCompile Include="smartview\TimeZoneDefinition.cpp" />

core/core.vcxproj.filters

@@ -228,9 +228,6 @@
     <ClInclude Include="mapi\mapiStoreFunctions.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="smartview\binaryParser.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="mapi\processor\mapiProcessor.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -252,9 +249,6 @@
     <ClInclude Include="utility\cli.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="smartview\smartViewParser.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="sortlistdata\binaryData.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -306,6 +300,12 @@
     <ClInclude Include="smartview\block\blockPV.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="smartview\block\binaryParser.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="smartview\block\scratchBlock.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="utility\strings.cpp">
@@ -488,9 +488,6 @@
     <ClCompile Include="utility\cli.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="smartview\smartViewParser.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="sortlistdata\binaryData.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -533,6 +530,9 @@
     <ClCompile Include="smartview\SPropValueStruct.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="smartview\block\block.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="res\MFCMapi.rc2">

core/smartview/AdditionalRenEntryIDs.cpp

@@ -20,27 +20,27 @@ namespace smartview
 	{
 		WORD wPersistDataCount = 0;
 		// Run through the parser once to count the number of PersistData structs
-		while (m_Parser->getSize() >= 2 * sizeof(WORD))
+		while (parser->getSize() >= 2 * sizeof(WORD))
 		{
-			const auto& wPersistID = blockT<WORD>::parse(m_Parser);
-			const auto& wDataElementSize = blockT<WORD>::parse(m_Parser);
+			const auto& wPersistID = blockT<WORD>::parse(parser);
+			const auto& wDataElementSize = blockT<WORD>::parse(parser);
 			// Must have at least wDataElementSize bytes left to be a valid data element
-			if (m_Parser->getSize() < *wDataElementSize) break;
+			if (parser->getSize() < *wDataElementSize) break;
 
-			m_Parser->advance(*wDataElementSize);
+			parser->advance(*wDataElementSize);
 			wPersistDataCount++;
 			if (wPersistID == PersistData::PERISIST_SENTINEL) break;
 		}
 
 		// Now we parse for real
-		m_Parser->rewind();
+		parser->rewind();
 
 		if (wPersistDataCount && wPersistDataCount < _MaxEntriesSmall)
 		{
 			m_ppdPersistData.reserve(wPersistDataCount);
 			for (WORD iPersistElement = 0; iPersistElement < wPersistDataCount; iPersistElement++)
 			{
-				m_ppdPersistData.emplace_back(std::make_shared<PersistData>(m_Parser));
+				m_ppdPersistData.emplace_back(std::make_shared<PersistData>(parser));
 			}
 		}
 	}
@@ -92,7 +92,7 @@ namespace smartview
 
 	void AdditionalRenEntryIDs::parseBlocks()
 	{
-		setRoot(L"Additional Ren Entry IDs\r\n");
+		setText(L"Additional Ren Entry IDs\r\n");
 		addHeader(L"PersistDataCount = %1!d!", m_ppdPersistData.size());
 
 		if (!m_ppdPersistData.empty())
@@ -102,10 +102,9 @@ namespace smartview
 			{
 				terminateBlock();
 				addBlankLine();
-				auto element = std::make_shared<block>();
+				auto element = create(L"Persist Element %1!d!:\r\n", iPersistElement);
 				addChild(element);
 
-				element->setText(L"Persist Element %1!d!:\r\n", iPersistElement);
 				element->addChild(
 					persistData->wPersistID,
 					L"PersistID = 0x%1!04X! = %2!ws!\r\n",
@@ -122,8 +121,7 @@ namespace smartview
 					for (const auto& dataElement : persistData->ppeDataElement)
 					{
 						element->terminateBlock();
-						auto de =
-							std::make_shared<block>(strings::formatmessage(L"DataElement: %1!d!\r\n", iDataElement));
+						auto de = create(L"DataElement: %1!d!\r\n", iDataElement);
 						element->addChild(de);
 
 						de->addChild(

core/smartview/AdditionalRenEntryIDs.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <core/smartview/smartViewParser.h>
+#include <core/smartview/block/block.h>
 #include <core/smartview/block/blockBytes.h>
 #include <core/smartview/block/blockT.h>
 
@@ -27,7 +27,7 @@ namespace smartview
 		PersistData(const std::shared_ptr<binaryParser>& parser);
 	};
 
-	class AdditionalRenEntryIDs : public smartViewParser
+	class AdditionalRenEntryIDs : public block
 	{
 	private:
 		void parse() override;

core/smartview/AppointmentRecurrencePattern.cpp

@@ -119,50 +119,49 @@ namespace smartview
 
 	void AppointmentRecurrencePattern::parse()
 	{
-		m_RecurrencePattern.smartViewParser::parse(m_Parser, false);
+		m_RecurrencePattern = block::parse<RecurrencePattern>(parser, false);
 
-		m_ReaderVersion2 = blockT<DWORD>::parse(m_Parser);
-		m_WriterVersion2 = blockT<DWORD>::parse(m_Parser);
-		m_StartTimeOffset = blockT<DWORD>::parse(m_Parser);
-		m_EndTimeOffset = blockT<DWORD>::parse(m_Parser);
-		m_ExceptionCount = blockT<WORD>::parse(m_Parser);
+		m_ReaderVersion2 = blockT<DWORD>::parse(parser);
+		m_WriterVersion2 = blockT<DWORD>::parse(parser);
+		m_StartTimeOffset = blockT<DWORD>::parse(parser);
+		m_EndTimeOffset = blockT<DWORD>::parse(parser);
+		m_ExceptionCount = blockT<WORD>::parse(parser);
 
-		if (*m_ExceptionCount && *m_ExceptionCount == *m_RecurrencePattern.m_ModifiedInstanceCount &&
+		if (*m_ExceptionCount && *m_ExceptionCount == *m_RecurrencePattern->m_ModifiedInstanceCount &&
 			*m_ExceptionCount < _MaxEntriesSmall)
 		{
 			m_ExceptionInfo.reserve(*m_ExceptionCount);
 			for (WORD i = 0; i < *m_ExceptionCount; i++)
 			{
-				m_ExceptionInfo.emplace_back(std::make_shared<ExceptionInfo>(m_Parser));
+				m_ExceptionInfo.emplace_back(std::make_shared<ExceptionInfo>(parser));
 			}
 		}
 
-		m_ReservedBlock1Size = blockT<DWORD>::parse(m_Parser);
-		m_ReservedBlock1 = blockBytes::parse(m_Parser, *m_ReservedBlock1Size, _MaxBytes);
+		m_ReservedBlock1Size = blockT<DWORD>::parse(parser);
+		m_ReservedBlock1 = blockBytes::parse(parser, *m_ReservedBlock1Size, _MaxBytes);
 
-		if (*m_ExceptionCount && *m_ExceptionCount == *m_RecurrencePattern.m_ModifiedInstanceCount &&
+		if (*m_ExceptionCount && *m_ExceptionCount == *m_RecurrencePattern->m_ModifiedInstanceCount &&
 			*m_ExceptionCount < _MaxEntriesSmall && !m_ExceptionInfo.empty())
 		{
 			for (WORD i = 0; i < *m_ExceptionCount; i++)
 			{
-				m_ExtendedException.emplace_back(std::make_shared<ExtendedException>(
-					m_Parser, *m_WriterVersion2, *m_ExceptionInfo[i]->OverrideFlags));
+				m_ExtendedException.emplace_back(
+					std::make_shared<ExtendedException>(parser, *m_WriterVersion2, *m_ExceptionInfo[i]->OverrideFlags));
 			}
 		}
 
-		m_ReservedBlock2Size = blockT<DWORD>::parse(m_Parser);
-		m_ReservedBlock2 = blockBytes::parse(m_Parser, *m_ReservedBlock2Size, _MaxBytes);
+		m_ReservedBlock2Size = blockT<DWORD>::parse(parser);
+		m_ReservedBlock2 = blockBytes::parse(parser, *m_ReservedBlock2Size, _MaxBytes);
 	}
 
 	void AppointmentRecurrencePattern::parseBlocks()
 	{
-		setRoot(m_RecurrencePattern.getBlock());
+		addChild(m_RecurrencePattern);
 		terminateBlock();
 
-		auto arpBlock = std::make_shared<block>();
+		auto arpBlock = create(L"Appointment Recurrence Pattern: \r\n");
 		addChild(arpBlock);
 
-		arpBlock->setText(L"Appointment Recurrence Pattern: \r\n");
 		arpBlock->addChild(m_ReaderVersion2, L"ReaderVersion2: 0x%1!08X!\r\n", m_ReaderVersion2->getData());
 		arpBlock->addChild(m_WriterVersion2, L"WriterVersion2: 0x%1!08X!\r\n", m_WriterVersion2->getData());
 		arpBlock->addChild(
@@ -184,7 +183,7 @@ namespace smartview
 			auto i = 0;
 			for (const auto& info : m_ExceptionInfo)
 			{
-				auto exception = std::make_shared<block>();
+				auto exception = create();
 				m_ExceptionCount->addChild(exception);
 
 				exception->addChild(
@@ -331,7 +330,7 @@ namespace smartview
 			auto i = UINT{};
 			for (const auto& ee : m_ExtendedException)
 			{
-				auto exception = std::make_shared<block>();
+				auto exception = create();
 				arpBlock->addChild(exception);
 
 				if (*m_WriterVersion2 >= 0x00003009)

core/smartview/AppointmentRecurrencePattern.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <core/smartview/smartViewParser.h>
+#include <core/smartview/block/block.h>
 #include <core/smartview/RecurrencePattern.h>
 #include <core/smartview/block/blockStringA.h>
 #include <core/smartview/block/blockStringW.h>
@@ -66,13 +66,13 @@ namespace smartview
 	// =====================
 	//   This structure specifies a recurrence pattern for a calendar object
 	//   including information about exception property values.
-	class AppointmentRecurrencePattern : public smartViewParser
+	class AppointmentRecurrencePattern : public block
 	{
 	private:
 		void parse() override;
 		void parseBlocks() override;
 
-		RecurrencePattern m_RecurrencePattern;
+		std::shared_ptr<RecurrencePattern> m_RecurrencePattern;
 		std::shared_ptr<blockT<DWORD>> m_ReaderVersion2 = emptyT<DWORD>();
 		std::shared_ptr<blockT<DWORD>> m_WriterVersion2 = emptyT<DWORD>();
 		std::shared_ptr<blockT<DWORD>> m_StartTimeOffset = emptyT<DWORD>();