JsonSerializer.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
 
#include <aws/core/utils/Array.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/external/cjson/cJSON.h>
 
#include <utility>
 
namespace Aws
{
    namespace Utils
    {
        class Document;
        class DocumentView;
 
        namespace Json
        {
            class JsonView;
            class AWS_CORE_API JsonValue
            {
            public:
                JsonValue();
 
                JsonValue(const Aws::String& value);
 
                JsonValue(Aws::IStream& istream);
 
                JsonValue(const JsonValue& value);
 
                JsonValue(JsonValue&& value);
 
                JsonValue(const Aws::Utils::DocumentView& value);
 
                ~JsonValue();
 
                JsonValue& operator=(const JsonValue& other);
 
                JsonValue& operator=(JsonValue&& other);
 
                JsonValue& operator=(const Aws::Utils::DocumentView& value);
 
                bool operator==(const JsonValue& other) const;
                bool operator!=(const JsonValue& other) const;
 
                JsonValue& WithString(const Aws::String& key, const Aws::String& value);
                JsonValue& WithString(const char* key, const Aws::String& value);
 
                JsonValue& AsString(const Aws::String& value);
 
                JsonValue& WithBool(const Aws::String& key, bool value);
                JsonValue& WithBool(const char* key, bool value);
 
                JsonValue& AsBool(bool value);
 
                JsonValue& WithInteger(const Aws::String& key, int value);
                JsonValue& WithInteger(const char* key, int value);
 
                JsonValue& AsInteger(int value);
 
                JsonValue& WithInt64(const Aws::String& key, long long value);
                JsonValue& WithInt64(const char* key, long long value);
 
                JsonValue& AsInt64(long long value);
 
                JsonValue& WithDouble(const Aws::String& key, double value);
                JsonValue& WithDouble(const char* key, double value);
 
                JsonValue& AsDouble(double value);
 
                JsonValue& WithArray(const Aws::String& key, const Array<Aws::String>& array);
                JsonValue& WithArray(const char* key, const Array<Aws::String>& array);
 
                JsonValue& WithArray(const Aws::String& key, const Array<JsonValue>& array);
 
                JsonValue& WithArray(const Aws::String& key, Array<JsonValue>&& array);
 
                JsonValue& AsArray(const Array<JsonValue>& array);
 
                JsonValue& AsArray(Array<JsonValue>&& array);
 
                JsonValue& WithObject(const Aws::String& key, const JsonValue& value);
                JsonValue& WithObject(const char* key, const JsonValue& value);
 
                JsonValue& WithObject(const Aws::String& key, JsonValue&& value);
                JsonValue& WithObject(const char* key, JsonValue&& value);
 
                JsonValue& AsObject(const JsonValue& value);
 
                JsonValue& AsObject(JsonValue&& value);
 
                inline bool WasParseSuccessful() const
                {
                    return m_wasParseSuccessful;
                }
 
                inline const Aws::String& GetErrorMessage() const
                {
                    return m_errorMessage;
                }
 
                JsonView View() const;
 
            private:
                void Destroy();
                JsonValue(cJSON* value);
                cJSON* m_value;
                bool m_wasParseSuccessful;
                Aws::String m_errorMessage;
                friend class JsonView;
            };
 
            class AWS_CORE_API JsonView
            {
            public:
                /* constructors */
                JsonView();
                JsonView(const JsonValue& v);
                JsonView& operator=(const JsonValue& v);
 
                Aws::String GetString(const Aws::String& key) const;
 
                Aws::String AsString() const;
 
                bool GetBool(const Aws::String& key) const;
 
                bool AsBool() const;
 
                int GetInteger(const Aws::String& key) const;
 
                int AsInteger() const;
 
                int64_t GetInt64(const Aws::String& key) const;
 
                int64_t AsInt64() const;
 
                double GetDouble(const Aws::String& key) const;
 
                double AsDouble() const;
 
                Array<JsonView> GetArray(const Aws::String& key) const;
 
                Array<JsonView> AsArray() const;
 
                JsonView GetObject(const Aws::String& key) const;
 
                JsonView AsObject() const;
 
                Aws::Map<Aws::String, JsonView> GetAllObjects() const;
 
                bool ValueExists(const Aws::String& key) const;
 
                bool KeyExists(const Aws::String& key) const;
 
                bool IsObject() const;
 
                bool IsBool() const;
 
                bool IsString() const;
 
                bool IsIntegerType() const;
 
                bool IsFloatingPointType() const;
 
                bool IsListType() const;
 
                bool IsNull() const;
 
                Aws::String WriteCompact(bool treatAsObject = true) const;
 
                Aws::String WriteReadable(bool treatAsObject = true) const;
 
                JsonValue Materialize() const;
 
            private:
                JsonView(cJSON* val);
                JsonView& operator=(cJSON* val);
                cJSON* m_value;
                friend class Aws::Utils::Document;
            };
 
        } // namespace Json
    } // namespace Utils
} // namespace Aws