Nebula
Loading...
Searching...
No Matches
jsonwriter.h
Go to the documentation of this file.
1#pragma once
2//------------------------------------------------------------------------------
11#include "io/streamwriter.h"
12#include "util/string.h"
13#include "util/stack.h"
14#include "util/bitfield.h"
15#include "util/stringatom.h"
16#include "util/variant.h"
17#include "util/blob.h"
18
19namespace pjson
20{
21 class value_variant;
22 class document;
23}
24
25//------------------------------------------------------------------------------
26namespace IO
27{
29{
31public:
33 JsonWriter();
35 virtual ~JsonWriter();
37 virtual bool Open();
39 virtual void Close();
40
42 void BeginArray(const char * nodeName = nullptr);
43
45 void BeginObject(const char * nodeName = nullptr);
47 void End();
48
50 template <typename T> void Add(const T & value, const Util::String & name = "");
52 template<unsigned int N> void Add(Util::BitField<N> const& value, const Util::String& name = "");
54 void Add(const char * value, const Util::String & name = "");
56// template <typename T> void Add(const Util::String & name, const T & value);
57
58 /*
60 void AddString(const Util::String & value);
62 void AddBool(bool value);
64 void AddInt(int value);
66 void AddFloat(float value);
68 void AddFloat2(const Math::vec2 & value);
70 void AddVec4(const Math::vec4 & value);
72 void AddMatrix44(const Math::mat4 & value);
74 void AddTransform44(const Math::transform44 & value);
75
77 void SetString(const Util::String& name, const Util::String& value);
79 void SetBool(const Util::String& name, bool value);
81 void SetInt(const Util::String& name, int value);
83 void SetFloat(const Util::String& name, float value);
85 void SetVec2(const Util::String& name, const Math::vec2& value);
87 void SetVec4(const Util::String& name, const Math::vec4& value);
89 void SetMat4(const Util::String& name, const Math::mat4& value);
91 void SetTransform44(const Util::String& name, const Math::transform44& value);
93 template<typename T> void Set(const Util::String& name, const T &value);
94 */
95
96private:
97
98 pjson::document * document;
101};
102
103template<> void JsonWriter::Add(const Util::String& value, const Util::String& name);
104template<> void JsonWriter::Add(const Util::StringAtom& value, const Util::String& name);
105template<> void JsonWriter::Add(const Util::FourCC& value, const Util::String& name);
106template<> void JsonWriter::Add(const bool& value, const Util::String& name);
107template<> void JsonWriter::Add(const char& value, const Util::String& name);
108template<> void JsonWriter::Add(const uchar& value, const Util::String& name);
109template<> void JsonWriter::Add(const int& value, const Util::String& name);
110template<> void JsonWriter::Add(const unsigned int& value, const Util::String& name);
111template<> void JsonWriter::Add(const float& value, const Util::String& name);
112template<> void JsonWriter::Add(const Math::vec3& value, const Util::String& name);
113template<> void JsonWriter::Add(const Math::vec4& value, const Util::String& name);
114template<> void JsonWriter::Add(const Math::vec2& value, const Util::String& name);
115template<> void JsonWriter::Add(const Math::mat4& value, const Util::String& name);
116template<> void JsonWriter::Add(const Math::transform44& value, const Util::String& name);
117template<> void JsonWriter::Add(const Util::Variant& value, const Util::String& name);
118template<> void JsonWriter::Add(const Util::Guid& value, const Util::String& name);
119template<> void JsonWriter::Add(const Util::Array<int>& value, const Util::String& name);
120template<> void JsonWriter::Add(const Util::Array<Util::String>& value, const Util::String& name);
121
122//------------------------------------------------------------------------------
125template<unsigned int N>
126inline void
128{
129 Util::Array<int> tempArr;
130 for (uint i = 0; i < N; i++)
131 {
132 if (value.IsSet(i))
133 {
134 tempArr.Append(i);
135 }
136 }
137 this->Add(tempArr, name);
138}
139
140
141} // namespace IO
142//------------------------------------------------------------------------------
143
Write Json-formatted data to a stream.
Definition jsonwriter.h:29
JsonWriter()
constructor
Definition jsonwriter.cc:26
__DeclareClass(JsonWriter)
virtual bool Open()
begin writing the stream
Definition jsonwriter.cc:47
pjson::document * document
add a value to current object node
Definition jsonwriter.h:98
void BeginObject(const char *nodeName=nullptr)
begin a new node that can host key-value pairs
Definition jsonwriter.cc:100
virtual void Close()
end writing the stream
Definition jsonwriter.cc:66
void Add(const T &value, const Util::String &name="")
add a value to the current array node
virtual ~JsonWriter()
destructor
Definition jsonwriter.cc:35
void End()
end current object or array
Definition jsonwriter.cc:113
Util::Stack< pjson::value_variant * > hierarchy
Definition jsonwriter.h:99
void BeginArray(const char *nodeName=nullptr)
begin a new array node
Definition jsonwriter.cc:87
Util::Stack< Util::String > nameHierarchy
Definition jsonwriter.h:100
Stream writer classes provide a specialized write-interface for a stream.
Definition streamwriter.h:22
A 4x4 matrix which is described by translation, rotation and scale.
Definition transform44.h:20
Nebula's dynamic array class.
Definition array.h:60
void Append(const TYPE &first, const ELEM_TYPE &... elements)
Append multiple elements to the end of the array.
Definition array.h:1334
Implements large bit field.
Definition bitfield.h:24
constexpr bool IsSet(const uint64_t bitIndex) const
Check if single bit is set.
Definition bitfield.h:156
A four-character-code is a quasi-human-readable 32-bit-id.
Definition fourcc.h:19
Implements a GUID.
Nebula's stack class (a FILO container).
Definition stack.h:19
A StringAtom.
Definition stringatom.h:22
An "any type" variable.
Definition variant.h:31
Instances of wrapped stream classes.
Definition orientation.cc:10
Definition jsonreader.h:24
A 4x4 single point precision float matrix.
Definition mat4.h:49
A 2-component float vector class.
Definition vec2.h:21
A 3D vector.
Definition vec3.h:40
A 4D vector.
Definition vec4.h:24
Nebula's universal string class.
Definition string.h:50
unsigned char uchar
Definition types.h:33
unsigned int uint
Definition types.h:31