Lil cleanup

include/Orange/Core/Parse.h

@@ -29,6 +29,12 @@ namespace orange::stream
         return Parse<T>(first, first + length);
     }
 
+    template <typename T>
+    Result<T> Parse(StringView view)
+    {
+        return Parse<T>(view.data, view.size);
+    }
+
     template <typename T>
     Result<T> Parse(const char*& first)
     {
@@ -63,14 +69,28 @@ namespace orange::stream
         return count;
     }
 
+    static constexpr const char* WhitespaceDelimiters = " \t";
+    static constexpr const char* NewlineDelimiters = "\r\n";
+    static constexpr const char* WhitespaceOrNewlineDelimiters = " \t\r\n";
+
     inline size_t ConsumeSpace(const char*& first, const char* end)
     {
-        return Consume(first, end, " \t");
+        return Consume(first, end, WhitespaceDelimiters);
     }
 
     inline size_t ConsumeSpaceAndNewLine(const char*& first, const char* end)
     {
-        return Consume(first, end, " \t\r\n");
+        return Consume(first, end, WhitespaceOrNewlineDelimiters);
+    }
+
+    inline bool IsWhitespace(char val)
+    {
+        return val == ' ' || val == '\t';
+    }
+
+    inline bool IsNewLine(char val)
+    {
+        return val == '\r' || val == '\n';
     }
 
     template <typename OutArray = SmallVector<char, 1>>

include/Orange/Formats/KeyValues.h

@@ -82,6 +82,16 @@ namespace orange::kv
         template <typename T>
         T Get() const;
 
+        operator StringView();
+        operator int64_t();
+        operator int32_t();
+        operator float();
+        operator double();
+        operator void*();
+        operator RGBAColor32();
+        operator uint32_t();
+        operator uint64_t();
+
         void Set(const std::string& val) { Clear(); m_type = Types::String;    m_str = KeyValuesString{ StringView{ val } }; }
         void Set(StringView val)         { Clear(); m_type = Types::String;    m_str = KeyValuesString{ val }; }
         void Set(int32_t val)            { Clear(); m_type = Types::Int;       m_data.Get<int64_t>() = val; }
@@ -190,17 +200,15 @@ namespace orange::kv
                 {
                     if (stream::IsCPPComment(range, start))
                     {
-                        stream::AdvancePast(start, end, "\r\n");
+                        stream::AdvancePast(start, end, stream::NewlineDelimiters);
                         stream::ConsumeSpaceAndNewLine(start, end);
                         continue;
                     }
 
                     if (*start == '{')
                     {
-                        fprintf(stdout, "Adding block child: %s - {\n", key.c_str());
                         auto child = ParseChild(start, end);
                         kv->m_children.emplace(key, Move(child));
-                        fprintf(stdout, "Adding block child: }\n");
 
                         fillingInValue = false;
                         key.clear();
@@ -213,18 +221,17 @@ namespace orange::kv
                         break;
                     }
 
-                    if (*start == ' ' || *start == '\t' || *start == '\n' || *start == '\r')
+                    if (stream::IsWhitespace(*start) || stream::IsNewLine(*start))
                     {
                         fillingInValue = !fillingInValue;
 
                         if (!fillingInValue)
                         {
-                            fprintf(stdout, "Adding child: %s - %s\n", key.c_str(), value.c_str());
                             kv->m_children.emplace(key, value);
                             key.clear();
                             value.clear();
                         }
-                        else if (*start == '\n' || *start == '\r')
+                        else if (stream::IsNewLine(*start))
                         {
                             fillingInValue = false;
                         }
@@ -260,6 +267,41 @@ namespace orange::kv
         }
     }
 
+    // todo josh:
+    // make the ::Get variant return a result
+    // return un-resulted version of that with the
+    // operators
+
+    template <>
+    inline int64_t KeyValuesVariant::Get() const
+    {
+        switch (m_type)
+        {
+            case Types::String:
+                return *stream::Parse<int64_t>(m_str);
+            default:
+                return 0;
+        }
+    }
+
+    template <>
+    inline int32_t KeyValuesVariant::Get() const
+    {
+        return Get<int64_t>();
+    }
+
+    template <>
+    inline float KeyValuesVariant::Get() const
+    {
+        switch (m_type)
+        {
+            case Types::String:
+                return *stream::Parse<float>(m_str);
+            default:
+                return 0;
+        }
+    }
+
     template <>
     inline KeyValues& KeyValuesVariant::Get() const
     {
@@ -292,4 +334,41 @@ namespace orange::kv
 
         return Get<const kv::KeyValues&>()[string];
     }
+
+    KeyValuesVariant::operator StringView()
+    {
+        return Get<StringView>();
+    }
+    KeyValuesVariant::operator int64_t()
+    {
+        return Get<int64_t>();
+    }
+    KeyValuesVariant::operator int32_t()
+    {
+        return Get<int32_t>();
+    }
+    KeyValuesVariant::operator float()
+    {
+        return Get<float>();
+    }
+    KeyValuesVariant::operator double()
+    {
+        return Get<double>();
+    }
+    KeyValuesVariant::operator void*()
+    {
+        return Get<void*>();
+    }
+    KeyValuesVariant::operator RGBAColor32()
+    {
+        return Get<RGBAColor32>();
+    }
+    KeyValuesVariant::operator uint32_t()
+    {
+        return Get<uint32_t>();
+    }
+    KeyValuesVariant::operator uint64_t()
+    {
+        return Get<uint64_t>();
+    }
 }