jubatus::core::storage::column_type Class Reference

#include <column_type.hpp>

Collaboration diagram for jubatus::core::storage::column_type:

Public Types
enum	type_name {   int8_type, int16_type, int32_type, int64_type,   uint8_type, uint16_type, uint32_type, uint64_type,   float_type, double_type, bit_vector_type, string_type,   array_type, invalid_type }

Public Member Functions
size_t	bit_vector_length () const
	column_type ()
	column_type (type_name name)
	column_type (type_name name, int length)
bool	is (const type_name &type) const
template<class Buffer >
void	msgpack_pack (msgpack::packer< Buffer > &packer) const
void	msgpack_unpack (msgpack::object o)
column_type &	operator= (const column_type &orig)
size_t	size () const
void	swap (column_type &rhs)
std::string	type_as_string () const

Private Attributes
int	bit_vector_length_
type_name	type_

Friends
bool	operator!= (const column_type &x, const column_type &y)
std::ostream &	operator<< (std::ostream &os, const column_type &type)
bool	operator== (const column_type &x, const column_type &y)

Detailed Description

Definition at line 32 of file column_type.hpp.

Member Enumeration Documentation

enum jubatus::core::storage::column_type::type_name

Enumerator
int8_type
int16_type
int32_type
int64_type
uint8_type
uint16_type
uint32_type
uint64_type
float_type
double_type
bit_vector_type
string_type
array_type
invalid_type

Definition at line 34 of file column_type.hpp.

                 {
    int8_type,
    int16_type,
    int32_type,
    int64_type,
    uint8_type,
    uint16_type,
    uint32_type,
    uint64_type,
    float_type,
    double_type,
    bit_vector_type,
    string_type,
    array_type,  // not implemented yet
    invalid_type
  };

Constructor & Destructor Documentation

jubatus::core::storage::column_type::column_type ( )

inline

Definition at line 50 of file column_type.hpp.

:type_(invalid_type), bit_vector_length_(0) {}

jubatus::core::storage::column_type::column_type ( type_name  name )

inlineexplicit

Definition at line 51 of file column_type.hpp.

References bit_vector_type.

                                       : type_(name), bit_vector_length_(0) {
    if (name == bit_vector_type) {
      throw argument_unmatch_exception(
          "bit_vector_type expects bit_vector's length as second argument");
    }
  }

jubatus::core::storage::column_type::column_type ( type_name  name, int  length  )

inline

Definition at line 57 of file column_type.hpp.

References bit_vector_type.

      : type_(name),
        bit_vector_length_(length) {
    if (name != bit_vector_type) {
      throw argument_unmatch_exception(
          "unneeded second parameter, it is used only for bit_vector_type");
    }
  }

Member Function Documentation

size_t jubatus::core::storage::column_type::bit_vector_length ( ) const

inline

Definition at line 126 of file column_type.hpp.

References bit_vector_length_, bit_vector_type, type_, and type_as_string().

