KnowledgeRecord.h

Go to the documentation of this file.

 
 
#ifndef _MADARA_KNOWLEDGE_RECORD_H_
#define _MADARA_KNOWLEDGE_RECORD_H_
 
#include <string>
#include <vector>
#include <map>
#include <memory>
#include <type_traits>
#include "madara/MadaraExport.h"
#include "madara/utility/StlHelper.h"
#include "madara/utility/StdInt.h"
#include "madara/utility/Refcounter.h"
#include "madara/logger/GlobalLogger.h"
#include "madara/utility/IntTypes.h"
#include "madara/utility/CircularBuffer.h"
#include "madara/exceptions/IndexException.h"
 
namespace madara
{
namespace knowledge
{
class ThreadSafeContext;
 
namespace tags
{
using utility::type;
 
using integer_t = type<int64_t>;
constexpr integer_t integer;
constexpr integer_t int_;
using double_t = type<double>;
constexpr double_t double_;
constexpr double_t dbl;
using integers_t = type<std::vector<int64_t>>;
constexpr integers_t integers;
constexpr integers_t ints;
using doubles_t = type<std::vector<double>>;
constexpr doubles_t doubles;
constexpr doubles_t dbls;
using string_t = type<std::string>;
constexpr string_t string;
constexpr string_t str;
using binary_t = type<std::vector<unsigned char>>;
constexpr binary_t binary;
 
template<typename T>
struct any
{
  any() {}
};
 
template<typename T>
struct shared_t
{
  shared_t() {}
};
 
template<typename T>
inline shared_t<T> shared(T)
{
  return shared_t<T>{};
}
}  // namespace tags
 
class MADARA_EXPORT KnowledgeRecord
{
public:
  // allow ThreadSafeContext to modify private members
  friend class ThreadSafeContext;
 
  enum
  {
    UNCREATED = 0,
    MODIFIED = 1
  };
 
  enum
  {
    OWNED = 0,
    SHARED = 1
  };
 
  enum ValueTypes : uint32_t
  {
    EMPTY = 0,
    INTEGER = 1,
    STRING = 2,
    DOUBLE = 4,
    FLOAT = 4,
    UNKNOWN_FILE_TYPE = 8,
    XML = 16,
    TEXT_FILE = 32,
    INTEGER_ARRAY = 64,
    DOUBLE_ARRAY = 128,
    IMAGE_JPEG = 256,
    ALL_ARRAYS = INTEGER_ARRAY | DOUBLE_ARRAY,
    ALL_INTEGERS = INTEGER | INTEGER_ARRAY,
    ALL_DOUBLES = DOUBLE | DOUBLE_ARRAY,
    ALL_PRIMITIVE_TYPES =
        INTEGER | STRING | DOUBLE | INTEGER_ARRAY | DOUBLE_ARRAY,
    ALL_FILE_TYPES = UNKNOWN_FILE_TYPE | XML | TEXT_FILE | IMAGE_JPEG,
    ALL_IMAGES = IMAGE_JPEG,
    ALL_TEXT_FORMATS = XML | TEXT_FILE | STRING,
    ALL_TYPES = ALL_PRIMITIVE_TYPES | ALL_FILE_TYPES,
    ALL_CLEARABLES = ALL_ARRAYS | ALL_TEXT_FORMATS | ALL_FILE_TYPES,
    BUFFER = (1UL << 31),
  };
 
  typedef int64_t Integer;
 
  using CircBuf = utility::CircularBuffer<KnowledgeRecord>;
 
private:
  logger::Logger* logger_ = logger::global_logger.get();
 
public:
  uint64_t clock = 0;
 
private:
  uint64_t toi_ = 0;
 
public:
  uint64_t toi() const
  {
    return toi_;
  }
  void set_toi(uint64_t new_toi)
  {
    toi_ = new_toi;
    if (has_history())
    {
      buf_->back().set_toi(new_toi);
    }
  }
 
  uint32_t quality = 0;
 
  uint32_t write_quality = 0;
 
private:
  union {
    Integer int_value_ = 0;
    double double_value_;
 
    std::shared_ptr<std::vector<Integer>> int_array_;
    std::shared_ptr<std::vector<double>> double_array_;
    std::shared_ptr<std::string> str_value_;
    std::shared_ptr<std::vector<unsigned char>> file_value_;
 
    std::shared_ptr<CircBuf> buf_;
  };
 
