path.hpp

Go to the documentation of this file.

/// \file jsonv/path.hpp
/// Support for [JSONPath](http://goessner.net/articles/JsonPath/).
///
/// Copyright (c) 2014-2020 by Travis Gockel. All rights reserved.
///
/// This program is free software: you can redistribute it and/or modify it under the terms of the Apache License
/// as published by the Apache Software Foundation, either version 2 of the License, or (at your option) any later
/// version.
///
/// \author Travis Gockel (travis@gockelhut.com)
#ifndef __JSONV_PATH_HPP_INCLUDED__
#define __JSONV_PATH_HPP_INCLUDED__
 
#include <jsonv/config.hpp>
#include <jsonv/detail/generic_container.hpp>
#include <string_view>
 
#include <iosfwd>
#include <memory>
#include <string>
#include <vector>
 
namespace jsonv
{
 
enum class path_element_kind : unsigned char
{
    array_index,
    object_key,
};
 
JSONV_PUBLIC std::ostream& operator<<(std::ostream&, const path_element_kind&);
 
JSONV_PUBLIC std::string to_string(const path_element_kind&);
 
class JSONV_PUBLIC path_element
{
public:
    path_element(std::size_t idx);
    path_element(int         idx);
    path_element(std::string key);
    path_element(std::string_view key);
    path_element(const char* key);
    path_element(const path_element&);
    path_element& operator=(const path_element&);
    path_element(path_element&&) noexcept;
    path_element& operator=(path_element&&) noexcept;
 
    ~path_element() noexcept;
 
    path_element_kind kind() const;
 
    std::size_t index() const;
 
    const std::string& key() const;
 
    bool operator==(const path_element&) const;
    bool operator!=(const path_element&) const;
 
private:
    union storage
    {
        std::size_t index;
        std::string key;
 
        storage(std::size_t   idx);
        storage(std::string&& key);
        ~storage() noexcept;
    };
 
private:
    path_element_kind _kind;
    storage           _data;
};
 
JSONV_PUBLIC std::ostream& operator<<(std::ostream&, const path_element&);
 
JSONV_PUBLIC std::string to_string(const path_element&);
 
/// Represents an exact path in some JSON structure.
class JSONV_PUBLIC path :
        public detail::generic_container<std::vector<path_element>>
{
public:
    /// Creates a new, empty path.
    path();
 
    /// Creates a path with the provided \a elements.
    path(storage_type elements);
 
    /// Create a \c path from a string definition. The syntax of this is ECMAScript's syntax for selecting elements, so
    /// <tt>path::create(".foo.bar[1]")</tt> is equivalent to <tt>path({ "foo", "bar", 1 })</tt>.
    ///
    /// \throws std::invalid_argument if the \a specification is not valid.
    static path create(std::string_view specification);
 
    path(const path&);
    path& operator=(const path&);
    path(path&&) noexcept;
    path& operator=(path&&) noexcept;
    ~path() noexcept;
 
    /// Return a new path with the given \a subpath appended to the back.
    path  operator+(const path& subpath) const;
    path& operator+=(const path& subpath);
 
    /// Return a new path with the given \a elem appended to the back.
    path  operator+(path_element elem) const;
    path& operator+=(path_element elem);
};
 
JSONV_PUBLIC std::ostream& operator<<(std::ostream&, const path&);
 
JSONV_PUBLIC std::string to_string(const path&);
 
}
 
#endif/*__JSONV_PATH_HPP_INCLUDED__*/