release 1.4.3

Author: jagt

DataConfig/Source/DataConfigCore/Private/DataConfig/Deserialize/DcDeserializeUtils.cpp

@@ -22,6 +22,14 @@ FDcResult RecursiveDeserialize(FDcDeserializeContext& Ctx)
 	return DcOk();
 }
 
+EDcDeserializePredicateResult PredicateIsRootProperty(FDcDeserializeContext& Ctx)
+{
+	check(Ctx.Properties.Num() > 0);
+    return Ctx.TopProperty() == Ctx.Properties[0]
+        ? EDcDeserializePredicateResult::Process
+        : EDcDeserializePredicateResult::Pass;
+}
+
 } // namespace DcDeserializeUtils
 
 

DataConfig/Source/DataConfigCore/Private/DataConfig/Diagnostic/DcDiagnosticSerDe.cpp

@@ -7,10 +7,10 @@ namespace DcDSerDe
 struct FDcDiagnosticDetail _DeserializeDetails[] = {
 	{ NoMatchingHandler, TEXT("No matching handler, Property: '{0}' '{1}'"), },
 	{ MismatchHandler, TEXT("Mismatched handler, Property: '{0}' '{1}'"), },
-	{ NotPrepared, TEXT("Deserialize isn't prepared, need to call 'Ctx.Prepare'"), },
-	{ DataEntryMismatch, TEXT("Deserialize type mismatch, Expect: '{0}', Actual: '{1}'"), },
-	{ DataEntryMismatch2, TEXT("Deserialize type mismatch, Expect: '{0}'/'{1}', Actual: '{2}'"), },
-	{ DataEntryMismatch3, TEXT("Deserialize type mismatch, Expect: '{0}'/'{1}'/'{2}', Actual: {3}"), },
+	{ NotPrepared, TEXT("Context isn't prepared, need to call 'Ctx.Prepare'"), },
+	{ DataEntryMismatch, TEXT("Type mismatch, Expect: '{0}', Actual: '{1}'"), },
+	{ DataEntryMismatch2, TEXT("Type mismatch, Expect: '{0}'/'{1}', Actual: '{2}'"), },
+	{ DataEntryMismatch3, TEXT("Type mismatch, Expect: '{0}'/'{1}'/'{2}', Actual: {3}"), },
 	{ ExpectMetaType, TEXT("Expect '$type' but not found")},
 	{ ExpectNumericEntry, TEXT("Expect numeric data but not found, Actual: '{0}'")},
 	{ CoercionFail, TEXT("Reader coercion failed, Actual: '{0}'")},

DataConfig/Source/DataConfigCore/Private/DataConfig/Json/DcJsonReader.cpp

@@ -308,6 +308,7 @@ FDcResult TDcJsonReader<CharType>::FinishRead()
 
 	EDcDataEntry Next;
 	DC_TRY(PeekRead(&Next));
+
 	if (Next != EDcDataEntry::Ended)
 	{
 		return DC_FAIL(DcDJSON, UnexpectedTrailingToken) 
@@ -316,8 +317,19 @@ FDcResult TDcJsonReader<CharType>::FinishRead()
 	}
 	else
 	{
-		check(State == EState::FinishedStr);
-		return DcOk();
+		if (GetTopState() == EParseState::Object)
+		{
+			return DC_FAIL(DcDJSON, EndUnclosedObject) << FormatHighlight(Cur, 0);
+		}
+		else if (GetTopState() == EParseState::Array)
+		{
+			return DC_FAIL(DcDJSON, EndUnclosedArray) << FormatHighlight(Cur, 0);
+		}
+		else
+		{
+			check(State == EState::FinishedStr);
+			return DcOk();
+		}
 	}
 }
 
@@ -917,7 +929,7 @@ FDcResult TDcJsonReader<CharType>::CheckConsumeToken(EDcDataEntry Expect)
 				<< FormatHighlight(Token.Ref);
 	}
 
-	//	setting need consume token for the next one
+	//	setting need consume token for the next one when not at end
 	bNeedConsumeToken = true;
 	return DcOk();
 }
@@ -948,8 +960,9 @@ FDcResult TDcJsonReader<CharType>::EndTopRead()
 			DC_TRY(ConsumeEffectiveToken());
 			bTopObjectAtValue = false;
 
