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/StdInt.h"
#include "madara/utility/Refcounter.h"
#include "madara/logger/GlobalLogger.h"
#include "madara/utility/IntTypes.h"

namespace madara
{

  namespace knowledge
  {
    class ThreadSafeContext;

    namespace tags {
      static struct integers_t { integers_t(){} } integers;
      static struct doubles_t { doubles_t(){} } doubles;
      static struct string_t { string_t(){} } string;
      static struct binary_t { binary_t(){} } binary;

      template<typename T>
      struct shared_t { shared_t(){} };

      template<typename T>
      inline shared_t<T> shared(T) {
        return shared_t<T>{};
      }
    }

    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
      {
        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
      };

      typedef  int64_t     Integer;

    private:
      logger::Logger * logger_ = logger::global_logger.get ();

    public:
      uint64_t clock = 0;

      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_;
      };

      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,
        typename std::enable_if<std::is_integral<T>::value,
        void*>::type = nullptr>
      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 shared_ptr constructor */
      explicit KnowledgeRecord (std::shared_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 shared_ptr constructor */
      explicit KnowledgeRecord (std::shared_ptr<std::vector <double>> value,
        logger::Logger & logger = *logger::global_logger.get ()) noexcept;

      /* String constructor */
      explicit 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 shared_ptr constructor */
      explicit KnowledgeRecord (std::shared_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 shared_ptr constructor */
      explicit KnowledgeRecord (
        std::shared_ptr<std::vector<unsigned char>> value,
        logger::Logger & logger = *logger::global_logger.get ()) noexcept;

      /* copy constructor */
      KnowledgeRecord (const KnowledgeRecord & rhs);

      /* move constructor */
      KnowledgeRecord (KnowledgeRecord && rhs) noexcept;

      /* destructor */
      ~KnowledgeRecord () noexcept;

    public:
      template<typename... Args>
      void emplace_shared_integers(Args&&... args) {
        emplace_shared_vec<Integer, INTEGER_ARRAY,
               &KnowledgeRecord::int_array_> (
                  std::forward<Args>(args)...);
        shared_ = SHARED;
      }

      template<typename... Args>
      void emplace(tags::shared_t<tags::integers_t>, Args&&... args) {
        emplace_shared_integers(std::forward<Args>(args)...);
      }

      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_shared_doubles(Args&&... args) {
        emplace_shared_vec<double, DOUBLE_ARRAY,
               &KnowledgeRecord::double_array_> (
                  std::forward<Args>(args)...);
        shared_ = SHARED;
      }

      template<typename... Args>
      void emplace(tags::shared_t<tags::doubles_t>, Args&&... args) {
        emplace_shared_doubles(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_shared_string(Args&&... args) {
        emplace_shared_val<std::string, STRING,
               &KnowledgeRecord::str_value_> (
                  std::forward<Args>(args)...);
        shared_ = SHARED;
      }

      template<typename... Args>
      void emplace(tags::shared_t<tags::string_t>, Args&&... args) {
        emplace_shared_string(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_shared_file(Args&&... args) {
        emplace_shared_vec<unsigned char, UNKNOWN_FILE_TYPE,
               &KnowledgeRecord::file_value_> (
                std::forward<Args>(args)...);
        shared_ = SHARED;
      }

      template<typename... Args>
      void emplace(tags::shared_t<tags::binary_t>, Args&&... args) {
        emplace_shared_binary(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>
      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::shared_t<tags::integers_t>, Args&&... args)
        : int_array_ {std::forward<Args>(args)...},
          type_ (INTEGER_ARRAY), shared_ (SHARED) {}

      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::shared_t<tags::doubles_t>, Args&&... args)
        : double_array_ {std::forward<Args>(args)...},
          type_ (DOUBLE_ARRAY), shared_ (SHARED) {}

      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::shared_t<tags::string_t>, Args&&... args)
        : str_value_ {std::forward<Args>(args)...},
          type_ (STRING), shared_ (SHARED) {}

      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) {}

      template<typename... Args>
      KnowledgeRecord(tags::shared_t<tags::binary_t>, Args&&... args)
        : file_value_ {std::forward<Args>(args)...},
          type_ (UNKNOWN_FILE_TYPE), shared_ (SHARED) {}

      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,
        typename std::enable_if<std::is_integral<T>::value,
        void*>::type = nullptr>
      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;

      std::shared_ptr<std::string> share_string() const;

      std::shared_ptr<std::string> take_string();

      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<std::vector<Integer>> share_integers() const;

      std::shared_ptr<std::vector<Integer>> take_integers();

      std::vector <double> to_doubles (void) const;

      std::shared_ptr<std::vector<double>> share_doubles() const;

      std::shared_ptr<std::vector<double>> take_doubles();

      std::shared_ptr<std::vector<unsigned char>> share_binary() const;

      std::shared_ptr<std::vector<unsigned char>> take_binary();

      unsigned char * to_unmanaged_buffer (size_t & size) const;

      void set_value (const KnowledgeRecord &new_value);

      void set_value (KnowledgeRecord &&new_value);

      template<typename T,
        typename std::enable_if<std::is_integral<T>::value,
        void*>::type = nullptr>
      void set_value (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::shared_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::shared_ptr<std::string> new_value);

      template<typename T,
        typename std::enable_if<std::is_floating_point<T>::value,
        void*>::type = nullptr>
      void set_value (T 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::shared_ptr<std::vector <double>> new_value);

      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;
      }

      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::shared_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::shared_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::shared_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::shared_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;

      int32_t type (void) const;

      bool set_type (int32_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;

#if 0

      template<typename T,
        typename std::enable_if<std::is_integral<T>::value,
        void*>::type = nullptr>
      bool operator== (T value) const;

      template<typename T,
        typename std::enable_if<std::is_floating_point<T>::value,
        void*>::type = nullptr>
      bool operator== (T value) const;

      bool operator== (const std::string & value) const;

      bool operator== (const char * value) const;
#endif

      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;

      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;

    private:
      template<typename T>
      using MemberType = std::shared_ptr<T> KnowledgeRecord::*;

      template<typename T, uint32_t Type, MemberType<T> Member, typename... Args>
      std::shared_ptr<T> &emplace_shared_val(Args&&... args) {
        clear_union();
        type_ = Type;
        return *new(&(this->*Member)) std::shared_ptr<T>(
              std::forward<Args>(args)...);
      }

      template<typename T, uint32_t Type, MemberType<T> Member, typename... Args>
      std::shared_ptr<T> &emplace_val(Args&&... args) {
        return emplace_shared_val<T, Type, Member> (std::move(
            std::make_shared<T> (
              std::forward<Args>(args)...)));
      }

      template<typename T, uint32_t Type, MemberType<std::vector<T>> Member,
               typename... Args>
      std::shared_ptr<std::vector<T>> &emplace_shared_vec(Args&&... args) {
        return emplace_shared_val<std::vector<T>, Type, Member> (
              std::forward<Args>(args)...);
      }

      template<typename T, uint32_t Type, MemberType<std::vector<T>> Member,
               typename... Args>
      std::shared_ptr<std::vector<T>> &emplace_vec(Args&&... args) {
        return emplace_val<std::vector<T>, Type, Member> (
              std::forward<Args>(args)...);
      }
    };

    typedef ::std::map < std::string, KnowledgeRecord>   KnowledgeMap;
    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;

    uint32_t max_quality (const KnowledgeRecords & records);

    uint32_t max_quality (const KnowledgeMap & records);
  }
}

//inline std::ostream & operator<< (std::ostream & stream,
  //const madara::knowledge::KnowledgeRecord & rhs);

#include "KnowledgeRecord.inl"


#endif  // _MADARA_KNOWLEDGE_RECORD_H_

#include "KnowledgeCast.h"