X-Git-Url: http://plrg.eecs.uci.edu/git/?p=folly.git;a=blobdiff_plain;f=folly%2Fdynamic.cpp;h=8c25017d3e4d85c7a740710fb185161e4b5963d5;hp=e58292447f27b0bcc916b404b57a1de73c75200b;hb=171c36527455c2709be57f2ccc41218d45689411;hpb=c636ccbe85cd086426dceb645dca71e7dc1d7efd diff --git a/folly/dynamic.cpp b/folly/dynamic.cpp index e5829244..8c25017d 100644 --- a/folly/dynamic.cpp +++ b/folly/dynamic.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2015 Facebook, Inc. + * Copyright 2017 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,62 +16,100 @@ #include +#include +#include +#include +#include + namespace folly { ////////////////////////////////////////////////////////////////////// -#define DEF_TYPE(T, str, typen) \ - template<> char const dynamic::TypeInfo::name[] = str; \ - template<> dynamic::Type const dynamic::TypeInfo::type = typen +#define FOLLY_DYNAMIC_DEF_TYPEINFO(T) \ + constexpr const char* dynamic::TypeInfo::name; \ + constexpr dynamic::Type dynamic::TypeInfo::type; \ + // -DEF_TYPE(void*, "null", dynamic::NULLT); -DEF_TYPE(bool, "boolean", dynamic::BOOL); -DEF_TYPE(fbstring, "string", dynamic::STRING); -DEF_TYPE(dynamic::Array, "array", dynamic::ARRAY); -DEF_TYPE(double, "double", dynamic::DOUBLE); -DEF_TYPE(int64_t, "int64", dynamic::INT64); -DEF_TYPE(dynamic::ObjectImpl, "object", dynamic::OBJECT); +FOLLY_DYNAMIC_DEF_TYPEINFO(std::nullptr_t) +FOLLY_DYNAMIC_DEF_TYPEINFO(bool) +FOLLY_DYNAMIC_DEF_TYPEINFO(std::string) +FOLLY_DYNAMIC_DEF_TYPEINFO(dynamic::Array) +FOLLY_DYNAMIC_DEF_TYPEINFO(double) +FOLLY_DYNAMIC_DEF_TYPEINFO(int64_t) +FOLLY_DYNAMIC_DEF_TYPEINFO(dynamic::ObjectImpl) -#undef DEF_TYPE +#undef FOLLY_DYNAMIC_DEF_TYPEINFO const char* dynamic::typeName() const { return typeName(type_); } TypeError::TypeError(const std::string& expected, dynamic::Type actual) - : std::runtime_error(to("TypeError: expected dynamic " - "type `", expected, '\'', ", but had type `", - dynamic::typeName(actual), '\'')) -{} - -TypeError::TypeError(const std::string& expected, - dynamic::Type actual1, dynamic::Type actual2) - : std::runtime_error(to("TypeError: expected dynamic " - "types `", expected, '\'', ", but had types `", - dynamic::typeName(actual1), "' and `", dynamic::typeName(actual2), - '\'')) -{} + : std::runtime_error(sformat( + "TypeError: expected dynamic type `{}', but had type `{}'", + expected, + dynamic::typeName(actual))) {} + +TypeError::TypeError( + const std::string& expected, + dynamic::Type actual1, + dynamic::Type actual2) + : std::runtime_error(sformat( + "TypeError: expected dynamic types `{}, but had types `{}' and `{}'", + expected, + dynamic::typeName(actual1), + dynamic::typeName(actual2))) {} TypeError::~TypeError() = default; +[[noreturn]] void throwTypeError_( + std::string const& expected, + dynamic::Type actual) { + throw TypeError(expected, actual); +} + +[[noreturn]] void throwTypeError_( + std::string const& expected, + dynamic::Type actual1, + dynamic::Type actual2) { + throw TypeError(expected, actual1, actual2); +} + // This is a higher-order preprocessor macro to aid going from runtime // types to the compile time type system. -#define FB_DYNAMIC_APPLY(type, apply) do { \ - switch ((type)) { \ - case NULLT: apply(void*); break; \ - case ARRAY: apply(Array); break; \ - case BOOL: apply(bool); break; \ - case DOUBLE: apply(double); break; \ - case INT64: apply(int64_t); break; \ - case OBJECT: apply(ObjectImpl); break; \ - case STRING: apply(fbstring); break; \ - default: CHECK(0); abort(); \ - } \ -} while (0) +#define FB_DYNAMIC_APPLY(type, apply) \ + do { \ + switch ((type)) { \ + case NULLT: \ + apply(std::nullptr_t); \ + break; \ + case ARRAY: \ + apply(Array); \ + break; \ + case BOOL: \ + apply(bool); \ + break; \ + case DOUBLE: \ + apply(double); \ + break; \ + case INT64: \ + apply(int64_t); \ + break; \ + case OBJECT: \ + apply(ObjectImpl); \ + break; \ + case STRING: \ + apply(std::string); \ + break; \ + default: \ + CHECK(0); \ + abort(); \ + } \ + } while (0) bool dynamic::operator<(dynamic const& o) const { if (UNLIKELY(type_ == OBJECT || o.type_ == OBJECT)) { - throw TypeError("object", type_); + throwTypeError_("object", type_); } if (type_ != o.type_) { return type_ < o.type_; @@ -132,9 +170,9 @@ dynamic& dynamic::operator=(dynamic&& o) noexcept { return *this; } -dynamic& dynamic::operator[](dynamic const& k) { +dynamic& dynamic::operator[](dynamic const& k) & { if (!isObject() && !isArray()) { - throw TypeError("object/array", type()); + throwTypeError_("object/array", type()); } if (isArray()) { return at(k); @@ -144,31 +182,49 @@ dynamic& dynamic::operator[](dynamic const& k) { return ret.first->second; } -dynamic dynamic::getDefault(const dynamic& k, const dynamic& v) const { +dynamic dynamic::getDefault(const dynamic& k, const dynamic& v) const& { auto& obj = get(); auto it = obj.find(k); return it == obj.end() ? v : it->second; } -dynamic&& dynamic::getDefault(const dynamic& k, dynamic&& v) const { +dynamic dynamic::getDefault(const dynamic& k, dynamic&& v) const& { + auto& obj = get(); + auto it = obj.find(k); + // Avoid clang bug with ternary + if (it == obj.end()) { + return std::move(v); + } else { + return it->second; + } +} + +dynamic dynamic::getDefault(const dynamic& k, const dynamic& v) && { auto& obj = get(); auto it = obj.find(k); - if (it != obj.end()) { - v = it->second; + // Avoid clang bug with ternary + if (it == obj.end()) { + return v; + } else { + return std::move(it->second); } +} - return std::move(v); +dynamic dynamic::getDefault(const dynamic& k, dynamic&& v) && { + auto& obj = get(); + auto it = obj.find(k); + return std::move(it == obj.end() ? v : it->second); } -const dynamic* dynamic::get_ptr(dynamic const& idx) const { +const dynamic* dynamic::get_ptr(dynamic const& idx) const& { if (auto* parray = get_nothrow()) { if (!idx.isInt()) { - throw TypeError("int64", idx.type()); + throwTypeError_("int64", idx.type()); } if (idx < 0 || idx >= parray->size()) { return nullptr; } - return &(*parray)[idx.asInt()]; + return &(*parray)[size_t(idx.asInt())]; } else if (auto* pobject = get_nothrow()) { auto it = pobject->find(idx); if (it == pobject->end()) { @@ -176,28 +232,32 @@ const dynamic* dynamic::get_ptr(dynamic const& idx) const { } return &it->second; } else { - throw TypeError("object/array", type()); + throwTypeError_("object/array", type()); } } -dynamic const& dynamic::at(dynamic const& idx) const { +[[noreturn]] static void throwOutOfRangeAtMissingKey(dynamic const& idx) { + auto msg = sformat("couldn't find key {} in dynamic object", idx.asString()); + std::__throw_out_of_range(msg.c_str()); +} + +dynamic const& dynamic::at(dynamic const& idx) const& { if (auto* parray = get_nothrow()) { if (!idx.isInt()) { - throw TypeError("int64", idx.type()); + throwTypeError_("int64", idx.type()); } if (idx < 0 || idx >= parray->size()) { - throw std::out_of_range("out of range in dynamic array"); + std::__throw_out_of_range("out of range in dynamic array"); } - return (*parray)[idx.asInt()]; + return (*parray)[size_t(idx.asInt())]; } else if (auto* pobject = get_nothrow()) { auto it = pobject->find(idx); if (it == pobject->end()) { - throw std::out_of_range(to( - "couldn't find key ", idx.asString(), " in dynamic object")); + throwOutOfRangeAtMissingKey(idx); } return it->second; } else { - throw TypeError("object/array", type()); + throwTypeError_("object/array", type()); } } @@ -208,14 +268,13 @@ std::size_t dynamic::size() const { if (auto* obj = get_nothrow()) { return obj->size(); } - if (auto* str = get_nothrow()) { + if (auto* str = get_nothrow()) { return str->size(); } - throw TypeError("array/object", type()); + throwTypeError_("array/object", type()); } -dynamic::const_iterator -dynamic::erase(const_iterator first, const_iterator last) { +dynamic::iterator dynamic::erase(const_iterator first, const_iterator last) { auto& arr = get(); return get().erase( arr.begin() + (first - arr.begin()), @@ -227,18 +286,20 @@ std::size_t dynamic::hash() const { case OBJECT: case ARRAY: case NULLT: - throw TypeError("not null/object/array", type()); + throwTypeError_("not null/object/array", type()); case INT64: - return std::hash()(asInt()); + return std::hash()(getInt()); case DOUBLE: - return std::hash()(asDouble()); + return std::hash()(getDouble()); case BOOL: - return std::hash()(asBool()); - case STRING: - return std::hash()(asString()); - default: - CHECK(0); abort(); + return std::hash()(getBool()); + case STRING: { + // keep it compatible with FBString + const auto& str = getString(); + return ::folly::hash::fnv32_buf(str.data(), str.size()); + } } + assume_unreachable(); } char const* dynamic::typeName(Type t) { @@ -249,7 +310,9 @@ char const* dynamic::typeName(Type t) { void dynamic::destroy() noexcept { // This short-circuit speeds up some microbenchmarks. - if (type_ == NULLT) return; + if (type_ == NULLT) { + return; + } #define FB_X(T) detail::Destroy::destroy(getAddress()) FB_DYNAMIC_APPLY(type_, FB_X); @@ -260,4 +323,4 @@ void dynamic::destroy() noexcept { ////////////////////////////////////////////////////////////////////// -} +} // namespace folly