JsonObject.h

Go to the documentation of this file.

#pragma once
#include <aws/crt/StlAllocator.h>
#include <aws/crt/Types.h>
 
struct aws_json_value;
namespace Aws
{
    namespace Crt
    {
 
        class JsonView;
        class AWS_CRT_CPP_API JsonObject
        {
          public:
            JsonObject();
 
            JsonObject(const String &stringToParse);
 
            JsonObject(const JsonObject &other);
 
            JsonObject(JsonObject &&other) noexcept;
 
            ~JsonObject();
 
            JsonObject &operator=(const JsonObject &other);
 
            JsonObject &operator=(JsonObject &&other) noexcept;
 
            bool operator==(const JsonObject &other) const;
            bool operator!=(const JsonObject &other) const;
 
            JsonObject &WithString(const String &key, const String &value);
            JsonObject &WithString(const char *key, const String &value);
 
            JsonObject &AsString(const String &value);
 
            JsonObject &WithBool(const String &key, bool value);
            JsonObject &WithBool(const char *key, bool value);
 
            JsonObject &AsBool(bool value);
 
            JsonObject &WithInteger(const String &key, int value);
            JsonObject &WithInteger(const char *key, int value);
 
            JsonObject &AsInteger(int value);
 
            JsonObject &WithInt64(const String &key, int64_t value);
            JsonObject &WithInt64(const char *key, int64_t value);
 
            JsonObject &AsInt64(int64_t value);
 
            JsonObject &WithDouble(const String &key, double value);
            JsonObject &WithDouble(const char *key, double value);
 
            JsonObject &AsDouble(double value);
 
            JsonObject &WithArray(const String &key, const Vector<String> &array);
            JsonObject &WithArray(const char *key, const Vector<String> &array);
 
            JsonObject &WithArray(const String &key, const Vector<JsonObject> &array);
 
            JsonObject &WithArray(const String &key, Vector<JsonObject> &&array);
 
            JsonObject &AsArray(const Vector<JsonObject> &array);
 
            JsonObject &AsArray(Vector<JsonObject> &&array);
 
            JsonObject &AsNull();
 
            JsonObject &WithObject(const String &key, const JsonObject &value);
            JsonObject &WithObject(const char *key, const JsonObject &value);
 
            JsonObject &WithObject(const String &key, JsonObject &&value);
            JsonObject &WithObject(const char *key, JsonObject &&value);
 
            JsonObject &AsObject(const JsonObject &value);
 
            JsonObject &AsObject(JsonObject &&value);
 
            inline bool WasParseSuccessful() const { return m_value != nullptr; }
 
            const String &GetErrorMessage() const;
 
            JsonView View() const;
 
          private:
            JsonObject(const aws_json_value *valueToCopy);
 
            JsonObject &AsNewValue(aws_json_value *valueToOwn);
 
            JsonObject &WithNewKeyValue(const char *key, aws_json_value *valueToOwn);
 
            static aws_json_value *NewArray(const Vector<JsonObject> &objectsToCopy);
 
            static aws_json_value *NewArray(Vector<JsonObject> &&objectsToMove);
 
            aws_json_value *m_value;
 
            /* Once upon a time each class instance had an m_errorMessage string member,
             * and if parse failed the string would explain why.
             * When we switched json implementations, there was no longer a unique string
             * explaining why parse failed so we dropped that member from the class.
             * To avoid breaking the GetErrorMessage() API, which returns the string by REFERENCE,
             * we now use singletons that are created/destroyed along with library init/cleanup. */
            static std::unique_ptr<String> s_errorMessage;
            static std::unique_ptr<String> s_okMessage;
            static void OnLibraryInit();
            static void OnLibraryCleanup();
 
            friend class JsonView;
            friend class ApiHandle;
        };
 
        class AWS_CRT_CPP_API JsonView
        {
          public:
            /* constructors */
            JsonView();
            JsonView(const JsonObject &val);
            JsonView &operator=(const JsonObject &val);
 
            String GetString(const String &key) const;
            String GetString(const char *key) const;
 
            String AsString() const;
 
            bool GetBool(const String &key) const;
            bool GetBool(const char *key) const;
 
            bool AsBool() const;
 
            int GetInteger(const String &key) const;
            int GetInteger(const char *key) const;
 
            int AsInteger() const;
 
            int64_t GetInt64(const String &key) const;
            int64_t GetInt64(const char *key) const;
 
            int64_t AsInt64() const;
 
            double GetDouble(const String &key) const;
            double GetDouble(const char *key) const;
 
            double AsDouble() const;
 
            Vector<JsonView> GetArray(const String &key) const;
            Vector<JsonView> GetArray(const char *key) const;
 
            Vector<JsonView> AsArray() const;
 
            JsonView GetJsonObject(const String &key) const;
            JsonView GetJsonObject(const char *key) const;
 
            JsonObject GetJsonObjectCopy(const String &key) const;
 
            JsonObject GetJsonObjectCopy(const char *key) const;
 
            JsonView AsObject() const;
 
            Map<String, JsonView> GetAllObjects() const;
 
            bool ValueExists(const String &key) const;
            bool ValueExists(const char *key) const;
 
            bool KeyExists(const String &key) const;
            bool KeyExists(const char *key) const;
 
            bool IsObject() const;
 
            bool IsBool() const;
 
            bool IsString() const;
 
            bool IsNumber() const;
 
            bool IsIntegerType() const;
 
            bool IsFloatingPointType() const;
 
            bool IsListType() const;
 
            bool IsNull() const;
 
            String WriteCompact(bool treatAsObject = true) const;
 
            String WriteReadable(bool treatAsObject = true) const;
 
            JsonObject Materialize() const;
 
          private:
            JsonView(const aws_json_value *val);
 
            String Write(bool treatAsObject, bool readable) const;
 
            const aws_json_value *m_value;
        };
    } // namespace Crt
} // namespace Aws