Json.hpp

Go to the documentation of this file.

/*
 * Json.hpp
 *
 * Copyright (C) 2022 by RStudio, PBC
 *
 * Unless you have received this program directly from RStudio pursuant to the terms of a commercial license agreement
 * with RStudio, then this program is licensed to you under the following terms:
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
 
#ifndef LAUNCHER_PLUGINS_JSON_HPP
#define LAUNCHER_PLUGINS_JSON_HPP
 
#include <map>
#include <ostream>
#include <set>
#include <sstream>
#include <utility>
#include <vector>
 
#include <Optional.hpp>
 
#include <Error.hpp>
#include <logging/Logger.hpp>
#include <PImpl.hpp>
 
namespace rstudio {
namespace launcher_plugins {
namespace json {
 
class Array;
class Object;
 
typedef std::vector<std::pair<std::string, std::string> > StringPairList;
typedef std::map<std::string, std::vector<std::string> > StringListMap;
 
enum class Type
{
   ARRAY,
   BOOL,
   INTEGER,
   OBJECT,
   STRING,
   REAL,
   NULL_TYPE,
   UNKNOWN
};
 
class Value
{
protected:
   // This is defined first so it may be referred to in the class definition.
   PRIVATE_IMPL_SHARED(m_impl);
 
   typedef std::shared_ptr<Impl> ValueImplPtr;
 
   friend class Array;
 
public:
   Value();
 
   explicit Value(ValueImplPtr in_valueImpl);
 
   Value(const Value& in_other);
 
   Value(Value&& in_other) noexcept;
 
   explicit Value(bool in_value);
 
   explicit Value(double in_value);
 
   explicit Value(float in_value);
 
   explicit Value(int in_value);
 
   explicit Value(int64_t in_value);
 
   explicit Value(const char* in_value);
 
   explicit Value(const std::string& in_value);
 
   explicit Value(unsigned int in_value);
 
   explicit Value(uint64_t in_value);
 
   virtual ~Value() = default;
 
   Value& operator=(const Value& in_other);
 
   Value& operator=(Value&& in_other) noexcept;
 
   Value& operator=(bool in_value);
 
   Value& operator=(double in_value);
 
   Value& operator=(float in_value);
 
   Value& operator=(int in_value);
 
   Value& operator=(int64_t in_value);
 
   Value& operator=(const char* in_value);
 
   Value& operator=(const std::string& in_value);
 
   Value& operator=(unsigned int in_value);
 
   Value& operator=(uint64_t in_value);
 
   bool operator==(const Value& in_other) const;
 
   bool operator!=(const Value& in_other) const;
 
   Value clone() const;
 
   Error coerce(const std::string& in_schema,
                std::vector<std::string>& out_propViolations);
 
   Array getArray() const;
 
   bool getBool() const;
 
   double getDouble() const;
 
   float getFloat() const;
 
   int getInt() const;
 
   int64_t getInt64() const;
 
   Object getObject() const;
 
   std::string getString() const;
 
   Type getType() const;
 
   unsigned int getUInt() const;
 
   uint64_t getUInt64() const;
 
   template <typename T>
   T getValue() const;
 
   bool isArray() const;
 
   bool isBool() const;
 
   bool isDouble() const;
 
   bool isFloat() const;
 
   bool isInt() const;
 
   bool isInt64() const;
 
   bool isObject() const;
 
   bool isString() const;
 
   bool isNull() const;
 
   bool isUInt() const;
 
   bool isUInt64() const;
 
   virtual Error parse(const char* in_jsonStr);
 
   virtual Error parse(const std::string& in_jsonStr);
 
   Error parseAndValidate(const std::string& in_jsonStr, const std::string& in_schema);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, const json::Value& in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, bool in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, double in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, float in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, int in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, int64_t in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, const char* in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, const std::string& in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, unsigned int in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, uint64_t in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, const Array& in_value);
 
   Error setValueAtPointerPath(const std::string& in_pointerPath, const Object& in_value);
 
   Error validate(const std::string& in_schema) const;
 
   std::string write() const;
 
   void write(std::ostream& io_ostream) const;
 
   std::string writeFormatted() const;
 
   void writeFormatted(std::ostream& io_ostream) const;
 
private:
   void move(Value&& in_other);
};
 
class Object : public Value
{
public:
   class Iterator;
 
   class Member
   {
   private:
      // Private implementation of member, declared first so it can be used.
      PRIVATE_IMPL_SHARED(m_impl);
 
      // Iterators can construct members.
      friend class Iterator;
   public:
      Member() = default;
 
      explicit Member(const std::shared_ptr<Impl>& in_impl);
 
      const std::string& getName() const;
 
      Value getValue() const;
   };
 
   class Iterator: public std::iterator<
      std::bidirectional_iterator_tag,   // iterator_category
      Member,                            // value_type
      std::ptrdiff_t,                    // difference_type
      const Member*,                     // pointer
      Member>                            // reference
   {
   public:
      explicit Iterator(const Object* in_parent, std::ptrdiff_t in_startPos = 0);
 
      Iterator(const Iterator& in_other) = default;
 
      Iterator& operator=(const Iterator& in_other);
 
      Iterator& operator++();
 
      Iterator& operator--();
 
      Iterator operator++(int);
 
      Iterator operator--(int);
 
      bool operator==(const Iterator& in_other) const;
 
      bool operator!=(const Iterator& in_other) const;
 
      reference operator*() const;
 
   private:
      const Object* m_parent;
 
      std::ptrdiff_t m_pos;
 
      // Let the parent class manipulate its iterators.
      friend class Object;
   };
 
   typedef std::reverse_iterator<Iterator> ReverseIterator;
 
   Object();
 
   explicit Object(const StringPairList& in_strPairs);
 
   Object(const Object& in_other);
 
   Object(Object&& in_other) noexcept;
 
   static Member createMember(const std::string& in_name, const Value& in_value);
 
   static Error getSchemaDefaults(const std::string& in_schema, Object& out_schemaDefaults);
 
   static Object mergeObjects(const Object& in_base, const Object& in_overlay);
 
   Object& operator=(const Object& in_other);
 
   Object& operator=(Object&& in_other) noexcept;
 
   Value operator[](const char* in_name);
 
   Value operator[](const std::string& in_name);
 
   Iterator find(const char* in_name) const;
 
   Iterator find(const std::string& in_name) const;
 
   Iterator begin() const;
 
   Iterator end() const;
 
   ReverseIterator rbegin() const;
 
   ReverseIterator rend() const;
 
   void clear();
 
   bool erase(const char* in_name);
 
   bool erase(const std::string& in_name);
 
   Iterator erase(const Iterator& in_itr);
 
   size_t getSize() const;
 
   bool hasMember(const char* in_name) const;
 
   bool hasMember(const std::string& in_name) const;
 
   void insert(const std::string& in_name, const Value& in_value);
 
   void insert(const std::string& in_name, bool in_value);
 
   void insert(const std::string& in_name, double in_value);
 
   void insert(const std::string& in_name, float in_value);
 
   void insert(const std::string& in_name, int in_value);
 
   void insert(const std::string& in_name, int64_t in_value);
 
   void insert(const std::string& in_name, const char* in_value);
 
   void insert(const std::string& in_name, const std::string& in_value);
 
   void insert(const std::string& in_name, unsigned int in_value);
 
   void insert(const std::string& in_name, uint64_t in_value);
 
   void insert(const std::string& in_name, const Array& in_value);
 
   void insert(const std::string& in_name, const Object& in_value);
 
   void insert(const Member& in_member);
 
   bool isEmpty() const;
 
   Error parse(const char* in_jsonStr) override;
 
   Error parse(const std::string& in_jsonStr) override;
 
   bool toStringMap(StringListMap& out_map) const;
 
   StringPairList toStringPairList() const;
 
private:
   explicit Object(ValueImplPtr in_value);
 
   friend class Value;
   friend class Iterator;
};
 
class Array : public Value
{
public:
 
   typedef Value value_type;
 
   class Iterator: public std::iterator<std::bidirectional_iterator_tag,   // iterator_category
      Value,                             // value_type
      std::ptrdiff_t,                    // difference_type
      const Value*,                      // pointer
      Value>                             // reference
   {
   public:
      explicit Iterator(const Array* in_parent, std::ptrdiff_t in_startPos = 0);
 
      Iterator(const Iterator& in_other) = default;
 
      Iterator& operator=(const Iterator& in_other);
 
      Iterator& operator++();
 
      Iterator& operator--();
 
      Iterator operator++(int);
 
      Iterator operator--(int);
 
      bool operator==(const Iterator& in_other) const;
 
      bool operator!=(const Iterator& in_other) const;
 
      reference operator*() const;
 
   private:
      const Array* m_parent;
 
      std::ptrdiff_t m_pos;
 
      // Allow the array class to manipulate its own iterators.
      friend class Array;
   };
 
   typedef std::reverse_iterator<Iterator> ReverseIterator;
 
   Array();
 
   explicit Array(const StringPairList& in_strPairs);
 
   Array(const Array& in_other);
 
   Array(Array&& in_other) noexcept;
 
   Array& operator=(const Array& in_other);
 
   Array& operator=(Array&& in_other) noexcept;
 
   Value operator[](size_t in_index) const;
 
   Iterator begin() const;
 
   Iterator end() const;
 
   ReverseIterator rbegin() const;
 
   ReverseIterator rend() const;
 
   void clear();
 
   Iterator erase(const Iterator& in_itr);
 
   Iterator erase(const Iterator& in_first, const Iterator& in_last);
 
   Value getBack() const;
 
   Value getFront() const;
 
   Value getValueAt(size_t in_index) const;
 
   size_t getSize() const;
 
   bool isEmpty() const;
 
   Error parse(const char* in_jsonStr) override;
 
   Error parse(const std::string& in_jsonStr) override;
 
   void push_back(const Value& in_value);
 
   void push_back(bool in_value);
 
   void push_back(double in_value);
 
   void push_back(float in_value);
 
   void push_back(int in_value);
 
   void push_back(int64_t in_value);
 
   void push_back(const char* in_value);
 
   void push_back(const std::string& in_value);
 
   void push_back(unsigned int in_value);
 
   void push_back(uint64_t in_value);
 
   void push_back(const Array& in_value);
 
   void push_back(const Object& in_value);
 
   bool toSetString(std::set<std::string>& out_set) const;
 
   StringPairList toStringPairList() const;
 
   bool toVectorInt(std::vector<int>& out_set) const;
 
   bool toVectorString(std::vector<std::string>& out_set) const;
 
private:
   explicit Array(ValueImplPtr in_value);
 
   friend class Value;
};
 
template <typename T>
bool isType(const Value& in_value)
{ 
   if (in_value.isNull())
      return false;
   else if (std::is_same<T, Object>::value)
      return in_value.getType() == Type::OBJECT;
   else if (std::is_same<T, Array>::value)
      return in_value.getType() == Type::ARRAY;
   else if (std::is_same<T, std::string>::value)
      return in_value.getType() == Type::STRING;
   else if (std::is_same<T, bool>::value)
      return in_value.getType() == Type::BOOL;
   else if (std::is_same<T, int>::value)
      return in_value.getType() == Type::INTEGER;
   else if (std::is_same<T, unsigned int>::value)
      return in_value.getType() == Type::INTEGER;
   else if (std::is_same<T, int64_t>::value)
      return in_value.getType() == Type::INTEGER;
   else if (std::is_same<T, uint64_t>::value)
      return in_value.getType() == Type::INTEGER;
   else if (std::is_same<T, unsigned long>::value)
      return in_value.getType() == Type::INTEGER;
   else if (std::is_same<T, double>::value)
      return (in_value.getType() == Type::INTEGER) || (in_value.getType() == Type::REAL);
   else
      return false;
}
 
std::string typeAsString(Type in_type);
std::ostream& operator<<(std::ostream& io_ostream, Type in_type);
 
namespace detail {
 
template <typename T>
struct is_json_type : public std::is_base_of<Value, T>
{
};
 
template <typename T>
Type asJsonType(const T& in_object,
               std::true_type)
{
   return in_object.getType();
}
 
template <typename T>
Type asJsonType(const T& in_object,
               std::false_type)
{
   if (std::is_same<T, bool>::value)
      return Type::BOOL;
   else if (std::is_same<T, int>::value)
      return Type::INTEGER;
   else if (std::is_same<T, double>::value)
      return Type::REAL;
   else if (std::is_same<T, std::string>::value)
      return Type::STRING;
   
   logging::logErrorMessage("Unexpected type");
   return Type::NULL_TYPE;
}
 
template <typename T>
inline Value toJsonValue(const T& in_value)
{
   return Value(in_value);
}
 
template <typename T>
inline Value toJsonValue(const Optional<T>& in_value)
{
   return in_value ? Value(*in_value) : Value();
}
 
template <typename T>
inline Value toJsonValue(const std::vector<T>& in_vector)
{
   Array results;
   for (auto&& val : in_vector)
   {
      results.push_back(val);
   }
 
   return std::move(results);
}
 
template <typename T>
inline Value toJsonValue(const std::set<T>& in_set)
{
   Array results;
   for (const T& val : in_set)
   {
      results.push_back(val);
   }
 
   return std::move(results);
}
 
} // namespace detail
 
template <typename T>
Type asJsonType(const T& in_object)
{
   return detail::asJsonType(
      in_object,
      detail::is_json_type<T>());
}
 
inline std::string typeAsString(const Value& in_value)
{
   return typeAsString(in_value.getType());
}
 
template <typename T>
inline Value toJsonValue(const T& in_value)
{
   return detail::toJsonValue(in_value);
}
 
template<typename T>
Array toJsonArray(const std::vector<T>& in_vector)
{
   return detail::toJsonValue(in_vector).getArray();
}
 
template<typename T>
Array toJsonArray(const std::set<T>& in_set)
{
   return detail::toJsonValue(in_set).getArray();
}
 
enum class JsonReadError
{
   SUCCESS = 0,
   MISSING_MEMBER = 1,
   INVALID_TYPE = 2,
};
 
Error jsonReadError(JsonReadError in_errorCode, const std::string& in_message, const ErrorLocation& in_errorLocation);
 
bool isMissingMemberError(const Error& in_error);
 
template <typename T>
Error readObject(const Object& in_object, const std::string& in_name, T& out_value)
{
   Object::Iterator itr = in_object.find(in_name);
   if ((itr == in_object.end()) || (*itr).getValue().isNull())
      return jsonReadError(
         JsonReadError::MISSING_MEMBER,
         "Member " + in_name + " does not exist in the specified JSON object.",
         ERROR_LOCATION);
 
   if (!isType<T>((*itr).getValue()))
   {
      std::ostringstream msgStream;
      msgStream << "Member " << in_name << " has type " << (*itr).getValue().getType() <<
                " which is not compatible with requested type " << typeid(T).name() << ".";
      return jsonReadError(
         JsonReadError::INVALID_TYPE,
         msgStream.str(),
         ERROR_LOCATION);
   }
 
   out_value = (*itr).getValue().getValue<T>();
   return Success();
}
 
template <typename T>
Error readObject(const Object& in_object, const std::string& in_name, Optional<T>& out_value)
{
   // If the value is optional, no need to report that it's missing.
   Object::Iterator itr = in_object.find(in_name);
   if (itr == in_object.end() || (*itr).getValue().isNull())
      return Success();
 
   if (!isType<T>((*itr).getValue()))
   {
      std::ostringstream msgStream;
      msgStream << "Member " << in_name << " has type " << (*itr).getValue().getType() <<
                " which is not compatible with requested type " << typeid(T).name() << ".";
      return jsonReadError(
         JsonReadError::INVALID_TYPE,
         msgStream.str(),
         ERROR_LOCATION);
   }
 
   out_value = (*itr).getValue().getValue<T>();
   return Success();
}
 
template <typename T>
Error readObject(const Object& in_object, const std::string& in_name, std::vector<T>& out_values)
{
   Object::Iterator itr = in_object.find(in_name);
   if ((itr == in_object.end()) || (*itr).getValue().isNull())
      return jsonReadError(
         JsonReadError::MISSING_MEMBER,
         "Member " + in_name + " does not exist in the specified JSON object.",
         ERROR_LOCATION);
 
   if (!(*itr).getValue().isArray())
      return jsonReadError(JsonReadError::INVALID_TYPE,
                           "Member " + in_name + " is not an array.",
                           ERROR_LOCATION);
 
   Array array = (*itr).getValue().getArray();
   for (size_t i = 0, n = array.getSize(); i < n; ++i)
   {
      const Value& value = array[i];
      if (!isType<T>(value))
      {
         std::ostringstream msgStream;
         msgStream << "Element " << i << " of member " + in_name << " is of type " <<  value.getType() <<
                   " which is not compatible with the requested type " << typeid(T).name() << ".";
         return jsonReadError(
            JsonReadError::INVALID_TYPE,
            msgStream.str(),
            ERROR_LOCATION);
      }
 
      out_values.push_back(value.getValue<T>());
   }
 
   return Success();
}
 
template <typename T>
Error readObject(const Object& in_object, const std::string& in_name, std::set<T>& out_values)
{
   Object::Iterator itr = in_object.find(in_name);
   if ((itr == in_object.end()) || (*itr).getValue().isNull())
      return jsonReadError(
         JsonReadError::MISSING_MEMBER,
         "Member " + in_name + " does not exist in the specified JSON object.",
         ERROR_LOCATION);
 
   if (!(*itr).getValue().isArray())
      return jsonReadError(JsonReadError::INVALID_TYPE,
                           "Member " + in_name + " is not an array.",
                           ERROR_LOCATION);
 
   Array array = (*itr).getValue().getArray();
   for (size_t i = 0, n = array.getSize(); i < n; ++i)
   {
      const Value& value = array[i];
      if (!isType<T>(value))
      {
         std::ostringstream msgStream;
         msgStream << "Element " << i << " of member " + in_name << " is of type " <<  value.getType() <<
                   " which is not compatible with the requested type " << typeid(T).name() << ".";
         return jsonReadError(
            JsonReadError::INVALID_TYPE,
            msgStream.str(),
            ERROR_LOCATION);
      }
 
      out_values.insert(value.getValue<T>());
   }
 
   return Success();
}
 
template <typename T>
Error readObject(const Object& in_object, const std::string& in_name, Optional<std::vector<T> >& out_values)
{
   std::vector<T> values;
   Error error = readObject(in_object, in_name, values);
   if (error && !isMissingMemberError(error))
      return error;
   else if (!error)
      out_values = values;
 
   return Success();
}
 
template <typename T>
Error readObject(const Object& in_object, const std::string& in_name, Optional<std::set<T> >& out_values)
{
   std::set<T> values;
   Error error = readObject(in_object, in_name, values);
   if (error && !isMissingMemberError(error))
      return error;
   else if (!error)
      out_values = values;
 
   return Success();
}
 
template <typename T, typename... Args>
Error readObject(const Object& in_object, const std::string& in_name, T& out_value, Args&... io_args)
{
   Error error = readObject(in_object, in_name, out_value);
   if (error)
      return error;
 
   return readObject(in_object, io_args...);
}
 
template <typename T, typename... Args>
Error readObject(const Object& in_object, const std::string& in_name, Optional<T>& out_value, Args&... io_args)
{
   Error error = readObject(in_object, in_name, out_value);
   if (error)
      return error;
 
   return readObject(in_object, io_args...);
}
 
template <typename T, typename... Args>
Error readObject(const Object& in_object, const std::string& in_name, std::vector<T>& out_values, Args&... io_args)
{
   Error error = readObject(in_object, in_name, out_values);
   if (error)
      return error;
 
   return readObject(in_object, io_args...);
}
 
template <typename T, typename... Args>
Error readObject(const Object& in_object, const std::string& in_name, std::set<T>& out_values, Args&... io_args)
{
   Error error = readObject(in_object, in_name, out_values);
   if (error)
      return error;
 
   return readObject(in_object, io_args...);
}
 
template <typename T, typename... Args>
Error readObject(
   const Object& in_object,
   const std::string& in_name,
   Optional<std::vector<T> >& out_value,
   Args&... io_args)
{
   Error error = readObject(in_object, in_name, out_value);
   if (error)
      return error;
 
   return readObject(in_object, io_args...);
}
 
template <typename T, typename... Args>
Error readObject(
   const Object& in_object,
   const std::string& in_name,
   Optional<std::set<T> >& out_value,
   Args&... io_args)
{
   Error error = readObject(in_object, in_name, out_value);
   if (error)
      return error;
 
   return readObject(in_object, io_args...);
}
 
} // namespace json
} // namespace launcher_plugins
} // namespace rstudio
 
#endif // LAUNCHER_PLUGINS_JSON_HPP