-			//	allowing optional trailing comma
-			if (Token.Type == ETokenType::Comma)
+			if (Token.Type == ETokenType::Comma // allowing optional trailing comma
+				|| Token.Type == ETokenType::EOF_) // allowing root level object
+				
 			{
 				return DcOk();
 			}
@@ -969,7 +982,8 @@ FDcResult TDcJsonReader<CharType>::EndTopRead()
 		FToken Prev = Token;
 		DC_TRY(ConsumeEffectiveToken());
 
-		if (Token.Type == ETokenType::Comma)
+		if (Token.Type == ETokenType::Comma // allowing optional trailing comma
+			|| Token.Type == ETokenType::EOF_) // allowing root level array
 		{
 			return DcOk();
 		}
@@ -1101,21 +1115,11 @@ FDcResult TDcJsonReader<CharType>::ConsumeRawToken()
 
 	if (IsAtEnd())
 	{
-		if (GetTopState() == EParseState::Object)
-		{
-			return DC_FAIL(DcDJSON, EndUnclosedObject) << FormatHighlight(Cur, 1);
-		}
-		else if (GetTopState() == EParseState::Array)
-		{
-			return DC_FAIL(DcDJSON, EndUnclosedArray) << FormatHighlight(Cur, 1);
-		}
-		else
-		{
-			Token.Type = ETokenType::EOF_;
-			//	keep the token for diagnostic highlight
-			State = EState::FinishedStr;
-			return DcOk();
-		}
+		Token.Type = ETokenType::EOF_;
+		//	keep the token for diagnostic highlight
+		State = EState::FinishedStr;
+		bNeedConsumeToken = false;
+		return DcOk();
 	}
 
 	auto _ConsumeSingleCharToken = [this](ETokenType TokenType) {

DataConfig/Source/DataConfigCore/Private/DataConfig/Serialize/DcSerializeUtils.cpp

@@ -22,5 +22,13 @@ FDcResult RecursiveSerialize(FDcSerializeContext& Ctx)
 	return DcOk();
 }
 
+EDcSerializePredicateResult PredicateIsRootProperty(FDcSerializeContext& Ctx)
+{
+	check(Ctx.Properties.Num() > 0);
+    return Ctx.TopProperty() == Ctx.Properties[0]
+        ? EDcSerializePredicateResult::Process
+        : EDcSerializePredicateResult::Pass;
+}
+
 } // namespace DcSerializeUtils
 

DataConfig/Source/DataConfigCore/Public/DataConfig/DcVersion.h

@@ -1,4 +1,4 @@
 #pragma once
 
-#define DATA_CONFIG_CORE_VERSION "1.4.2"
-#define DATA_CONFIG_CORE_VERSION_NUMBER 10402
+#define DATA_CONFIG_CORE_VERSION "1.4.3"
+#define DATA_CONFIG_CORE_VERSION_NUMBER 10403

DataConfig/Source/DataConfigCore/Public/DataConfig/Deserialize/DcDeserializeUtils.h

@@ -17,6 +17,8 @@ EDcDeserializePredicateResult PredicateIsUStruct(FDcDeserializeContext& Ctx)
 		? EDcDeserializePredicateResult::Process
 		: EDcDeserializePredicateResult::Pass;
 }
+
+DATACONFIGCORE_API EDcDeserializePredicateResult PredicateIsRootProperty(FDcDeserializeContext& Ctx);
 
 } // namespace DcDeserializeUtils
 

DataConfig/Source/DataConfigCore/Public/DataConfig/Diagnostic/DcDiagnostic.h

@@ -42,15 +42,15 @@ struct DATACONFIGCORE_API FDcDiagnostic
 };
 
 template<typename T>
-FORCEINLINE typename TEnableIf<!TIsEnumClass<T>::Value, FDcDiagnostic&>::Type
+typename TEnableIf<!TIsEnumClass< typename TRemoveReference<T>::Type >::Value, FDcDiagnostic&>::Type
 operator<<(FDcDiagnostic& Diag, T&& InValue)
 {
 	Diag.Args.Emplace(Forward<T>(InValue));
 	return Diag;
 }
 
 template<typename T>
