From 2a83e49ae7e9669a51224c76ab57be80e8050706 Mon Sep 17 00:00:00 2001
From: Michael Davidsaver <mdavidsaver@gmail.com>
Date: Sat, 17 Jun 2023 17:17:20 -0700
Subject: [PATCH] redo tree formatting

---
 src/datafmt.cpp     | 232 +++++++++++++++++++++++++++++++-------------
 test/testpvreq.cpp  |  27 ++----
 test/testqgroup.cpp |  10 +-
 test/testtype.cpp   | 105 ++++++++++++++++----
 4 files changed, 263 insertions(+), 111 deletions(-)

diff --git a/src/datafmt.cpp b/src/datafmt.cpp
index 6514cef..da7910e 100644
--- a/src/datafmt.cpp
+++ b/src/datafmt.cpp
@@ -125,82 +125,181 @@ struct FmtTree {
     std::ostream& strm;
     const Value::Fmt& fmt;
 
-    void top(const std::string& member,
-             const FieldDesc *desc,
-             const FieldStorage* store)
-    {
-        strm<<indent{};
-        if(!desc) {
+    void show_value(const Value& fld) {
+        const auto type(fld.type());
+        assert(type.kind()!=Kind::Compound);
+
+        switch(type.code) {
+        case TypeCode::Bool:
+            strm<<(fld.as<bool>() ? "true" : "false");
+            return;
+#define CASE(ENUM, TYPE) \
+        case TypeCode::ENUM : strm<<fld.as<TYPE>(); return
+            CASE(Int8, int8_t);
+            CASE(Int16, int16_t);
+            CASE(Int32, int32_t);
+            CASE(Int64, int64_t);
+            CASE(UInt8, uint8_t);
+            CASE(UInt16, uint16_t);
+            CASE(UInt32, uint32_t);
+            CASE(UInt64, uint64_t);
+            CASE(Float32, float);
+            CASE(Float64, double);
+#undef CASE
+        case TypeCode::String:
+            strm<<"\""<<escape(fld.as<std::string>())<<"\"";
+            return;
+        case TypeCode::BoolA:
+        case TypeCode::Int8A:
+        case TypeCode::Int16A:
+        case TypeCode::Int32A:
+        case TypeCode::Int64A:
+        case TypeCode::UInt8A:
+        case TypeCode::UInt16A:
+        case TypeCode::UInt32A:
+        case TypeCode::UInt64A:
+        case TypeCode::Float32A:
+        case TypeCode::Float64A:
+        case TypeCode::StringA:
+        {
+            auto varr = fld.as<shared_array<const void>>();
+            strm<<varr.format().limit(fmt._limit);
+        }
+            return;
+        case TypeCode::Any:
+        case TypeCode::Struct:
+        case TypeCode::Union:
+        case TypeCode::StructA:
+        case TypeCode::UnionA:
+        case TypeCode::AnyA:
+            assert(false);
+            break;
+        default:
+            strm<<"!!Invalid TypeCode!! "<<int(type.code)<<"\n";
+            return;
+        }
+    }
+
+    // each invocation emits at least one complete line
+    void show(const Value& fld, const std::string& member) {
+        // caller should indent{}
+        if(!fld) {
             strm<<"null\n";
             return;
         }
 
-        strm<<desc->code;
-        if(!desc->id.empty())
-            strm<<" \""<<desc->id<<"\"";
-        if(!member.empty() && desc->code!=TypeCode::Struct)
-            strm<<" "<<member;
+        const auto type(fld.type());
 
-        switch(store->code) {
-        case StoreType::Null:
-            if(desc->code==TypeCode::Struct) {
-                strm<<" {\n";
-                for(auto& pair : desc->miter) {
-                    auto cdesc = desc + pair.second;
-                    Indented I(strm);
-                    top(pair.first, cdesc, store + pair.second);
-                }
-                strm<<indent{}<<"}";
-                if(!member.empty())
-                    strm<<" "<<member;
-                strm<<"\n";
+        strm<<type;
+        {
+            auto id(fld.id());
+            if(!id.empty())
+                strm<<" \""<<id<<"\"";
+        }
+
+        if(type.kind()!=Kind::Compound) {
+            if(!member.empty())
+                strm<<' '<<member;
+            if(fmt._showValue) {
+                strm<<" = ";
+                show_value(fld);
+            }
+            strm<<"\n";
+            return;
+        }
+
+        if(type==TypeCode::Any
+                || (!fmt._showValue && type==TypeCode::AnyA)
+                || (fmt._showValue && type==TypeCode::Union)) {
+            // any NAME = VAL
+            // union NAME.MEM TYPE = VAL
+
+            Value val;
+            if(fmt._showValue)
+                val = fld.as<Value>();
+
+            if(!member.empty())
+                strm<<' '<<member;
+
+            if(type==TypeCode::Union && val) { // implied _showValue
+                auto mem(fld.nameOf(val));
+                strm<<'.'<<mem;
+            }
+            if(fmt._showValue) {
+                strm<<" ";
+                show(val, std::string());
             } else {
                 strm<<"\n";
             }
-            break;
-        case StoreType::Real:     if(fmt._showValue) { strm<<" = "<<store->as<double>(); } strm<<"\n"; break;
-        case StoreType::Integer:  if(fmt._showValue) { strm<<" = "<<store->as<int64_t>(); } strm<<"\n"; break;
-        case StoreType::UInteger: if(fmt._showValue) { strm<<" = "<<store->as<uint64_t>(); } strm<<"\n"; break;
-        case StoreType::Bool:     if(fmt._showValue) { strm<<" = "<<(store->as<bool>() ? "true" : "false"); } strm<<"\n"; break;
-        case StoreType::String:   if(fmt._showValue) { strm<<" = \""<<escape(store->as<std::string>())<<"\""; } strm<<"\n"; break;
-        case StoreType::Compound: {
-            auto& fld = store->as<Value>();
-            if(fld.valid() && desc->code==TypeCode::Union) {
-                for(auto& pair : desc->miter) {
-                    if(&desc->members[pair.second] == Value::Helper::desc(fld)) {
-                        strm<<"."<<pair.first;
+            return;
+
+        } else if(type==TypeCode::Struct
+                  || type==TypeCode::Union // && !_showValue
+                  || (!fmt._showValue && type==TypeCode::StructA)
+                  || (!fmt._showValue && type==TypeCode::UnionA))
+        {
+            // struct "id" { ... } NAME
+
+            Value def;
+            if(!type.isarray()) {
+                def = fld;
+            } else { // StructA, UnionA
+                //def = fld.allocMember(); // can't call directly due to const
+                auto desc(Value::Helper::desc(fld));
+                auto store(Value::Helper::store(fld));
+                decltype (store->top->desc) fld(store->top->desc, desc->members.data());
+                def = Value::Helper::build(fld); // not connection to fld (not parent)
+            }
+
+            strm<<" {";
+            bool first = true;
+            {
+                Indented I(strm);
+                for(auto mem : def.ichildren()) {
+                    auto mname(def.nameOf(mem));
+                    if(first)
+                        strm<<'\n';
+                    strm<<indent{};
+                    show(mem, mname);
+                    first = false;
+                }
+            }
+            if(!first)
+                strm<<indent{};
+            strm<<'}';
+
+            if(!member.empty())
+                strm<<' '<<member;
+            strm<<"\n";
+
+        } else {
+            // struct[] NAME = [ ... ]
+
+            if(!member.empty())
+                strm<<' '<<member;
+
+            auto arr(fld.as<shared_array<const Value>>());
+            strm<<" = {"<<arr.size()<<"}[";
+            size_t shown = 0u;
+            {
+                Indented I(strm);
+
+                for(auto& elem : arr) {
+                    if(!shown)
+                        strm<<'\n';
+                    strm<<indent{};
+                    if(fmt._limit && shown>=fmt._limit) {
+                        strm<<"...\n";
                         break;
                     }
+                    show(elem, std::string());
+                    shown++;
                 }
             }
-            Indented I(strm);
-            top(std::string(),
-                Value::Helper::desc(fld),
-                Value::Helper::store_ptr(fld));
-        }
-            break;
-        case StoreType::Array: {
-            auto& varr = store->as<shared_array<const void>>();
-            if(!fmt._showValue) {
-                strm<<"\n";
-            } else if(varr.original_type()!=ArrayType::Value) {
-                strm<<" = "<<varr.format().limit(fmt._limit)<<"\n";
-            } else {
-                auto arr = varr.castTo<const Value>();
-                strm<<" [\n";
-                for(auto& val : arr) {
-                    Indented I(strm);
-                    top(std::string(),
-                        Value::Helper::desc(val),
-                        Value::Helper::store_ptr(val));
-                }
-                strm<<indent{}<<"]\n";
-            }
-        }
-            break;
-        default:
-            strm<<"!!Invalid StoreType!! "<<int(store->code)<<"\n";
-            break;
+
+            if(shown)
+                strm<<indent{};
+            strm<<"]\n";
         }
     }
 };
@@ -211,9 +310,8 @@ std::ostream& operator<<(std::ostream& strm, const Value::Fmt& fmt)
 {
     switch (fmt._format) {
     case Value::Fmt::Tree:
-        FmtTree{strm, fmt}.top("",
-                                 Value::Helper::desc(*fmt.top),
-                                 Value::Helper::store_ptr(*fmt.top));
+        strm<<indent{};
+        FmtTree{strm, fmt}.show(*fmt.top, std::string());
         break;
     case Value::Fmt::Delta:
         FmtDelta{strm, fmt}.top("", *fmt.top, true);
diff --git a/test/testpvreq.cpp b/test/testpvreq.cpp
index c14c1bd..f87f507 100644
--- a/test/testpvreq.cpp
+++ b/test/testpvreq.cpp
@@ -160,8 +160,7 @@ void testEmpty()
     testShow()<<req;
     testStrEq(std::string(SB()<<req),
         "struct {\n"
-        "    struct {\n"
-        "    } field\n"
+        "    struct {} field\n"
         "}\n"
     );
 }
@@ -181,11 +180,9 @@ void testAssemble()
     testStrEq(std::string(SB()<<req),
         "struct {\n"
         "    struct {\n"
+        "        struct {} foo\n"
         "        struct {\n"
-        "        } foo\n"
-        "        struct {\n"
-        "            struct {\n"
-        "            } baz\n"
+        "            struct {} baz\n"
         "        } bar\n"
         "    } field\n"
         "    struct {\n"
@@ -209,8 +206,7 @@ void testParseEmpty()
     testShow()<<req;
     testStrEq(std::string(SB()<<req),
         "struct {\n"
-        "    struct {\n"
-        "    } field\n"
+        "    struct {} field\n"
         "}\n"
     );
 }
@@ -227,8 +223,7 @@ void testParseValue()
     testStrEq(std::string(SB()<<req),
         "struct {\n"
         "    struct {\n"
-        "        struct {\n"
-        "        } value\n"
+        "        struct {} value\n"
         "    } field\n"
         "}\n"
     );
@@ -246,11 +241,9 @@ void testParse1()
     testStrEq(std::string(SB()<<req),
         "struct {\n"
         "    struct {\n"
+        "        struct {} foo\n"
         "        struct {\n"
-        "        } foo\n"
-        "        struct {\n"
-        "            struct {\n"
-        "            } baz\n"
+        "            struct {} baz\n"
         "        } bar\n"
         "    } field\n"
         "    struct {\n"
@@ -275,11 +268,9 @@ void testParse2()
     testStrEq(std::string(SB()<<req),
         "struct {\n"
         "    struct {\n"
+        "        struct {} foo\n"
         "        struct {\n"
-        "        } foo\n"
-        "        struct {\n"
-        "            struct {\n"
-        "            } baz\n"
+        "            struct {} baz\n"
         "        } bar\n"
         "    } field\n"
         "    struct {\n"
diff --git a/test/testqgroup.cpp b/test/testqgroup.cpp
index 920b67c..9875073 100644
--- a/test/testqgroup.cpp
+++ b/test/testqgroup.cpp
@@ -247,10 +247,10 @@ void testImage()
               "        int32_t nanoseconds = 102030\n"
               "        int32_t userTag = 0\n"
               "    } timeStamp\n"
-              "    struct[] attribute [\n"
+              "    struct[] attribute = {2}[\n"
               "        struct {\n"
               "            string name = \"ColorMode\"\n"
-              "            any value                uint16_t = 0\n"
+              "            any value uint16_t = 0\n"
               "            struct \"alarm_t\" {\n"
               "                int32_t severity = 0\n"
               "                int32_t status = 0\n"
@@ -264,7 +264,7 @@ void testImage()
               "        }\n"
               "        struct {\n"
               "            string name = \"\"\n"
-              "            any value                uint16_t = 0\n"
+              "            any value uint16_t = 0\n"
               "            struct \"alarm_t\" {\n"
               "                int32_t severity = 3\n"
               "                int32_t status = 2\n"
@@ -277,7 +277,7 @@ void testImage()
               "            } timeStamp\n"
               "        }\n"
               "    ]\n"
-              "    struct[] dimension [\n"
+              "    struct[] dimension = {2}[\n"
               "        struct {\n"
               "            int32_t size = 100\n"
               "        }\n"
@@ -285,7 +285,7 @@ void testImage()
               "            int32_t size = 100\n"
               "        }\n"
               "    ]\n"
-              "    any value        uint16_t[] = {10000}[0, 655, 1310, 1966, 2621, 3276, ...]\n"
+              "    any value uint16_t[] = {10000}[0, 655, 1310, 1966, 2621, 3276, ...]\n"
               "    struct {\n"
               "        struct \"alarm_t\" {\n"
               "            int32_t severity = 0\n"
diff --git a/test/testtype.cpp b/test/testtype.cpp
index 47b9e12..5fb606d 100644
--- a/test/testtype.cpp
+++ b/test/testtype.cpp
@@ -83,7 +83,7 @@ void testBasic()
         testOk1(!!val.isMarked());
     }
 
-    testEq(std::string(SB()<<top),
+    testStrEq(std::string(SB()<<top),
            "struct \"simple_t\" {\n"
            "    double value = 4.2\n"
            "}\n");
@@ -292,7 +292,7 @@ void testTypeDef()
            "        uint32_t nanoseconds = 0\n"
            "    } timeStamp\n"
            "    struct {\n"
-           "        struct[] sarr [\n"
+           "        struct[] sarr = {3}[\n"
            "            struct {\n"
            "                double value = 1\n"
            "            }\n"
@@ -302,18 +302,18 @@ void testTypeDef()
            "            null\n"
            "        ]\n"
            "    } arbitrary\n"
-           "    any any        uint32_t = 42\n"
-           "    any[] anya [\n"
+           "    any any uint32_t = 42\n"
+           "    any[] anya = {3}[\n"
            "        uint32_t = 123\n"
            "        struct {\n"
            "            string q = \"theq\"\n"
            "        }\n"
            "        null\n"
            "    ]\n"
-           "    union choice.b        string = \"test\"\n"
-           "    union[] achoice [\n"
-           "        union.x            float = 4\n"
-           "        union.y            float = 5\n"
+           "    union choice.b string = \"test\"\n"
+           "    union[] achoice = {3}[\n"
+           "        union.x float = 4\n"
+           "        union.y float = 5\n"
            "        null\n"
            "    ]\n"
            "}\n");
@@ -363,7 +363,7 @@ void testTypeDefDynamic()
 
         testTrue(val.valid());
         testStrEq(std::string(SB()<<val),
-                  "struct[] [\n"
+                  "struct[] = {1}[\n"
                   "    struct \"simple_t\" {\n"
                   "        double value = 42\n"
                   "    }\n"
@@ -381,8 +381,8 @@ void testTypeDefDynamic()
 
         testTrue(val.valid());
         testStrEq(std::string(SB()<<val),
-                  "union[] [\n"
-                  "    union \"simple_t\".value        double = 42\n"
+                  "union[] = {1}[\n"
+                  "    union \"simple_t\".value double = 42\n"
                   "]\n");
     }
 }
@@ -538,24 +538,87 @@ void testFormat()
         "        bool b = true\n"
         "        double f64 = 123.5\n"
         "        string s = \"a \\\"test\\\"\"\n"
-        "        any wildcard            string = \"simple\"\n"
-        "        union choice.one            int32_t = 1024\n"
+        "        any wildcard string = \"simple\"\n"
+        "        union choice.one int32_t = 1024\n"
         "    } scalar\n"
         "    struct {\n"
         "        int32_t[] i32 = {4}[1, -1, 2, -3]\n"
         "        string[] s = {3}[\"one\", \"two\", \"three\"]\n"
-        "        any[] wildcard [\n"
+        "        any[] wildcard = {2}[\n"
         "            string = \"simple\"\n"
         "            null\n"
         "        ]\n"
-        "        union[] choice [\n"
-        "            union.one                int32_t = 1357\n"
+        "        union[] choice = {3}[\n"
+        "            union.one int32_t = 1357\n"
         "            null\n"
-        "            union.two                struct {\n"
-        "                    int32_t ahalf = 2468\n"
-        "                }\n"
+        "            union.two struct {\n"
+        "                int32_t ahalf = 2468\n"
+        "            }\n"
         "        ]\n"
-        "        struct[] more = {\?}[]\n"
+        "        struct[] more = {0}[]\n"
+        "    } array\n"
+        "}\n"
+    );
+
+    testStrEq(std::string(SB()<<top.format().arrayLimit(1u)),
+        "struct \"top_t\" {\n"
+        "    struct {\n"
+        "        int32_t i32 = -42\n"
+        "        uint32_t u32 = 42\n"
+        "        bool b = true\n"
+        "        double f64 = 123.5\n"
+        "        string s = \"a \\\"test\\\"\"\n"
+        "        any wildcard string = \"simple\"\n"
+        "        union choice.one int32_t = 1024\n"
+        "    } scalar\n"
+        "    struct {\n"
+        "        int32_t[] i32 = {4}[1, -1, ...]\n"
+        "        string[] s = {3}[\"one\", \"two\", ...]\n"
+        "        any[] wildcard = {2}[\n"
+        "            string = \"simple\"\n"
+        "            ...\n"
+        "        ]\n"
+        "        union[] choice = {3}[\n"
+        "            union.one int32_t = 1357\n"
+        "            ...\n"
+        "        ]\n"
+        "        struct[] more = {0}[]\n"
+        "    } array\n"
+        "}\n"
+    );
+
+    testStrEq(std::string(SB()<<top.format().showValue(false)),
+        "struct \"top_t\" {\n"
+        "    struct {\n"
+        "        int32_t i32\n"
+        "        uint32_t u32\n"
+        "        bool b\n"
+        "        double f64\n"
+        "        string s\n"
+        "        any wildcard\n"
+        "        union {\n"
+        "            int32_t one\n"
+        "            struct {\n"
+        "                int32_t ahalf\n"
+        "            } two\n"
+        "        } choice\n"
+        "    } scalar\n"
+        "    struct {\n"
+        "        int32_t[] i32\n"
+        "        string[] s\n"
+        "        any[] wildcard\n"
+        "        union[] {\n"
+        "            int32_t one\n"
+        "            struct {\n"
+        "                int32_t ahalf\n"
+        "            } two\n"
+        "        } choice\n"
+        "        struct[] {\n"
+        "            int32_t one\n"
+        "            struct {\n"
+        "                int32_t ahalf\n"
+        "            } two\n"
+        "        } more\n"
         "    } array\n"
         "}\n"
     );
@@ -600,7 +663,7 @@ void testAppendBig()
 
 MAIN(testtype)
 {
-    testPlan(69);
+    testPlan(71);
     testSetup();
     showSize();
     testCode();