folly::json_pointer Class Reference

#include <json_pointer.h>

Classes
class	parse_exception

Public Types
enum	parse_error { parse_error::invalid_first_character, parse_error::invalid_escape_sequence }

Public Member Functions
	json_pointer ()=default
	~json_pointer ()=default
bool	is_prefix_of (json_pointer const &other) const noexcept
std::vector< std::string > const &	tokens () const

Static Public Member Functions
static Expected< json_pointer, parse_error >	try_parse (StringPiece const str)
static json_pointer	parse (StringPiece const str)

Private Member Functions
	json_pointer (std::vector< std::string >) noexcept

Static Private Member Functions
static bool	unescape (std::string &)

Private Attributes
std::vector< std::string >	tokens_

Friends
bool	operator== (json_pointer const &lhs, json_pointer const &rhs)
bool	operator!= (json_pointer const &lhs, json_pointer const &rhs)

Detailed Description

Definition at line 35 of file json_pointer.h.

Member Enumeration Documentation

enum folly::json_pointer::parse_error

strong

Enumerator
invalid_first_character
invalid_escape_sequence

Definition at line 37 of file json_pointer.h.

                         {
    invalid_first_character,
    invalid_escape_sequence,
  };

Constructor & Destructor Documentation

folly::json_pointer::json_pointer ( )

default

Referenced by try_parse().

folly::json_pointer::~json_pointer ( )

default

folly::json_pointer::json_pointer ( std::vector< std::string >  tokens )

explicitprivatenoexcept

Definition at line 81 of file json_pointer.cpp.

References folly::gen::move, and tokens().

    : tokens_{std::move(tokens)} {}

Member Function Documentation

bool folly::json_pointer::is_prefix_of ( json_pointer const &  other ) const

noexcept

Definition at line 66 of file json_pointer.cpp.

References tokens_.

                                                                        {
  auto const& other_tokens = other.tokens();
  if (tokens_.size() > other_tokens.size()) {
    return false;
  }
  auto const other_begin = other_tokens.cbegin();
  auto const other_end = other_tokens.cbegin() + tokens_.size();
  return std::equal(tokens_.cbegin(), tokens_.cend(), other_begin, other_end);
}

json_pointer folly::json_pointer::parse ( StringPiece const  str )

static

Definition at line 49 of file json_pointer.cpp.

References folly::assume_unreachable(), invalid_escape_sequence, invalid_first_character, folly::gen::move, and try_parse().

                                                      {
  auto res = try_parse(str);
  if (res.hasValue()) {
    return std::move(res.value());
  }
  switch (res.error()) {
    case parse_error::invalid_first_character:
      throw json_pointer::parse_exception(
          "non-empty JSON pointer string does not start with '/'");
    case parse_error::invalid_escape_sequence:
      throw json_pointer::parse_exception(
          "Invalid escape sequence in JSON pointer string");
    default:
      assume_unreachable();
  }
}

std::vector< std::string > const & folly::json_pointer::tokens

(

)

const

Definition at line 76 of file json_pointer.cpp.

References tokens_.

Referenced by json_pointer(), and try_parse().

                                                       {
  return tokens_;
}

Expected< json_pointer, json_pointer::parse_error > folly::json_pointer::try_parse ( StringPiece const  str )

static

Definition at line 24 of file json_pointer.cpp.

References folly::Range< Iter >::at(), folly::Range< Iter >::empty(), invalid_escape_sequence, invalid_first_character, json_pointer(), folly::makeUnexpected(), folly::gen::move, tokens(), and unescape().

Referenced by parse(), and folly::json_patch::try_parse().

                           {
  // pointer describes complete document
  if (str.empty()) {
    return json_pointer{};
  }

  if (str.at(0) != '/') {
    return makeUnexpected(parse_error::invalid_first_character);
  }

  std::vector<std::string> tokens;
  splitTo<std::string>("/", str, std::inserter(tokens, tokens.begin()));
  tokens.erase(tokens.begin());

  for (auto& token : tokens) {
    if (!unescape(token)) {
      return makeUnexpected(parse_error::invalid_escape_sequence);
    }
  }

  return json_pointer(std::move(tokens));
}

bool folly::json_pointer::unescape ( std::string &  str )

staticprivate

Definition at line 85 of file json_pointer.cpp.

References fizz::decode(), and folly::test::end().

Referenced by try_parse().

                                          {
  char const* end = &str[str.size()];
  char* out = &str.front();
  char const* decode = out;
  while (decode < end) {
    if (*decode != '~') {
      *out++ = *decode++;
      continue;
    }
    if (decode + 1 == end) {
      return false;
    }
    switch (decode[1]) {
      case '1':
        *out++ = '/';
        break;
      case '0':
        *out++ = '~';
        break;
      default:
        return false;
    }
    decode += 2;
  }
  str.resize(out - &str.front());
  return true;
}

Friends And Related Function Documentation

bool operator!= ( json_pointer const &  lhs, json_pointer const &  rhs  )

friend

Definition at line 72 of file json_pointer.h.

                                                                           {
    return lhs.tokens_ != rhs.tokens_;
  }

bool operator== ( json_pointer const &  lhs, json_pointer const &  rhs  )

friend

Definition at line 68 of file json_pointer.h.

                                                                           {
    return lhs.tokens_ == rhs.tokens_;
  }

Member Data Documentation

std::vector<std::string> folly::json_pointer::tokens_

private

Definition at line 84 of file json_pointer.h.

Referenced by is_prefix_of(), and tokens().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/json_pointer.h
• proxygen/folly/folly/json_pointer.cpp