kwargs.h

Go to the documentation of this file.

#ifndef KWARGS_H_
#define KWARGS_H_

#include <cstdint>

namespace kw {

template <uint64_t Tag, typename T>
struct Arg {
  T v;
  Arg(T v) : v(v) {}
  constexpr bool IsTagged(uint64_t query){ return query == Tag; }
};

template<uint32_t N>
inline constexpr uint64_t Hash(const char (&string)[N]);

template <typename T>
struct RefWrap {
  T& v;
  RefWrap(T& v) : v(v) {}
};

template <typename T>
struct ConstRefWrap {
  const T& v;
  ConstRefWrap(const T& v) : v(v) {}
};

template <typename T>
RefWrap<T> Ref(T& v){ return RefWrap<T>(v); }

template <typename T>
const ConstRefWrap<T> ConstRef(const T& v) { return ConstRefWrap<T>(v); }

template <uint64_t Tag>
struct Key {
    template <typename T>
    Arg<Tag,T> operator=(T v) { return v; }

  template <typename T>
    Arg<Tag,T&> operator=(RefWrap<T> vw) { return vw.v; }

  template <typename T>
    Arg<Tag,const T&> operator=(ConstRefWrap<T> vw) { return vw.v; }
};

template <uint64_t Tag, typename... Args>
struct ContainsTag {};

template <uint64_t Tag, typename Default, typename... Args>
struct TypeOfTagDefault {};

template <typename... Args>
struct ParamPack;

template <uint64_t Tag, bool exists, typename Default, typename... Args>
struct GetImpl{};

template <uint64_t Tag, typename Default, typename... Args>
inline typename TypeOfTagDefault<Tag,Default,Args...>::Result
    Get(ParamPack<Args...>& pack, Default d) {
  return 
    GetImpl<Tag,ContainsTag<Tag,Args...>::result,Default,Args...>::Get(pack,d);
}

template <uint64_t Tag, typename Default, typename... Args>
inline typename TypeOfTagDefault<Tag,Default,Args...>::Result
    Get(ParamPack<Args...>& pack, const Key<Tag>& key, Default d) {
  return 
    GetImpl<Tag,ContainsTag<Tag,Args...>::result,Default,Args...>::Get(pack,d);
}

inline uint64_t HashString(const std::string& str, int i,
                                     uint64_t hash) {
  return i == str.size() ? hash :
          HashString(str, i + 1, ((hash << 5) ^ (hash >> 27)) ^ str[i]);
}

inline uint64_t HashString(const std::string& str) {
  return HashString(str, 0, str.size());
}

template <typename... Args>
struct ParamPack{

  template<uint64_t Tag>
  constexpr bool Contains(const Key<Tag>& key) {
    return ContainsTag<Tag, Args...>::result;
  }

  template<uint64_t Tag, typename T>
  typename TypeOfTagDefault<Tag, T, Args...>::Result Get(const Key<Tag>& key,
                                                         T default_value) {
    return kw::Get(*this, key, default_value);
  }

  template<typename ReturnType>
  ReturnType GetAs(uint64_t tag, ReturnType default_value) {
    return default_value;
  }

  template<typename ReturnType>
  ReturnType GetAs(const std::string& tag, ReturnType default_value) {
    return GetAs(HashString(tag),default_value);
  }

  bool Contains(uint64_t tag){ return false; }
  bool Contains(const std::string& tag){ return Contains(HashString(tag)); }
};




class Tag {
 public:
  template<uint32_t N>
  constexpr Tag(const char (&string)[N])
      : m_ptr(string),
        m_size(N - 1) {
  }

  constexpr Tag(const char* string, size_t len)
      : m_ptr(string),
        m_size(len) {
  }

  constexpr char operator[](uint32_t i) {
    // if we care about overflow
    // return n < m_size ? m_ptr[i] : throw std::out_of_range("");
    return m_ptr[i];
  }

  constexpr uint32_t size() {
    return m_size;
  }

  constexpr uint64_t Hash(int i, uint64_t hash) {
    return i == size() ? hash :
        Hash(i + 1, ((hash << 5) ^ (hash >> 27)) ^ m_ptr[i]);
  }

  constexpr uint64_t Hash(){
    return Hash(0,size());
  }

 private:
  const char* const m_ptr;
  const uint32_t m_size;
};

template<uint32_t N>
inline constexpr uint64_t Hash(const char (&string)[N]){
  return Tag(string).Hash();
}

}  //< namespace kw


// ----------------------------------------------------------------------------
//   Danger!!! Horrible implementation details below!!!
//   Continue at your own risk!
// ----------------------------------------------------------------------------

#ifndef DOXYGEN_IGNORE

