ev-decoder.hpp

Go to the documentation of this file.

#ifndef NDNPH_TLV_EV_DECODER_HPP
#define NDNPH_TLV_EV_DECODER_HPP
 
#include "nni.hpp"
 
namespace ndnph {
namespace detail {
 
template<int type, bool repeatable, int order>
struct EvdElementDefBase {
  using TT = std::integral_constant<int, type>;
  using Repeatable = std::integral_constant<bool, repeatable>;
  using Order = std::integral_constant<int, order>;
};
struct EvdElementDefBase {…};
 
template<int type, bool repeatable, int order, typename Fn>
class EvdElementDefVoid : public EvdElementDefBase<type, repeatable, order> {
public:
  explicit EvdElementDefVoid(const Fn& f)
    : m_f(f) {}
  explicit EvdElementDefVoid(const Fn& f) {…}
 
  bool operator()(const Decoder::Tlv& d) const {
    m_f(d);
    return true;
  }
  bool operator()(const Decoder::Tlv& d) const  {…}
 
private:
  const Fn& m_f;
};
class EvdElementDefVoid : public EvdElementDefBase<type, repeatable, order> {…};
 
template<int type, bool repeatable, int order, typename Fn>
class EvdElementDefBool : public EvdElementDefBase<type, repeatable, order> {
public:
  explicit EvdElementDefBool(const Fn& f)
    : m_f(f) {}
  explicit EvdElementDefBool(const Fn& f) {…}
 
  bool operator()(const Decoder::Tlv& d) const {
    return m_f(d);
  }
  bool operator()(const Decoder::Tlv& d) const  {…}
 
private:
  const Fn& m_f;
};
class EvdElementDefBool : public EvdElementDefBase<type, repeatable, order> {…};
 
template<int type, bool repeatable, int order, typename Fn,
         typename R = typename std::conditional<
           std::is_convertible<decltype(std::declval<Fn>()(Decoder::Tlv())), bool>::value,
           EvdElementDefBool<type, repeatable, order, Fn>,
           EvdElementDefVoid<type, repeatable, order, Fn>>::type>
class EvdElementDefFn : public R {
public:
  using R::R;
};
class EvdElementDefFn : public R {…};
 
template<int type, bool repeatable, int order, typename Decodable>
class EvdElementDefDecodable : public EvdElementDefBase<type, repeatable, order> {
public:
  explicit EvdElementDefDecodable(Decodable* obj)
    : m_obj(obj) {}
  explicit EvdElementDefDecodable(Decodable* obj) {…}
 
  bool operator()(const Decoder::Tlv& d) const {
    return m_obj->decodeFrom(d);
  }
  bool operator()(const Decoder::Tlv& d) const  {…}
 
private:
  Decodable* m_obj;
};
class EvdElementDefDecodable : public EvdElementDefBase<type, repeatable, order> {…};
 
template<int type, bool repeatable, int order>
struct EvdElementDefIgnore : public EvdElementDefBase<type, repeatable, order> {
  bool operator()(const Decoder::Tlv&) const {
    return true;
  }
  bool operator()(const Decoder::Tlv&) const  {…}
};
struct EvdElementDefIgnore : public EvdElementDefBase<type, repeatable, order> {…};
 
template<int type, int order, typename NniClass, typename ValueType>
class EvdElementDefNni : public EvdElementDefBase<type, false, order> {
public:
  explicit EvdElementDefNni(ValueType* value)
    : m_value(value) {}
  explicit EvdElementDefNni(ValueType* value) {…}
 
  bool operator()(const Decoder::Tlv& d) const {
    return NniClass::decode(d, *m_value);
  }
  bool operator()(const Decoder::Tlv& d) const  {…}
 
private:
  ValueType* m_value;
};
class EvdElementDefNni : public EvdElementDefBase<type, false, order> {…};
 
} // namespace detail
 
class EvDecoder {
public:
  class DefaultUnknownCb {
  public:
    bool operator()(const Decoder::Tlv&, int&) const {
      return false;
    }
    bool operator()(const Decoder::Tlv&, int&) const  {…}
  };
  class DefaultUnknownCb {…};
 
  class DefaultIsCritical {
  public:
    bool operator()(uint32_t type) const {
      return type <= 0x1F || type % 2 == 1;
    }
    bool operator()(uint32_t type) const  {…}
  };
  class DefaultIsCritical {…};
 
