From c1c77aeb96f0863604c7494e64d5cbfd33d019c6 Mon Sep 17 00:00:00 2001
From: Michael Davidsaver <mdavidsaver@gmail.com>
Date: Wed, 11 Mar 2020 09:51:01 -0700
Subject: [PATCH] add TypeCode::storedAs()

---
 src/data.cpp    | 59 +++++++++++++++++++++----------------------------
 src/dataimpl.h  |  2 +-
 src/pvxs/data.h |  2 ++
 src/type.cpp    | 28 +++++++++++++++++++++++
 4 files changed, 56 insertions(+), 35 deletions(-)

diff --git a/src/data.cpp b/src/data.cpp
index 17d1b79..9143918 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -48,7 +48,7 @@ Value::Value(const std::shared_ptr<const impl::FieldDesc>& desc)
     top->members.resize(desc->size());
     {
         auto& root = top->members[0];
-        root.init(desc.get());
+        root.init(desc->code.storedAs());
         root.top = top.get();
     }
 
@@ -57,7 +57,7 @@ Value::Value(const std::shared_ptr<const impl::FieldDesc>& desc)
             auto cfld = desc.get() + pair.second;
             auto& mem = top->members.at(pair.second);
             mem.top = top.get();
-            mem.init(cfld);
+            mem.init(cfld->code.storedAs());
         }
     }
 
@@ -792,41 +792,32 @@ Value Value::_iter_deref(const IterInfo& info) const
 
 namespace impl {
 
-void FieldStorage::init(const FieldDesc *desc)
+void FieldStorage::init(StoreType code)
 {
-    if(!desc || desc->code.kind()==Kind::Null || desc->code.code==TypeCode::Struct) {
-        this->code = StoreType::Null;
-
-    } else if(desc->code.isarray()) {
-        this->code = StoreType::Array;
+    this->code = code;
+    switch(code) {
+    case StoreType::Null:
+        return;
+    case StoreType::Bool:
+        as<bool>() = false;
+        return;
+    case StoreType::Integer:
+    case StoreType::UInteger:
+    case StoreType::Real:
+        // just zero 8 bytes
+        as<uint64_t>() = 0u;
+        return;
+    case StoreType::String:
+        new(&store) std::string();
+        return;
+    case StoreType::Compound:
+        new(&store) std::shared_ptr<FieldStorage>();
+        return;
+    case StoreType::Array:
         new(&store) shared_array<void>();
-
-    } else {
-        switch(desc->code.kind()) {
-        case Kind::String:
-            new(&store) std::string();
-            this->code = StoreType::String;
-            break;
-        case Kind::Compound:
-            new(&store) std::shared_ptr<FieldStorage>();
-            this->code = StoreType::Compound;
-            break;
-        case Kind::Integer:
-            as<uint64_t>() = 0u;
-            this->code = desc->code.isunsigned() ? StoreType::UInteger : StoreType::Integer;
-            break;
-        case Kind::Bool:
-            as<bool>() = false;
-            this->code = StoreType::Bool;
-            break;
-        case Kind::Real:
-            as<double>() = 0.0;
-            this->code = StoreType::Real;
-            break;
-        default:
-            throw std::logic_error("FieldStore::init()");
-        }
+        return;
     }
+    throw std::logic_error("FieldStore::init()");
 }
 
 void FieldStorage::deinit()
diff --git a/src/dataimpl.h b/src/dataimpl.h
index f6494e1..2a3cb51 100644
--- a/src/dataimpl.h
+++ b/src/dataimpl.h
@@ -113,7 +113,7 @@ struct FieldStorage {
     bool valid=false;
     StoreType code=StoreType::Null;
 
-    void init(const FieldDesc* desc);
+    void init(StoreType code);
     void deinit();
     ~FieldStorage();
 
diff --git a/src/pvxs/data.h b/src/pvxs/data.h
index d009874..d378885 100644
--- a/src/pvxs/data.h
+++ b/src/pvxs/data.h
@@ -157,6 +157,8 @@ struct TypeCode {
     constexpr explicit TypeCode(uint8_t c) :code(code_t(c)) {}
     constexpr TypeCode(code_t c) :code(c) {}
 
+    PVXS_API StoreType storedAs() const;
+
     //! associated array of type
     constexpr TypeCode arrayOf() const {return TypeCode{uint8_t(code|0x08)};}
     //! associated not array of type
diff --git a/src/type.cpp b/src/type.cpp
index bf0d0bd..6ad4641 100644
--- a/src/type.cpp
+++ b/src/type.cpp
@@ -56,6 +56,34 @@ bool TypeCode::valid() const
     }
 }
 
+StoreType TypeCode::storedAs() const
+{
+    if(isarray()) {
+        return StoreType::Array;
+
+    } else if(code==Struct) {
+        return StoreType::Null;
+
+    } else if(code==String) {
+        return StoreType::String;
+
+    } else if(code==Bool) {
+        return StoreType::Bool;
+
+    } else if(kind()==Kind::Real) {
+        return StoreType::Real;
+
+    } else if(kind()==Kind::Integer) {
+        return isunsigned() ? StoreType::UInteger : StoreType::Integer;
+
+    } else if(kind()==Kind::Compound) {
+        return StoreType::Compound;
+
+    } else {
+        throw std::logic_error("TypeCode::storedAs() not map");
+    }
+}
+
 const char* TypeCode::name() const
 {
     switch(code) {