Referenced by jubatus::core::storage::typed_column< bit_vector >::check_bit_vector_(), and msgpack_unpack().

                                   {
    if (type_ != bit_vector_type) {
      throw type_unmatch_exception(
          "bit_vector length expected but type was" + type_as_string());
    }
    return bit_vector_length_;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool jubatus::core::storage::column_type::is ( const type_name &  type ) const

inline

Definition at line 66 of file column_type.hpp.

References type_.

Referenced by jubatus::core::storage::detail::abstract_column::abstract_column(), jubatus::core::storage::detail::abstract_column::msgpack_pack(), and jubatus::core::storage::detail::abstract_column::msgpack_unpack().

                                       {
    return type_ == type;
  }

Here is the caller graph for this function:

template<class Buffer >

void jubatus::core::storage::column_type::msgpack_pack ( msgpack::packer< Buffer > &  packer ) const

inline

Definition at line 163 of file column_type.hpp.

References bit_vector_length_, and type_.

                                                         {
    packer.pack_array(2);
    packer.pack(static_cast<uint8_t>(type_));
    packer.pack(static_cast<uint64_t>(bit_vector_length_));
  }

void jubatus::core::storage::column_type::msgpack_unpack ( msgpack::object  o )

inline

Definition at line 168 of file column_type.hpp.

References bit_vector_length(), bit_vector_length_, and type_.

                                       {
    if (o.type != msgpack::type::ARRAY || o.via.array.size != 2) {
      throw msgpack::type_error();
    }
    uint8_t type;
    o.via.array.ptr[0].convert(&type);
    uint64_t bit_vector_length;
    o.via.array.ptr[1].convert(&bit_vector_length);
    type_ = static_cast<type_name>(type);
    bit_vector_length_ = bit_vector_length;
  }

Here is the call graph for this function:

column_type& jubatus::core::storage::column_type::operator= ( const column_type &  orig )

inline

Definition at line 134 of file column_type.hpp.

References bit_vector_length_, and type_.

                                                  {
    type_ = orig.type_;
    bit_vector_length_ = orig.bit_vector_length_;
    return *this;
  }

size_t jubatus::core::storage::column_type::size ( ) const

inline

Definition at line 99 of file column_type.hpp.

References array_type, bit_vector_length_, bit_vector_type, double_type, float_type, int16_type, int32_type, int64_type, int8_type, invalid_type, jubatus::core::storage::bit_vector_base< uint64_t >::memory_size(), string_type, type_, uint16_type, uint32_type, uint64_type, and uint8_type.

                      {
    switch (type_) {
      case int8_type:
      case uint8_type:
        return 1;
      case int16_type:
      case uint16_type:
        return 2;
      case int32_type:
      case uint32_type:
      case float_type:
        return 4;
      case int64_type:
      case uint64_type:
      case double_type:
      case string_type:
        return 8;
      case bit_vector_type:
        return bit_vector::memory_size(bit_vector_length_);
      case array_type:
      case invalid_type:
      default:
        return 0;
    }
  }

Here is the call graph for this function:

void jubatus::core::storage::column_type::swap ( column_type &  rhs )

inline

Definition at line 140 of file column_type.hpp.

References bit_vector_length_, jubatus::core::clustering::swap(), and type_.

                              {
    using std::swap;
    swap(type_, rhs.type_);
    swap(bit_vector_length_, rhs.bit_vector_length_);
  }

Here is the call graph for this function:

std::string jubatus::core::storage::column_type::type_as_string ( ) const

inline

Definition at line 70 of file column_type.hpp.

References bit_vector_type, double_type, float_type, int16_type, int32_type, int64_type, int8_type, string_type, type_, uint16_type, uint32_type, uint64_type, and uint8_type.

Referenced by bit_vector_length().

                                   {
    if (type_ == int8_type) {
      return "int8";
    } else if (type_ == int16_type) {
      return "int16";
    } else if (type_ == int32_type) {
      return "int32";
    } else if (type_ == int64_type) {
      return "int64";
    } else if (type_ == uint8_type) {
      return "uint8";
    } else if (type_ == uint16_type) {
      return "uint16";
    } else if (type_ == uint32_type) {
      return "uint32";
    } else if (type_ == uint64_type) {
      return "uint64";
    } else if (type_ == float_type) {
      return "float";
    } else if (type_ == double_type) {
      return "double";
    } else if (type_ == bit_vector_type) {
      return "bit_vector";
    } else if (type_ == string_type) {
      return "string";
    }
    throw type_unmatch_exception("in type_as_string(): unknown type");
  }

Here is the caller graph for this function:

Friends And Related Function Documentation

bool operator!= ( const column_type &  x, const column_type &  y  )

friend

Definition at line 158 of file column_type.hpp.

                                                                     {
    return !(x == y);
  }

std::ostream& operator<< ( std::ostream &  os, const column_type &  type  )

friend

Definition at line 146 of file column_type.hpp.

                                                                         {
    os << "{ " << type.type_as_string();
    if (type.type_ == bit_vector_type) {
      os << ": " << type.bit_vector_length_;
    }
    os << " }";
    return os;
  }

bool operator== ( const column_type &  x, const column_type &  y  )

friend

Definition at line 155 of file column_type.hpp.

                                                                     {
    return x.type_ == y.type_ && x.bit_vector_length_ == y.bit_vector_length_;
  }

Member Data Documentation

int jubatus::core::storage::column_type::bit_vector_length_

private

Definition at line 182 of file column_type.hpp.

Referenced by bit_vector_length(), msgpack_pack(), msgpack_unpack(), operator=(), size(), and swap().

type_name jubatus::core::storage::column_type::type_

private

Definition at line 181 of file column_type.hpp.

Referenced by bit_vector_length(), is(), msgpack_pack(), msgpack_unpack(), operator=(), size(), swap(), and type_as_string().

---

The documentation for this class was generated from the following file:

• jubatus/core/storage/column_type.hpp