  uint32_t type_ = EMPTY;
 
  mutable bool shared_ = OWNED;
 
public:
  /* default constructor */
  KnowledgeRecord() noexcept : KnowledgeRecord(*logger::global_logger.get()) {}
 
  explicit KnowledgeRecord(logger::Logger& logger) noexcept;
 
  /* Integer constructor */
  template<typename T,
      utility::enable_if_<utility::is_int_numeric<T>(), int> = 0>
  explicit KnowledgeRecord(
      T value, logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  /* Floating point constructor */
  template<typename T, typename std::enable_if<std::is_floating_point<T>::value,
                           void*>::type = nullptr>
  explicit KnowledgeRecord(
      T value, logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  /* Integer array constructor */
  explicit KnowledgeRecord(const std::vector<Integer>& value,
      logger::Logger& logger = *logger::global_logger.get());
 
  /* Integer array move constructor */
  explicit KnowledgeRecord(std::vector<Integer>&& value,
      logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  /* Integer array unique_ptr constructor */
  explicit KnowledgeRecord(std::unique_ptr<std::vector<Integer>> value,
      logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  /* Double array constructor */
  explicit KnowledgeRecord(const std::vector<double>& value,
      logger::Logger& logger = *logger::global_logger.get());
 
  /* Double array move constructor */
  explicit KnowledgeRecord(std::vector<double>&& value,
      logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  /* Double array unique_ptr constructor */
  explicit KnowledgeRecord(std::unique_ptr<std::vector<double>> value,
      logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  /* String constructor */
  KnowledgeRecord(const std::string& value,
      logger::Logger& logger = *logger::global_logger.get());
 
  /* String move constructor */
  explicit KnowledgeRecord(std::string&& value,
      logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  /* Double array unique_ptr constructor */
  explicit KnowledgeRecord(std::unique_ptr<std::string> value,
      logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  /* Char pointer constructor for g++ */
  explicit KnowledgeRecord(
      const char* value, logger::Logger& logger = *logger::global_logger.get());
 
  /* Binary file unique_ptr constructor */
  explicit KnowledgeRecord(std::unique_ptr<std::vector<unsigned char>> value,
      logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  explicit KnowledgeRecord(const CircBuf& buffer,
      logger::Logger& logger = *logger::global_logger.get());
 
  explicit KnowledgeRecord(CircBuf&& buffer,
      logger::Logger& logger = *logger::global_logger.get()) noexcept;
 
  KnowledgeRecord(const KnowledgeRecord& rhs);
 
  KnowledgeRecord(KnowledgeRecord&& rhs) noexcept;
 
  /* destructor */
  ~KnowledgeRecord() noexcept;
 
public:
  template<typename... Args>
  void emplace_integers(Args&&... args)
  {
    emplace_vec<Integer, INTEGER_ARRAY, &KnowledgeRecord::int_array_>(
        std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void emplace(tags::integers_t, Args&&... args)
  {
    emplace_integers(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void emplace_doubles(Args&&... args)
  {
    emplace_vec<double, DOUBLE_ARRAY, &KnowledgeRecord::double_array_>(
        std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void emplace(tags::doubles_t, Args&&... args)
  {
    emplace_doubles(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void emplace_string(Args&&... args)
  {
    emplace_val<std::string, STRING, &KnowledgeRecord::str_value_>(
        std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void emplace(tags::string_t, Args&&... args)
  {
    emplace_string(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void emplace_file(Args&&... args)
  {
    emplace_vec<unsigned char, UNKNOWN_FILE_TYPE,
        &KnowledgeRecord::file_value_>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void emplace(tags::binary_t, Args&&... args)
  {
    emplace_binary(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void overwrite_circular_buffer(Args&&... args)
  {
    emplace_val<CircBuf, BUFFER, &KnowledgeRecord::buf_, true>(
        std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  KnowledgeRecord(tags::integers_t, Args&&... args)
    : int_array_(
          std::make_shared<std::vector<Integer>>(std::forward<Args>(args)...)),
      type_(INTEGER_ARRAY)
  {
  }
 
  template<typename... Args>
  KnowledgeRecord(tags::doubles_t, Args&&... args)
    : double_array_(
          std::make_shared<std::vector<double>>(std::forward<Args>(args)...)),
      type_(DOUBLE_ARRAY)
  {
  }
 
  template<typename... Args>
  KnowledgeRecord(tags::string_t, Args&&... args)
    : str_value_(std::make_shared<std::string>(std::forward<Args>(args)...)),
      type_(STRING)
  {
  }
 
  template<typename... Args>
  KnowledgeRecord(tags::binary_t, Args&&... args)
    : file_value_(std::make_shared<std::vector<unsigned char>>(
          std::forward<Args>(args)...)),
      type_(UNKNOWN_FILE_TYPE)
  {
  }
 
  bool exists(void) const;
 
  KnowledgeRecord retrieve_index(size_t index) const;
 
  KnowledgeRecord dec_index(size_t index);
 
  KnowledgeRecord inc_index(size_t index);
 
  template<typename T,
      utility::enable_if_<utility::is_int_numeric<T>(), int> = 0>
  void set_index(size_t index, T value);
 
  template<typename T, typename std::enable_if<std::is_floating_point<T>::value,
                           void*>::type = nullptr>
  void set_index(size_t index, T value);
 
  std::string to_string(const std::string& delimiter = ", ") const;
 
  size_t to_managed_buffer(char* buffer, size_t buf_size) const;
  
  size_t to_managed_string(char* buffer, size_t buf_size) const;
 
  std::shared_ptr<const std::string> share_string() const;
 
  ssize_t to_file(const std::string& filename) const;
 
  void unshare(void);
 
  KnowledgeRecord* clone(void) const;
 
  Integer to_integer(void) const;
 
  double to_double(void) const;
 
  std::vector<Integer> to_integers(void) const;
 
  std::shared_ptr<const std::vector<Integer>> share_integers() const;
 
  std::vector<double> to_doubles(void) const;
 
  std::shared_ptr<const std::vector<double>> share_doubles() const;
 
  std::shared_ptr<const std::vector<unsigned char>> share_binary() const;
 
  unsigned char* to_unmanaged_buffer(size_t& size) const;
 
  void set_value(const KnowledgeRecord& new_value);
 
  void set_value(KnowledgeRecord&& new_value);
 
  void set_full(const KnowledgeRecord& new_value);
 
  void set_full(KnowledgeRecord&& new_value);
 
  void set_value(Integer new_value);
 
  void set_value(int new_value);
 
  void set_value(size_t new_value);
 
  void set_value(const Integer* new_value, uint32_t size);
 
  void set_value(std::vector<Integer>&& new_value);
 
  void set_value(const std::vector<Integer>& new_value);
 
  void set_value(std::unique_ptr<std::vector<Integer>> new_value);
 
  void set_value(const char* new_value, uint32_t size);
 
  void set_value(std::string&& new_value);
 
  void set_value(const std::string& new_value);
 
  void set_value(std::unique_ptr<std::string> new_value);
 
  void set_value(double new_value);
 
  void set_value(float new_value);
 
  void set_value(const double* new_value, uint32_t size);
 
  void set_value(std::vector<double>&& new_value);
 
  void set_value(const std::vector<double>& new_value);
 
  void set_value(std::unique_ptr<std::vector<double>> new_value);
 
  void set_xml(const char* new_value, size_t size);
 
  void set_xml(std::string&& new_value);
 
  void set_xml(const std::string& new_value);
 
  void set_xml(std::unique_ptr<std::string> new_value);
 
  void set_text(const char* new_value, size_t size);
 
  void set_text(std::string&& new_value);
 
  void set_text(const std::string& new_value);
 
  void set_text(std::unique_ptr<std::string> new_value);
 
  static void set_precision(int new_precision);
 
  static void set_scientific(void);
 
  static void set_fixed(void);
 
  static int get_precision(void);
 
  void set_jpeg(const unsigned char* new_value, size_t size);
 
  void set_jpeg(std::vector<unsigned char>&& new_value);
 
  void set_jpeg(const std::vector<unsigned char>& new_value);
 
  void set_jpeg(std::unique_ptr<std::vector<unsigned char>> new_value);
 
  void set_file(const unsigned char* new_value, size_t size);
 
  void set_file(std::vector<unsigned char>&& new_value);
 
  void set_file(const std::vector<unsigned char>& new_value);
 
  void set_file(std::unique_ptr<std::vector<unsigned char>> new_value);
 
  void deep_copy(const KnowledgeRecord& source);
 
  KnowledgeRecord deep_copy() const;
 
  int status(void) const;
 
  void set_modified(void);
 
  void resize(size_t new_size);
 
  int read_file(const std::string& filename, uint32_t read_as_type = 0);
 
  void reset_value(void) noexcept;
 
private:
  void clear_union(void) noexcept;
 
public:
  void clear_value(void) noexcept;
 
  uint32_t size(void) const;
 
  uint32_t type(void) const;
 
  bool set_type(uint32_t type);
 
  bool is_ref_counted(void) const;
 
  static bool is_ref_counted(uint32_t type);
 
  bool is_string_type(void) const;
 
  static bool is_string_type(uint32_t type);
 
  bool is_double_type(void) const;
 
  static bool is_double_type(uint32_t type);
 
  bool is_integer_type(void) const;
 
  static bool is_integer_type(uint32_t type);
 
  bool is_array_type(void) const;
 
  static bool is_array_type(uint32_t type);
 
  KnowledgeRecord fragment(unsigned int first, unsigned int last);
 
  bool is_image_type(void) const;
 
  static bool is_image_type(uint32_t type);
 
  bool is_file_type(void) const;
 
  static bool is_file_type(uint32_t type);
 
  bool is_binary_file_type(void) const;
 
  static bool is_binary_file_type(uint32_t type);
 
  bool operator<(const KnowledgeRecord& rhs) const;
 
  bool operator<=(const KnowledgeRecord& rhs) const;
 
  bool operator==(const KnowledgeRecord& rhs) const;
 
  bool operator!=(const KnowledgeRecord& rhs) const;
 
  bool operator>(const KnowledgeRecord& rhs) const;
 
  bool operator>=(const KnowledgeRecord& rhs) const;
 
  bool operator!(void) const;
 
  KnowledgeRecord operator-(void) const;
 
  KnowledgeRecord& operator=(const KnowledgeRecord& rhs);
 
  KnowledgeRecord& operator=(KnowledgeRecord&& rhs) noexcept;
 
  template<typename T>
  auto operator=(T&& t) ->
      typename std::enable_if<!std::is_convertible<T, KnowledgeRecord>::value,
          decltype(this->set_value(std::forward<T>(t)), *this)>::type
  {
    this->set_value(std::forward<T>(t));
    return *this;
  }
 
  KnowledgeRecord& operator+=(const KnowledgeRecord& rhs);
 
  KnowledgeRecord& operator-=(const KnowledgeRecord& rhs);
 
  KnowledgeRecord& operator*=(const KnowledgeRecord& rhs);
 
  KnowledgeRecord& operator/=(const KnowledgeRecord& rhs);
 
  KnowledgeRecord& operator%=(const KnowledgeRecord& rhs);
 
  KnowledgeRecord operator*(const KnowledgeRecord& rhs) const;
 
  KnowledgeRecord operator/(const KnowledgeRecord& rhs) const;
 
  KnowledgeRecord operator%(const KnowledgeRecord& rhs) const;
 
  KnowledgeRecord operator+(const KnowledgeRecord& rhs) const;
 
  KnowledgeRecord operator-(const KnowledgeRecord& rhs) const;
 
  explicit operator bool(void) const;
 
  KnowledgeRecord& operator++(void);
 
  KnowledgeRecord& operator--(void);
 
  const char* read(const char* buffer, int64_t& buffer_remaining);
 
  const char* read(
      const char* buffer, std::string& key, int64_t& buffer_remaining);
 
  const char* read(
      const char* buffer, uint32_t& key_id, int64_t& buffer_remaining);
 
  char* write(char* buffer, int64_t& buffer_remaining) const;
 
  char* write(
      char* buffer, const std::string& key, int64_t& buffer_remaining) const;
 
  char* write(char* buffer, uint32_t key_id, int64_t& buffer_remaining) const;
 
  int apply(madara::knowledge::ThreadSafeContext& context,
      const std::string& key, unsigned int quality, uint64_t clock,
      bool perform_lock);
 
  bool is_true(void) const;
 
  bool is_false(void) const;
 
  inline bool is_valid(void) const
  {
    return status() != UNCREATED;
  }
 
  int64_t get_encoded_size(const std::string& key) const;
 
  int64_t get_encoded_size(void) const;
 
  bool has_history() const
  {
    return type_ == BUFFER;
  }
 
  size_t get_history_size() const
  {
    if (type_ == BUFFER)
    {
      return buf_->size();
    }
 
    if (exists())
    {
      return 1;
    }
 
    return 0;
  }
 
  size_t get_history_capacity() const
  {
    if (type_ == BUFFER)
    {
      return buf_->capacity();
    }
    else
    {
      return 0;
    }
  }
 
  void set_history_capacity(size_t size)
  {
    if (type_ == BUFFER)
    {
      if (size == 0)
      {
        if (!buf_->empty())
        {
          *this = std::move(buf_->back());
        }
        else
        {
          reset_value();
        }
      }
      else
      {
        buf_->reserve(size);
      }
    }
    else if (size > 0)
    {
      KnowledgeRecord tmp = *this;
 
      new (&buf_) std::shared_ptr<CircBuf>(std::make_shared<CircBuf>(size));
      type_ = BUFFER;
 
      if (tmp.exists())
      {
        buf_->push_back(std::move(tmp));
      }
    }
  }
 
  void clear_history()
  {
    set_history_capacity(0);
  }
 
private:
  size_t absolute_index(ssize_t index) const
  {
    if (type_ != BUFFER)
    {
      return 0;
    }
    if (index >= 0)
    {
      return buf_->front_index() + index;
    }
    return buf_->back_index() + (index + 1);
  }
 
public:
  template<typename Func>
  size_t for_history_range(Func&& func, size_t index, size_t count) const
  {
    if (type_ != BUFFER)
    {
      func(*this);
      return 1;
    }
    size_t front = buf_->front_index();
    if (index < front)
    {
      size_t diff = front - index;
      if (count > diff)
      {
        count -= diff;
      }
      else
      {
        count = 0;
      }
      index = front;
    }
    if (count > buf_->size())
    {
      count = buf_->size();
    }
    for (size_t i = index, end = index + count; i < end; ++i)
    {
      func((*buf_)[i]);
    }
    return count;
  }
 
  template<typename OutputIterator>
  size_t get_history_range(
      OutputIterator out, size_t index, size_t count) const;
 
  template<typename OutputIterator>
  size_t get_oldest(OutputIterator out, size_t count) const
  {
    return get_history(out, 0, count);
  }
 
  template<typename OutputIterator>
  auto get_oldest(OutputIterator out) const -> decltype(*out, size_t{})
  {
    return get_oldest(out, 1);
  }
 
  template<typename OutputIterator>
  size_t get_newest(OutputIterator out, size_t count) const
  {
    return get_history(out, -(ssize_t)count, count);
  }
 
  template<typename OutputIterator>
  auto get_newest(OutputIterator out) const -> decltype(*out, size_t{})
  {
    return get_newest(out, 1);
  }
 
  KnowledgeRecord get_oldest() const
  {
    KnowledgeRecord ret;
    get_oldest(&ret, 1);
    return ret;
  }
 
  KnowledgeRecord get_newest() const
  {
    KnowledgeRecord ret;
    get_newest(&ret, 1);
    return ret;
  }
 
private:
  KnowledgeRecord& ref_newest()
  {
    return buf_->back();
  }
 
  const KnowledgeRecord& ref_newest() const
  {
    return buf_->back();
  }
 
public:
  std::vector<KnowledgeRecord> get_oldest(size_t count) const
  {
    std::vector<KnowledgeRecord> ret;
    get_oldest(std::back_inserter(ret), count);
    return ret;
  }
 
  template<typename T>
  std::vector<T> get_oldest(size_t count) const
  {
    std::vector<T> ret;
    get_oldest(std::back_inserter(ret), count);
    return ret;
  }
 
  std::vector<KnowledgeRecord> get_newest(size_t count) const
  {
    std::vector<KnowledgeRecord> ret;
    get_newest(std::back_inserter(ret), count);
    return ret;
  }
 
  template<typename T>
  std::vector<T> get_newest(size_t count) const
  {
    std::vector<T> ret;
    get_newest(std::back_inserter(ret), count);
    return ret;
  }
 
  std::vector<KnowledgeRecord> get_history() const
  {
    std::vector<KnowledgeRecord> ret;
    get_history(std::back_inserter(ret));
    return ret;
  }
 
  template<typename OutputIterator>
  size_t get_history(OutputIterator out, ssize_t index, size_t count) const
  {
    return get_history_range(out, absolute_index(index), count);
  }
 
  template<typename OutputIterator>
  auto get_history(OutputIterator out) const -> decltype(*out, size_t{})
  {
    return get_history_range(out, 0, std::numeric_limits<size_t>::max());
  }
 
  template<typename T>
  std::vector<T> get_history() const
  {
    std::vector<T> ret;
    get_history(std::back_inserter(ret));
    return ret;
  }
 
  std::vector<KnowledgeRecord> get_history(size_t index, size_t count) const
  {
    std::vector<KnowledgeRecord> ret;
    get_history(std::back_inserter(ret), index, count);
    return ret;
  }
 
  KnowledgeRecord get_history(size_t index) const
  {
    KnowledgeRecord ret;
    get_history(&ret, index, 1);
    return ret;
  }
 
  size_t get_history_newest_index() const
  {
    if (!has_history())
    {
      throw exceptions::IndexException(
          "KnowledgeRecord::get_history_newest_index: "
          "record has zero capacity");
    }
    return buf_->back_index();
  }
 
  size_t get_history_oldest_index() const
  {
    if (!has_history())
    {
      throw exceptions::IndexException(
          "KnowledgeRecord::get_history_oldest_index: "
          "record has zero capacity");
    }
    return buf_->front_index();
  }
 
  std::shared_ptr<CircBuf> share_circular_buffer() const;
 
  void copy_metadata(const KnowledgeRecord& new_value);
 
  void overwrite(const KnowledgeRecord& new_value);
 
  void overwrite(KnowledgeRecord&& new_value);
 
private:
  template<typename... Args>
  KnowledgeRecord& emplace_hist(Args&&... args)
  {
    unshare();
    return buf_->emplace_back(std::forward<Args>(args)...);
  }
 
  template<typename T>
  using MemberType = std::shared_ptr<T> KnowledgeRecord::*;
 
  template<typename T, uint32_t Type, MemberType<T> Member,
      bool Overwrite = false, typename... Args>
  std::shared_ptr<const T> emplace_shared_val(Args&&... args)
  {
    if (has_history() && !Overwrite)
    {
      KnowledgeRecord tmp;
      tmp.copy_metadata(*this);
      auto ret =
          tmp.emplace_shared_val<T, Type, Member>(std::forward<Args>(args)...);
      emplace_hist(std::move(tmp));
      return ret;
    }
    clear_union();
    type_ = Type;
    return *new (&(this->*Member))
        std::shared_ptr<const T>(std::forward<Args>(args)...);
  }
 
  template<typename T, uint32_t Type, MemberType<T> Member,
      bool Overwrite = false, typename... Args>
  std::shared_ptr<const T> emplace_val(Args&&... args)
  {
    return emplace_shared_val<T, Type, Member, Overwrite>(
        std::move(std::make_shared<const T>(std::forward<Args>(args)...)));
  }
 
  template<typename T, uint32_t Type, MemberType<std::vector<T>> Member,
      bool Overwrite = false, typename... Args>
  std::shared_ptr<const std::vector<T>> emplace_shared_vec(Args&&... args)
  {
    return emplace_shared_val<std::vector<T>, Type, Member, Overwrite>(
        std::forward<Args>(args)...);
  }
 
  template<typename T, uint32_t Type, MemberType<std::vector<T>> Member,
      bool Overwrite = false, typename... Args>
  std::shared_ptr<const std::vector<T>> emplace_vec(Args&&... args)
  {
    return emplace_val<std::vector<T>, Type, Member, Overwrite>(
        std::forward<Args>(args)...);
  }
};
 
typedef ::std::map<std::string, KnowledgeRecord> KnowledgeMap;
typedef ::std::multimap<std::string, KnowledgeRecord> KnowledgeMultiMap;
typedef ::std::vector<KnowledgeRecord> KnowledgeVector;
typedef ::std::vector<std::string> KnowledgeRules;
typedef ::std::vector<std::string> StringVector;
typedef ::std::map<std::string, KnowledgeRecord*> KnowledgeRecords;
 
typedef std::string KnowledgeKey;
typedef KnowledgeRecord KnowledgeValue;
 
MADARA_EXPORT void safe_clear(KnowledgeMap& map);
 
uint32_t max_quality(const KnowledgeRecords& records);
 
uint32_t max_quality(const KnowledgeMap& records);
 
}  // namespace knowledge
}  // namespace madara
 
// inline std::ostream & operator<< (std::ostream & stream,
// const madara::knowledge::KnowledgeRecord & rhs);
 
#include "KnowledgeRecord.inl"
 
#endif  // _MADARA_KNOWLEDGE_RECORD_H_
 
#include "KnowledgeCast.h"