folly::json_patch Class Reference

#include <json_patch.h>

Classes
struct	parse_error
struct	patch_operation

Public Types
enum	parse_error_code : uint8_t {   parse_error_code::undefined, parse_error_code::invalid_shape, parse_error_code::missing_op, parse_error_code::unknown_op,   parse_error_code::malformed_op, parse_error_code::missing_path_attr, parse_error_code::malformed_path_attr, parse_error_code::missing_from_attr,   parse_error_code::malformed_from_attr, parse_error_code::missing_value_attr, parse_error_code::overlapping_pointers }
enum	patch_operation_code : uint8_t {   patch_operation_code::invalid = 0, patch_operation_code::test, patch_operation_code::remove, patch_operation_code::add,   patch_operation_code::replace, patch_operation_code::move, patch_operation_code::copy }

Public Member Functions
	json_patch ()=default
	~json_patch ()=default
std::vector< patch_operation > const &	ops () const

Static Public Member Functions
static folly::Expected< json_patch, parse_error >	try_parse (dynamic const &obj) noexcept

Private Attributes
std::vector< patch_operation >	ops_

Detailed Description

Definition at line 34 of file json_patch.h.

Member Enumeration Documentation

enum folly::json_patch::parse_error_code : uint8_t

strong

Enumerator
undefined
invalid_shape
missing_op
unknown_op
malformed_op
missing_path_attr
malformed_path_attr
missing_from_attr
malformed_from_attr
missing_value_attr
overlapping_pointers

Definition at line 36 of file json_patch.h.

                              : uint8_t {
    undefined,
    invalid_shape,
    missing_op,
    unknown_op,
    malformed_op,
    missing_path_attr,
    malformed_path_attr,
    missing_from_attr,
    malformed_from_attr,
    missing_value_attr,
    overlapping_pointers,
  };

enum folly::json_patch::patch_operation_code : uint8_t

strong

Enumerator
invalid
test
remove
add
replace
move
copy

Definition at line 61 of file json_patch.h.

                                  : uint8_t {
    invalid = 0,
    test,
    remove,
    add,
    replace,
    move,
    copy,
  };

Constructor & Destructor Documentation

folly::json_patch::json_patch ( )

default

folly::json_patch::~json_patch ( )

default

Member Function Documentation

std::vector< json_patch::patch_operation > const & folly::json_patch::ops

(

)

const

Definition at line 151 of file json_patch.cpp.

References ops_.

                                                                  {
  return ops_;
}

Expected< json_patch, json_patch::parse_error > folly::json_patch::try_parse ( dynamic const &  obj )

staticnoexcept

Definition at line 38 of file json_patch.cpp.

References add, copy, folly::json_patch::patch_operation::from, invalid, invalid_shape, folly::makeUnexpected(), malformed_from_attr, malformed_op, malformed_path_attr, missing_from_attr, missing_op, missing_path_attr, missing_value_attr, move, folly::gen::move, folly::json_patch::patch_operation::op_code, ops_, overlapping_pointers, folly::json_patch::patch_operation::path, remove, replace, test, folly::json_pointer::try_parse(), unknown_op, and folly::json_patch::patch_operation::value.

                                 {
  using err_code = parse_error_code;

  json_patch patch;
  if (!obj.isArray()) {
    return makeUnexpected(parse_error{err_code::invalid_shape, &obj});
  }
  for (auto const& elem : obj) {
    if (!elem.isObject()) {
      return makeUnexpected(parse_error{err_code::invalid_shape, &elem});
    }
    auto const* op_ptr = elem.get_ptr(kOpTag);
    if (!op_ptr) {
      return makeUnexpected(parse_error{err_code::missing_op, &elem});
    }
    if (!op_ptr->isString()) {
      return makeUnexpected(parse_error{err_code::malformed_op, &elem});
    }
    auto const op_str = op_ptr->asString();
    patch_operation op;

    // extract 'from' attribute
    {
      auto const* from_ptr = elem.get_ptr(kFromTag);
      if (from_ptr) {
        if (!from_ptr->isString()) {
          return makeUnexpected(parse_error{err_code::invalid_shape, &elem});
        }
        auto json_ptr = json_pointer::try_parse(from_ptr->asString());
        if (!json_ptr.hasValue()) {
          return makeUnexpected(
              parse_error{err_code::malformed_from_attr, &elem});
        }
        op.from = json_ptr.value();
      }
    }

    // extract 'path' attribute
    {
      auto const* path_ptr = elem.get_ptr(kPathTag);
      if (!path_ptr) {
        return makeUnexpected(parse_error{err_code::missing_path_attr, &elem});
      }
      if (!path_ptr->isString()) {
        return makeUnexpected(
            parse_error{err_code::malformed_path_attr, &elem});
      }
      auto const json_ptr = json_pointer::try_parse(path_ptr->asString());
      if (!json_ptr.hasValue()) {
        return makeUnexpected(
            parse_error{err_code::malformed_path_attr, &elem});
      }
      op.path = json_ptr.value();
    }

    // extract 'value' attribute
    {
      auto const* val_ptr = elem.get_ptr(kValueTag);
      if (val_ptr) {
        op.value = *val_ptr;
      }
    }

    // check mandatory attributes - different per operation
    // NOTE: per RFC, the surplus attributes (e.g. 'from' with 'add')
    // should be simply ignored

    using op_code = patch_operation_code;

    if (op_str == kOperationTest) {
      if (!op.value) {
        return makeUnexpected(parse_error{err_code::missing_value_attr, &elem});
      }
      op.op_code = op_code::test;
    } else if (op_str == kOperationRemove) {
      op.op_code = op_code::remove;
    } else if (op_str == kOperationAdd) {
      if (!op.value) {
        return makeUnexpected(parse_error{err_code::missing_value_attr, &elem});
      }
      op.op_code = op_code::add;
    } else if (op_str == kOperationReplace) {
      if (!op.value) {
        return makeUnexpected(parse_error{err_code::missing_value_attr, &elem});
      }
      op.op_code = op_code::replace;
    } else if (op_str == kOperationMove) {
      if (!op.from) {
        return makeUnexpected(parse_error{err_code::missing_from_attr, &elem});
      }
      // is from a proper prefix to path?
      if (op.from->is_prefix_of(op.path)) {
        return makeUnexpected(
            parse_error{err_code::overlapping_pointers, &elem});
      }
      op.op_code = op_code::move;
    } else if (op_str == kOperationCopy) {
      if (!op.from) {
        return makeUnexpected(parse_error{err_code::missing_from_attr, &elem});
      }
      op.op_code = op_code::copy;
    }

    if (op.op_code != op_code::invalid) {
      patch.ops_.emplace_back(std::move(op));
    } else {
      return makeUnexpected(parse_error{err_code::unknown_op, &elem});
    }
  }
  return patch;
}

Member Data Documentation

std::vector<patch_operation> folly::json_patch::ops_

private

Definition at line 101 of file json_patch.h.

Referenced by ops(), and try_parse().

---

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

• proxygen/folly/folly/json_patch.h
• proxygen/folly/folly/json_patch.cpp