  template<typename... E>
  static bool decode(const Decoder::Tlv& input, std::initializer_list<uint32_t> topTypes,
                     const E&... defs) {
    return decodeEx(input, topTypes, DefaultUnknownCb(), DefaultIsCritical(), defs...);
  }
  static bool decode(const Decoder::Tlv& input, std::initializer_list<uint32_t> topTypes, {…}
 
  template<typename... E>
  static bool decodeValue(const Decoder& input, const E&... defs) {
    return decodeValueEx(input, DefaultUnknownCb(), DefaultIsCritical(), defs...);
  }
  static bool decodeValue(const Decoder& input, const E&... defs) {…}
 
  template<typename UnknownCallback, typename IsCritical, typename... E>
  static bool decodeEx(const Decoder::Tlv& input, std::initializer_list<uint32_t> topTypes,
 
                       const UnknownCallback& unknownCb, const IsCritical& isCritical,
                       const E&... defs) {
    if (topTypes.size() > 0 &&
        std::find(topTypes.begin(), topTypes.end(), input.type) == topTypes.end()) {
      return false;
    }
    return decodeValueEx(input.vd(), unknownCb, isCritical, defs...);
  }
  static bool decodeEx(const Decoder::Tlv& input, std::initializer_list<uint32_t> topTypes, {…}
 
  template<typename UnknownCallback, typename IsCritical, typename... E>
  static bool decodeValueEx(const Decoder& input, const UnknownCallback& unknownCb,
                            const IsCritical& isCritical, const E&... defs) {
    int currentOrder = 0;
    for (const auto& d : input) {
      bool ok = decodeElement<AUTO_ORDER_SKIP>(d, currentOrder, unknownCb, isCritical, defs...);
      if (!ok) {
        return false;
      }
    }
    return true;
  }
  static bool decodeValueEx(const Decoder& input, const UnknownCallback& unknownCb, {…}
 
  template<int type, bool repeatable = false, int order = 0, typename Fn = void,
           typename R = detail::EvdElementDefFn<type, repeatable, order, Fn>>
  static R def(const Fn& f, decltype(&Fn::operator()) = nullptr) {
    return R(f);
  }
  static R def(const Fn& f, decltype(&Fn::operator()) = nullptr) {…}
 
  template<int type, bool repeatable = false, int order = 0, typename Decodable = void,
           typename R = detail::EvdElementDefDecodable<type, repeatable, order, Decodable>>
  static R def(Decodable* decodable, decltype(&Decodable::decodeFrom) = nullptr) {
    return R(decodable);
  }
  static R def(Decodable* decodable, decltype(&Decodable::decodeFrom) = nullptr) {…}
 
  template<int type, bool repeatable = false, int order = 0,
           typename R = detail::EvdElementDefIgnore<type, repeatable, order>>
  static R defIgnore() {
    return R();
  }
  static R defIgnore() {…}
 
  template<int type, typename NniClass = tlv::NNI, int order = 0, typename ValueType = void,
           typename R = detail::EvdElementDefNni<type, order, NniClass, ValueType>>
  static R defNni(ValueType* value) {
    return R(value);
  }
  static R defNni(ValueType* value) {…}
 
private:
  EvDecoder() = delete;
 
  enum {
    AUTO_ORDER_SKIP = 100,
  };
 
  template<int autoOrder, typename UnknownCallback, typename IsCritical, typename First,
           typename... E>
  static bool decodeElement(const Decoder::Tlv& d, int& currentOrder,
                            const UnknownCallback& unknownCb, const IsCritical& isCritical,
                            const First& first, const E&... defs) {
    if (d.type == First::TT::value) {
      return useDef<autoOrder>(d, currentOrder, isCritical, first);
    }
    return decodeElement<autoOrder + AUTO_ORDER_SKIP>(d, currentOrder, unknownCb, isCritical,
                                                      defs...);
  }
 
  template<int autoOrder, typename UnknownCallback, typename IsCritical>
  static bool decodeElement(const Decoder::Tlv& d, int& currentOrder,
                            const UnknownCallback& unknownCb, const IsCritical& isCritical) {
    return unknownCb(d, currentOrder) || handleUnrecognized(d, isCritical);
  }
 
  template<int autoOrder, typename IsCritical, typename E>
  static bool useDef(const Decoder::Tlv& d, int& currentOrder, const IsCritical& isCritical,
                     const E& def) {
    int defOrder = E::Order::value == 0 ? autoOrder : E::Order::value;
    if (currentOrder > defOrder) {
      return handleUnrecognized(d, isCritical); // out of order
    }
    if (currentOrder == defOrder && !E::Repeatable::value) {
      return false; // cannot repeat
    }
    currentOrder = defOrder;
    return def(d);
  }
 
  template<typename IsCritical>
  static bool handleUnrecognized(const Decoder::Tlv& d, const IsCritical& isCritical) {
    return !isCritical(d.type);
  }
};
class EvDecoder {…};
 
} // namespace ndnph
 
#endif // NDNPH_TLV_EV_DECODER_HPP