json_array.h

#ifndef SOURCEMETA_CORE_JSON_ARRAY_H_
#define SOURCEMETA_CORE_JSON_ARRAY_H_
 
#include <initializer_list> // std::initializer_list
#include <vector>           // std::vector
 
namespace sourcemeta::core {

template <typename Value> class JSONArray {
public:
  // Constructors
  using Container =
      std::vector<Value, typename Value::template Allocator<Value>>;
  JSONArray() : data{} {}
  JSONArray(std::initializer_list<Value> values) : data{values} {}
 
  // Operators
  // We cannot default given that this class references
  // a JSON "value" as an incomplete type
  auto operator<(const JSONArray<Value> &other) const noexcept -> bool {
    return this->data < other.data;
  }
  auto operator<=(const JSONArray<Value> &other) const noexcept -> bool {
    return this->data <= other.data;
  }
  auto operator>(const JSONArray<Value> &other) const noexcept -> bool {
    return this->data > other.data;
  }
  auto operator>=(const JSONArray<Value> &other) const noexcept -> bool {
    return this->data >= other.data;
  }
  auto operator==(const JSONArray<Value> &other) const noexcept -> bool {
    return this->data == other.data;
  }
  auto operator!=(const JSONArray<Value> &other) const noexcept -> bool {
    return this->data != other.data;
  }
 
  // Member types
  using value_type = typename Container::value_type;
  using allocator_type = typename Container::allocator_type;
  using size_type = typename Container::size_type;
  using difference_type = typename Container::difference_type;
  using reference = typename Container::reference;
  using const_reference = typename Container::const_reference;
  using pointer = typename Container::pointer;
  using const_pointer = typename Container::const_pointer;
  using iterator = typename Container::iterator;
  using const_iterator = typename Container::const_iterator;
  using reverse_iterator = typename Container::reverse_iterator;
  using const_reverse_iterator = typename Container::const_reverse_iterator;

  auto begin() noexcept -> iterator { return this->data.begin(); }
  auto end() noexcept -> iterator { return this->data.end(); }
  [[nodiscard]] auto begin() const noexcept -> const_iterator {
    return this->data.begin();
  }
  [[nodiscard]] auto end() const noexcept -> const_iterator {
    return this->data.end();
  }
  [[nodiscard]] auto cbegin() const noexcept -> const_iterator {
    return this->data.cbegin();
  }
  [[nodiscard]] auto cend() const noexcept -> const_iterator {
    return this->data.cend();
  }
  auto rbegin() noexcept -> reverse_iterator { return this->data.rbegin(); }
  auto rend() noexcept -> reverse_iterator { return this->data.rend(); }
  [[nodiscard]] auto rbegin() const noexcept -> const_reverse_iterator {
    return this->data.rbegin();
  }
  [[nodiscard]] auto rend() const noexcept -> const_reverse_iterator {
    return this->data.rend();
  }
  [[nodiscard]] auto crbegin() const noexcept -> const_reverse_iterator {
    return this->data.crbegin();
  }
  [[nodiscard]] auto crend() const noexcept -> const_reverse_iterator {
    return this->data.crend();
  }

  [[nodiscard]] auto size() const noexcept -> size_type {
    return this->data.size();
  }

  auto reserve(const size_type capacity) -> void {
    this->data.reserve(capacity);
  }
 
private:
  friend Value;
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(disable : 4251)
#endif
  Container data;
#if defined(_MSC_VER)
#pragma warning(default : 4251)
#endif
};
 
} // namespace sourcemeta::core
 
#endif