folly/DynamicConverter.h

   1 /*
   2  * Copyright 2015 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // @author Nicholas Ormrod <njormrod@fb.com>
  18
  19 #ifndef DYNAMIC_CONVERTER_H
  20 #define DYNAMIC_CONVERTER_H
  21
  22 #include <folly/dynamic.h>
  23 namespace folly {
  24   template <typename T> T convertTo(const dynamic&);
  25   template <typename T> dynamic toDynamic(const T&);
  26 }
  27
  28 /**
  29  * convertTo returns a well-typed representation of the input dynamic.
  30  *
  31  * Example:
  32  *
  33  *   dynamic d = { { 1, 2, 3 }, { 4, 5 } }; // a vector of vector of int
  34  *   auto vvi = convertTo<fbvector<fbvector<int>>>(d);
  35  *
  36  * See docs/DynamicConverter.md for supported types and customization
  37  */
  38
  39
  40 #include <type_traits>
  41 #include <iterator>
  42 #include <boost/iterator/iterator_adaptor.hpp>
  43 #include <boost/mpl/has_xxx.hpp>
  44 #include <folly/Likely.h>
  45
  46 namespace folly {
  47
  48 ///////////////////////////////////////////////////////////////////////////////
  49 // traits
  50
  51 namespace dynamicconverter_detail {
  52
  53 BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type);
  54 BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator);
  55 BOOST_MPL_HAS_XXX_TRAIT_DEF(mapped_type);
  56
  57 template <typename T> struct iterator_class_is_container {
  58   typedef std::reverse_iterator<typename T::iterator> some_iterator;
  59   enum { value = has_value_type<T>::value &&
  60               std::is_constructible<T, some_iterator, some_iterator>::value };
  61 };
  62
  63 template <typename T>
  64 using class_is_container = typename
  65   std::conditional<
  66     has_iterator<T>::value,
  67     iterator_class_is_container<T>,
  68     std::false_type
  69   >::type;
  70
  71 template <typename T> struct class_is_range {
  72   enum { value = has_value_type<T>::value &&
  73                  has_iterator<T>::value };
  74 };
  75
  76
  77 template <typename T> struct is_container
  78   : std::conditional<
  79       std::is_class<T>::value,
  80       class_is_container<T>,
  81       std::false_type
  82     >::type {};
  83
  84 template <typename T> struct is_range
  85   : std::conditional<
  86       std::is_class<T>::value,
  87       class_is_range<T>,
  88       std::false_type
  89     >::type {};
  90
  91 template <typename T> struct is_map
  92   : std::integral_constant<
  93       bool,
  94       is_range<T>::value && has_mapped_type<T>::value
  95     > {};
  96
  97 } // namespace dynamicconverter_detail
  98
  99 ///////////////////////////////////////////////////////////////////////////////
 100 // custom iterators
 101
 102 /**
 103  * We have iterators that dereference to dynamics, but need iterators
 104  * that dereference to typename T.
 105  *
 106  * Implementation details:
 107  *   1. We cache the value of the dereference operator. This is necessary
 108  *      because boost::iterator_adaptor requires *it to return a
 109  *      reference.
 110  *   2. For const reasons, we cannot call operator= to refresh the
 111  *      cache: we must call the destructor then placement new.
 112  */
 113
 114 namespace dynamicconverter_detail {
 115
 116 template<typename T>
 117 struct Dereferencer {
 118   static inline void derefToCache(
 119       T* /* mem */, const dynamic::const_item_iterator& /* it */) {
 120     throw TypeError("array", dynamic::Type::OBJECT);
 121   }
 122
 123   static inline void derefToCache(T* mem, const dynamic::const_iterator& it) {
 124     new (mem) T(convertTo<T>(*it));
 125   }
 126 };
 127
 128 template<typename F, typename S>
 129 struct Dereferencer<std::pair<F, S>> {
 130   static inline void
 131   derefToCache(std::pair<F, S>* mem, const dynamic::const_item_iterator& it) {
 132     new (mem) std::pair<F, S>(
 133         convertTo<F>(it->first), convertTo<S>(it->second)
 134     );
 135   }
 136
 137   // Intentional duplication of the code in Dereferencer
 138   template <typename T>
 139   static inline void derefToCache(T* mem, const dynamic::const_iterator& it) {
 140     new (mem) T(convertTo<T>(*it));
 141   }
 142 };
 143
 144 template <typename T, typename It>
 145 class Transformer : public boost::iterator_adaptor<
 146                              Transformer<T, It>,
 147                              It,
 148                              typename T::value_type
 149                            > {
 150   friend class boost::iterator_core_access;
 151
 152   typedef typename T::value_type ttype;
 153
 154   mutable ttype cache_;
 155   mutable bool valid_;
 156
 157   void increment() {
 158     ++this->base_reference();
 159     valid_ = false;
 160   }
 161
 162   ttype& dereference() const {
 163     if (LIKELY(!valid_)) {
 164       cache_.~ttype();
 165       Dereferencer<ttype>::derefToCache(&cache_, this->base_reference());
 166       valid_ = true;
 167     }
 168     return cache_;
 169   }
 170
 171 public:
 172   explicit Transformer(const It& it)
 173     : Transformer::iterator_adaptor_(it), valid_(false) {}
 174 };
 175
 176 // conversion factory
 177 template <typename T, typename It>
 178 inline std::move_iterator<Transformer<T, It>>
 179 conversionIterator(const It& it) {
 180   return std::make_move_iterator(Transformer<T, It>(it));
 181 }
 182
 183 } // namespace dynamicconverter_detail
 184
 185 ///////////////////////////////////////////////////////////////////////////////
 186 // DynamicConverter specializations
 187
 188 /**
 189  * Each specialization of DynamicConverter has the function
 190  *     'static T convert(const dynamic&);'
 191  */
 192
 193 // default - intentionally unimplemented
 194 template <typename T, typename Enable = void> struct DynamicConverter;
 195
 196 // boolean
 197 template <>
 198 struct DynamicConverter<bool> {
 199   static bool convert(const dynamic& d) {
 200     return d.asBool();
 201   }
 202 };
 203
 204 // integrals
 205 template <typename T>
 206 struct DynamicConverter<T,
 207     typename std::enable_if<std::is_integral<T>::value &&
 208                             !std::is_same<T, bool>::value>::type> {
 209   static T convert(const dynamic& d) {
 210     return folly::to<T>(d.asInt());
 211   }
 212 };
 213
 214 // floating point
 215 template <typename T>
 216 struct DynamicConverter<T,
 217     typename std::enable_if<std::is_floating_point<T>::value>::type> {
 218   static T convert(const dynamic& d) {
 219     return folly::to<T>(d.asDouble());
 220   }
 221 };
 222
 223 // fbstring
 224 template <>
 225 struct DynamicConverter<folly::fbstring> {
 226   static folly::fbstring convert(const dynamic& d) {
 227     return d.asString();
 228   }
 229 };
 230
 231 // std::string
 232 template <>
 233 struct DynamicConverter<std::string> {
 234   static std::string convert(const dynamic& d) {
 235     return d.asString().toStdString();
 236   }
 237 };
 238
 239 // std::pair
 240 template <typename F, typename S>
 241 struct DynamicConverter<std::pair<F,S>> {
 242   static std::pair<F, S> convert(const dynamic& d) {
 243     if (d.isArray() && d.size() == 2) {
 244       return std::make_pair(convertTo<F>(d[0]), convertTo<S>(d[1]));
 245     } else if (d.isObject() && d.size() == 1) {
 246       auto it = d.items().begin();
 247       return std::make_pair(convertTo<F>(it->first), convertTo<S>(it->second));
 248     } else {
 249       throw TypeError("array (size 2) or object (size 1)", d.type());
 250     }
 251   }
 252 };
 253
 254 // containers
 255 template <typename C>
 256 struct DynamicConverter<C,
 257     typename std::enable_if<
 258       dynamicconverter_detail::is_container<C>::value>::type> {
 259   static C convert(const dynamic& d) {
 260     if (d.isArray()) {
 261       return C(dynamicconverter_detail::conversionIterator<C>(d.begin()),
 262                dynamicconverter_detail::conversionIterator<C>(d.end()));
 263     } else if (d.isObject()) {
 264       return C(dynamicconverter_detail::conversionIterator<C>
 265                  (d.items().begin()),
 266                dynamicconverter_detail::conversionIterator<C>
 267                  (d.items().end()));
 268     } else {
 269       throw TypeError("object or array", d.type());
 270     }
 271   }
 272 };
 273
 274 ///////////////////////////////////////////////////////////////////////////////
 275 // DynamicConstructor specializations
 276
 277 /**
 278  * Each specialization of DynamicConstructor has the function
 279  *     'static dynamic construct(const C&);'
 280  */
 281
 282 // default
 283 template <typename C, typename Enable = void>
 284 struct DynamicConstructor {
 285   static dynamic construct(const C& x) {
 286     return dynamic(x);
 287   }
 288 };
 289
 290 // maps
 291 template<typename C>
 292 struct DynamicConstructor<C,
 293     typename std::enable_if<
 294       dynamicconverter_detail::is_map<C>::value>::type> {
 295   static dynamic construct(const C& x) {
 296     dynamic d = dynamic::object;
 297     for (auto& pair : x) {
 298       d.insert(toDynamic(pair.first), toDynamic(pair.second));
 299     }
 300     return d;
 301   }
 302 };
 303
 304 // other ranges
 305 template<typename C>
 306 struct DynamicConstructor<C,
 307     typename std::enable_if<
 308       !dynamicconverter_detail::is_map<C>::value &&
 309       !std::is_constructible<StringPiece, const C&>::value &&
 310       dynamicconverter_detail::is_range<C>::value>::type> {
 311   static dynamic construct(const C& x) {
 312     dynamic d = {};
 313     for (auto& item : x) {
 314       d.push_back(toDynamic(item));
 315     }
 316     return d;
 317   }
 318 };
 319
 320 // pair
 321 template<typename A, typename B>
 322 struct DynamicConstructor<std::pair<A, B>, void> {
 323   static dynamic construct(const std::pair<A, B>& x) {
 324     dynamic d = {};
 325     d.push_back(toDynamic(x.first));
 326     d.push_back(toDynamic(x.second));
 327     return d;
 328   }
 329 };
 330
 331 ///////////////////////////////////////////////////////////////////////////////
 332 // implementation
 333
 334 template <typename T>
 335 T convertTo(const dynamic& d) {
 336   return DynamicConverter<typename std::remove_cv<T>::type>::convert(d);
 337 }
 338
 339 template<typename T>
 340 dynamic toDynamic(const T& x) {
 341   return DynamicConstructor<typename std::remove_cv<T>::type>::construct(x);
 342 }
 343
 344 } // namespace folly
 345
 346 #endif // DYNAMIC_CONVERTER_H