element.h

Go to the documentation of this file.

#pragma once

#include "typeinfo.h"
#include <sstream>
#include <memory>
#include <vector>

namespace bson
{
  const char X00 = '\0'; // null character, useful for encoding in bson
  const int OID_SIZE = 12;
  const int DB_PTR_SIZE = 12;
  
  class Element; //forward declaration for typedefs
  class Document; // forward declaration for friending and typedefs
    
  typedef std::vector<Element> array;
  typedef std::array<unsigned char, OID_SIZE> oid;
  typedef std::pair<std::string, std::string> regex;
  typedef std::pair<std::string, std::array<unsigned char, DB_PTR_SIZE>> dbptr;
  typedef std::pair<std::string, Document> jscode_scope;
  typedef std::pair<unsigned char, std::string> binary;
  
  class Element
  {
    public:
      Element(): m_data(nullptr), m_type(_UNKNOWN) {}
      
      template <typename T>
      Element(const T& data, const TypeInfo type = _UNKNOWN);
      
      Element(const char* data, const TypeInfo type = _UNKNOWN);
      
      Element(const unsigned char* data, const TypeInfo & type) {decode(data, type);}
      
      unsigned decode(const unsigned char* data, const TypeInfo m_type);
      
      void encode(std::ostringstream& oss) const;
      
      TypeInfo get_type() const {return m_type;}
      template <typename T>
      const T& data() const;
      template <typename T>
      void data(T& t) const {t = data<T>();}
      
      static void encode(std::ostringstream& oss, const Element& e) {e.encode(oss);}
      static void decode(const unsigned char* data, const TypeInfo type, Element& e) {e.decode(data, type);}
      
      operator std::string() const;
      
    private:
      friend class Document;
      
      std::shared_ptr<void> m_data;
      TypeInfo m_type;

/* ------------ ALL FUNCTIONS BELOW THIS LINE MUST BE SPECIALIZED FOR TYPES --------- */
      
      template <typename T>
      bool check_convert() const;
      
      template <typename T>
      void type_check() const;
      
      template<typename T>
      unsigned deserialize_bytes(const unsigned char* bytes);
      
      template<typename T>
      void serialize_bson(std::ostringstream& oss) const;
      
      template <typename T>
      std::string _to_std_str() const;
  };

  template <typename T>
  std::string to_string();
  
  template <typename T>
  TypeInfo default_type();
  
}

#include "template_spec/document.hpp"
#include "template_spec/floats.hpp"
#include "template_spec/strings.hpp"
#include "template_spec/ints.hpp"
#include "template_spec/bools.hpp"
#include "template_spec/vectors.hpp"
#include "template_spec/chararrs.hpp"
#include "template_spec/voids.hpp"
#include "template_spec/pairs.hpp"
#include "template_spec/jsscope.hpp"
#include "template_spec/binary.hpp"
#include "element.hpp"