-FORCEINLINE typename TEnableIf<TIsEnumClass<T>::Value, FDcDiagnostic&>::Type
+typename TEnableIf<TIsEnumClass< typename TRemoveReference<T>::Type >::Value, FDcDiagnostic&>::Type
 operator<<(FDcDiagnostic& Diag, T&& InValue)
 {
 	Diag.Args.Emplace((int)(InValue));

DataConfig/Source/DataConfigCore/Public/DataConfig/Serialize/DcSerializeUtils.h

@@ -18,6 +18,8 @@ EDcSerializePredicateResult PredicateIsUStruct(FDcSerializeContext& Ctx)
 		? EDcSerializePredicateResult::Process
 		: EDcSerializePredicateResult::Pass;
 }
+
+DATACONFIGCORE_API EDcSerializePredicateResult PredicateIsRootProperty(FDcSerializeContext& Ctx);
 
 } // namespace DcSerializeUtils
 

DataConfig/Source/DataConfigExtra/Private/DataConfig/Extra/Diagnostic/DcDiagnosticExtra.cpp

@@ -15,6 +15,12 @@ static FDcDiagnosticDetail _ExtraDetails[] = {
 	//	InlineStruct
 	{ InlineStructTooBig, TEXT("Inline struct too big: BufSize '{0}', Struct '{1}' Size '{2}'"), },
 	{ InlineStructNotSet, TEXT("Inline struct not set"), },
+
+	//	Nested
+	{ NestedMissingMetaData, TEXT("Nested missing metadata: '{0}'"), },
+	{ NestedGrid2DHeightMismatch, TEXT("Nested Grid2D height mismatch, Expect '{0}'"), },
+	{ NestedGrid2DWidthMismatch, TEXT("Nested Grid2D width mismatch, Expect '{0}'"), },
+	{ NestedGrid2DLenMismatch, TEXT("Nested Grid2D total length mismatch, Expect '{0}', Actual: '{1}'"), },
 };
 
  FDcDiagnosticGroup Details = {

DataConfig/Source/DataConfigExtra/Private/DataConfig/Extra/Misc/DcNDJSON.cpp

@@ -0,0 +1,177 @@
+#include "DataConfig/Extra/Misc/DcNDJSON.h"
+#include "DataConfig/Deserialize/DcDeserializeTypes.h"
+#include "DataConfig/Deserialize/DcDeserializeUtils.h"
+#include "DataConfig/Deserialize/DcDeserializerSetup.h"
+#include "DataConfig/Serialize/DcSerializer.h"
+#include "DataConfig/Serialize/DcSerializerSetup.h"
+#include "DataConfig/Serialize/DcSerializeUtils.h"
+#include "DataConfig/Diagnostic/DcDiagnosticReadWrite.h"
+
+#include "DataConfig/Automation/DcAutomation.h"
+#include "DataConfig/Automation/DcAutomationUtils.h"
+#include "DataConfig/Extra/Misc/DcTestCommon.h"
+#include "DataConfig/Json/DcJsonReader.h"
+#include "DataConfig/Json/DcJsonWriter.h"
+#include "DataConfig/Serialize/DcSerializeUtils.h"
+#include "DataConfig/Deserialize/DcDeserializeUtils.h"
+#include "DataConfig/Extra/Types/DcExtraTestFixtures.h"
+
+namespace DcExtra
+{
+
+namespace NDJSONDetails
+{
+
+static TOptional<FDcDeserializer> Deserializer;
+static void LazyInitializeDeserializer()
+{
+    if (Deserializer.IsSet())
+        return;
+    
+    Deserializer.Emplace();
+    DcSetupJsonDeserializeHandlers(Deserializer.GetValue());
+
+    Deserializer->AddPredicatedHandler(
+        FDcDeserializePredicate::CreateStatic(DcDeserializeUtils::PredicateIsRootProperty),
+        FDcDeserializeDelegate::CreateLambda([](FDcDeserializeContext& Ctx) -> FDcResult
+        {
+            if (!Ctx.TopProperty().IsA<FArrayProperty>())
+                return DC_FAIL(DcDReadWrite, PropertyMismatch)
+                    << TEXT("Array") << Ctx.TopProperty().GetFName() << Ctx.TopProperty().GetClassName();
+
+            DC_TRY(Ctx.Writer->WriteArrayRoot());
+            EDcDataEntry CurPeek;
+            while (true)
+            {
+                DC_TRY(Ctx.Reader->PeekRead(&CurPeek));
+                //  read until EOF as we're processing ndjson
+                if (CurPeek == EDcDataEntry::Ended)
+                    break;
+
+                DC_TRY(DcDeserializeUtils::RecursiveDeserialize(Ctx));
+            }
+
+            DC_TRY(Ctx.Writer->WriteArrayEnd());
+            return DcOk();
+        })
+    );
+}
+
+
+static TOptional<FDcSerializer> Serializer;
+static void LazyInitializeSerializer()
+{
+    if (Serializer.IsSet())
+        return;
+
+    Serializer.Emplace();
+    DcSetupJsonSerializeHandlers(Serializer.GetValue());
+
+    Serializer->AddPredicatedHandler(
+        FDcSerializePredicate::CreateStatic(DcSerializeUtils::PredicateIsRootProperty),
+        FDcSerializeDelegate::CreateLambda([](FDcSerializeContext& Ctx) -> FDcResult{
+            if (!Ctx.TopProperty().IsA<FArrayProperty>())
+                return DC_FAIL(DcDReadWrite, PropertyMismatch)
+                    << TEXT("Array") << Ctx.TopProperty().GetFName() << Ctx.TopProperty().GetClassName();
+
+            FDcJsonWriter* JsonWriter = Ctx.Writer->CastByIdChecked<FDcJsonWriter>();
+
+            DC_TRY(Ctx.Reader->ReadArrayRoot());
+
+            EDcDataEntry CurPeek;
+            while (true)
+            {
+                DC_TRY(Ctx.Reader->PeekRead(&CurPeek));
+                if (CurPeek == EDcDataEntry::ArrayEnd)
+                    break;
+
+                DC_TRY(DcSerializeUtils::RecursiveSerialize(Ctx));
+
+                JsonWriter->CancelWriteComma();
+                JsonWriter->Sb << TCHAR('\n');
+            }
+
+            DC_TRY(Ctx.Reader->ReadArrayEnd());
+
+            return DcOk();
+        })
+    );
+}
+
+} // namespace NDJSONDetails
+
+FDcResult LoadNDJSON(const TCHAR* Str, FDcPropertyDatum Datum)
+{
+    using namespace NDJSONDetails;
+
+    FDcJsonReader Reader(Str);
+    FDcPropertyWriter Writer(Datum);
+
+    LazyInitializeDeserializer();
+
+    FDcDeserializeContext Ctx;
+    Ctx.Reader = &Reader;
+    Ctx.Writer = &Writer;
+    Ctx.Deserializer = &Deserializer.GetValue();
+    Ctx.Properties.Add(Datum.Property);
+    DC_TRY(Ctx.Prepare());
+    DC_TRY(Deserializer->Deserialize(Ctx));
+
+    return DcOk();
+}
+
+
+FDcResult SaveNDJSON(FDcPropertyDatum Datum, FString& OutStr)
+{
+    using namespace NDJSONDetails;
+
+    FDcJsonWriter::ConfigType Config = {
+        TEXT(" "),
+        TEXT(" "),
+        TEXT(""),
+        TEXT(" "),
+        false,
+        false
+    };
+
+    FDcJsonWriter Writer(Config);
+    FDcPropertyReader Reader(Datum);
+
+    LazyInitializeSerializer();
+
+    FDcSerializeContext Ctx;
+    Ctx.Reader = &Reader;
+    Ctx.Writer = &Writer;
+    Ctx.Serializer = &Serializer.GetValue();
+    DC_TRY(Ctx.Prepare());
+    DC_TRY(Serializer->Serialize(Ctx));
+
+    OutStr = Writer.Sb.ToString();
+    return DcOk();
+}
+
+} // namespace DcExtra
+
+DC_TEST("DataConfig.Extra.SerDe.NDJSON")
+{
+    using namespace DcExtra;
+
+    TArray<FDcExtraSimpleStruct> Dest;
+
+    FString Str = TEXT(R"(
+
+        { "Name" : "Foo", "Id" : 1, "Type" : "Alpha" }
+        { "Name" : "Bar", "Id" : 2, "Type" : "Beta" }
+        { "Name" : "Baz", "Id" : 3, "Type" : "Gamma" }
+
+    )");
+
+
+    UTEST_OK("Extra NDJSON", LoadNDJSON(*Str, Dest));
+
+    FString SavedStr;
+    UTEST_OK("Extra NDJSON", SaveNDJSON(Dest, SavedStr));
+
+    UTEST_EQUAL("Extra NDJSON", SavedStr, DcAutomationUtils::DcReindentStringLiteral(Str));
+    return true;
+};