JsonReader.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/PimplPtr.hxx"
#include "Arp/System/Commons/Json/JsonSerializationContext.hpp"
#include "Arp/System/Commons/Exceptions/JsonException.hpp"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Core/IEnumerator.hxx"
 
namespace Arp { namespace System { namespace Commons { namespace Json
{
 
using Arp::System::Commons::JsonException;
class JsonValue;
 
class ARP_CXX_SYMBOL_EXPORT JsonReader
{
public: // Impl forward declaration
    class Impl;
 
public: // construction/destruction/assignment
    JsonReader(void);
    JsonReader(const JsonReader& arg) = delete;
    JsonReader(JsonReader&& arg)noexcept;
    JsonReader& operator=(const JsonReader& arg) = delete;
    JsonReader& operator=(JsonReader&& arg)noexcept;
    ~JsonReader(void);
 
public: // static operations
    static JsonReader Create(const String& filename);
    static JsonReader CreateFromText(const String& text);
    static bool TryCreate(const String& filename, JsonReader& reader);
    static bool TryCreateFromText(const String& text, JsonReader& reader);
 
public: // setter/getter operations
    const String& GetDocumentFileName();
 
    bool HasRootObject(void);
    bool HasRootSimpleArray(void);
    bool HasRootComplexArray(void);
 
public: // operations
 
    // go straight into the object (and complex array)
    void ReadRootObject(void);
    bool TryReadRootObject(void);
    void ReadStartObject(const char* objectName);
    bool TryReadStartObject(const char* objectName);
    void ReadEndObject(void);
    bool TryReadEndObject(void);
 
    // go into the object (and complex array) using a loop
    bool TryReadStartAny(String& name);
    void ReadEndAny(void);
    bool TryReadEndAny(void);
 
    // loop complex array items
    void ReadStartComplexArrayItem(void);
    bool TryReadStartComplexArrayItem(void);
    void ReadEndComplexArrayItem(void);
    bool TryReadEndComplexArrayItem(void);
 
    bool TryReadValue(const char* valueName, bool& result);
    bool TryReadValue(const char* valueName, String& result);
    bool TryReadValue(const char* valueName, uint8& result);
    bool TryReadValue(const char* valueName, int8& result);
    bool TryReadValue(const char* valueName, uint16& result);
    bool TryReadValue(const char* valueName, int16& result);
    bool TryReadValue(const char* valueName, uint32& result);
    bool TryReadValue(const char* valueName, int32& result);
    bool TryReadValue(const char* valueName, uint64& result);
    bool TryReadValue(const char* valueName, int64& result);
    bool TryReadValue(const char* valueName, float32& result);
    bool TryReadValue(const char* valueName, float64& result);
 
    void ReadValue(const char* valueName, char* pBuffer, size_t bufferSize);
    bool TryReadValue(const char* valueName, char* pBuffer, size_t bufferSize);
 
    bool TryReadSimpleArray(const char* arrayName, std::vector<bool>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<String>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<uint8>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<int8>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<uint16>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<int16>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<uint32>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<int32>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<uint64>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<int64>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<float32>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<float64>& result);
    bool TryReadSimpleArray(const char* arrayName, std::vector<Arp::byte>& result);
 
    JsonValue GetRootValue(void);
    bool TryGetRootValue(JsonValue& jsonValueResult);
    JsonValue GetValue(const char* valueName);
    bool TryGetValue(const char* valueName, JsonValue& jsonValueResult);
 
    IEnumerator<const JsonValue&>::Ptr GetValueEnumerator(void);
 
    template<class T>
    bool TryReadStartComplexArrayItem(T& arrayObjectResult, JsonSerializationContext& context);
 
    template<class T>
    T ReadValue(const char* valueName);
 
    template<class T>
    std::vector<T> ReadSimpleArray(const char* arrayName);
 
    template<typename... Args>
    JsonException CreateException(const char* message, const Args& ... args) const;
    JsonException CreateException(const String& message) const;
 
public: // Impl operations
    Impl&       GetImpl(void);
    const Impl& GetImpl(void)const;
 
private: // Impl usings
    using Pimpl = PimplPtr<Impl>;
 
private: // Impl fields
    Pimpl   pimpl;
};
 
// inline methods of class JsonReader
 
template<class T>
inline bool JsonReader::TryReadStartComplexArrayItem(T& arrayObjectResult, JsonSerializationContext& context)
{
    if (this->TryReadStartComplexArrayItem())
    {
        arrayObjectResult.ReadJson(*this, context);
 
        this->TryReadEndComplexArrayItem();
 
        return true;
    }
    // else
    return false;
}
 
template<class T>
inline T JsonReader::ReadValue(const char* valueName)
{
    T value;
    if (!this->TryReadValue(valueName, value))
    {
        throw JsonException("Error reading value, type mismatch, valueName: {0} type: {1}", valueName, typeid(T).name());
    }
    // else
    return value;
}
 
template<class T>
inline std::vector<T> JsonReader::ReadSimpleArray(const char* arrayName)
{
    std::vector<T> value;
    if (!this->TryReadSimpleArray(arrayName, value))
    {
        throw JsonException("Error reading simple array, type mismatch, arrayName: {0} type: {1}", arrayName, typeid(T).name());
    }
    // else
    return value;
}
 
template<typename... Args>
inline JsonException JsonReader::CreateException(const char* message, const Args& ... args) const
{
    return this->CreateException(String::Format(message, args...));
}
 
}}}} // end of namespace Arp::System::Commons::Json