namespace kw {

template <typename T, typename ReturnType>
ReturnType SafeReturn(T query, ReturnType default_value){
  return query;
}

template <typename Head, typename... Tail>
struct ParamPack<Head,Tail...>
  : Head,
    ParamPack<Tail...> {
  ParamPack( Head head, Tail... tail )
    : Head(head),
      ParamPack<Tail...>(tail...) {}

  template <uint64_t Tag>
  constexpr bool Contains(const Key<Tag>& key) const{
    return ContainsTag<Tag,Head,Tail...>::result;
  }

  template<uint64_t Tag, typename T>
    typename TypeOfTagDefault<Tag,T,Head,Tail...>::Result
    Get(const Key<Tag>& key, T default_value) {
      return kw::Get<Tag>(*this, key, default_value);
  }

  template<typename ReturnType>
  ReturnType GetAs(uint64_t tag, ReturnType default_value) {
    return
        Head::IsTagged(tag) ?
            this->Head::v : ParamPack<Tail...>::GetAs(tag, default_value);
  }

  template<typename ReturnType>
  ReturnType GetAs(const std::string& string, ReturnType default_value) {
    return GetAs(HashString(string),default_value);
  }

  bool Contains(uint64_t tag) {
    return Head::IsTagged(tag) ? true : ParamPack<Tail...>::Contains(tag);
  }

  bool Contains(const std::string& tag) {
    return Contains(HashString(tag));
  }
};

template <typename Tail>
struct ParamPack<Tail> : Tail {
  ParamPack( Tail tail ) : Tail(tail) {}

  template <uint64_t Tag>
  constexpr bool Contains(const Key<Tag>& key) const{
    return ContainsTag<Tag,Tail>::result;
  }

  template<uint64_t Tag, typename T>
    typename TypeOfTagDefault<Tag,T,Tail>::Result
    Get(const Key<Tag>& key, T default_value) {
      return kw::Get<Tag>(*this, key, default_value);
  }

  template<typename ReturnType>
  ReturnType GetAs(uint64_t tag, ReturnType default_value) {
    return Tail::IsTagged(tag) ? this->Tail::v : default_value;
  }

  template<typename ReturnType>
  ReturnType GetAs(const std::string& string, ReturnType default_value) {
    return GetAs(HashString(string), default_value);
  }

  bool Contains(uint64_t tag) {
      return Tail::IsTagged(tag) ? true : false;
  }

  bool Contains(const std::string& tag) {
    return Contains(HashString(tag));
  }
};

inline constexpr bool ContainsTagFn(uint64_t tag){
  return false;
}

template <uint64_t Tag, typename T, typename... Rest>
inline constexpr bool ContainsTagFn(uint64_t tag, Arg<Tag,T> first, Rest... rest){
  return (tag==Tag) ? true : ContainsTagFn(tag,rest...);
}

template <uint64_t Tag, typename First, typename... Rest>
struct ContainsTag<Tag,First,Rest...> {
  static const bool result = ContainsTag<Tag, Rest...>::result;
};

template <uint64_t Tag, typename T, typename... Rest>
struct ContainsTag<Tag, Arg<Tag,T>, Rest...> {
  static const bool result = true;
};

template <uint64_t Tag>
struct ContainsTag<Tag> {
  static const bool result = false;
};

template <uint64_t Tag, typename Default, typename Head, typename... Tail>
struct TypeOfTagDefault<Tag, Default, Head, Tail...> {
  typedef typename TypeOfTagDefault<Tag, Default, Tail...>::Result Result;
};

template <uint64_t Tag, typename Default, typename T, typename... Tail>
struct TypeOfTagDefault<Tag, Default, Arg<Tag, T>, Tail...> {
  typedef T Result;
};

template <uint64_t Tag, typename Default>
struct TypeOfTagDefault<Tag,Default> {
  typedef Default Result;
};

template <uint64_t Tag, typename Default, typename... Args>
struct GetImpl<Tag,false,Default,Args...>{
  static inline Default Get(ParamPack<Args...>& pack, Default d) {
    return d;
  }
};

template <uint64_t Tag, typename Default, typename... Args>
struct GetImpl<Tag,true,Default,Args...>{
  static inline typename TypeOfTagDefault<Tag,Default,Args...>::Result Get(
      ParamPack<Args...>& pack, Default d) {
    typedef typename TypeOfTagDefault<Tag,Default,Args...>::Result StorageType;
    return static_cast<Arg<Tag,StorageType>&>(pack).v;
  }
};

}  //< namespace kw

#define TAG(key) kw::Hash(#key)
#define KW(key) kw::Key<kw::Hash(#key)>()

#endif  // DOXYGEN_IGNORE
#endif  // KWARGS_H_