jubatus::core::storage::detail::abstract_column Class Reference

#include <abstract_column.hpp>

Collaboration diagram for jubatus::core::storage::detail::abstract_column:

Public Member Functions
	abstract_column ()
	abstract_column (const column_type &type)
void	clear ()
void	dump (std::ostream &os, uint64_t target) const
abstract_column_base *	get ()
const abstract_column_base *	get () const
template<typename T >
bool	insert (uint64_t index, const T &value)
template<class Buffer >
void	msgpack_pack (msgpack::packer< Buffer > &packer) const
void	msgpack_unpack (msgpack::object o)
void	pack_with_index (uint64_t index, framework::packer &pk) const
template<typename T >
void	push_back (const T &value)
bool	remove (uint64_t index)
void	swap (abstract_column &x)
column_type	type () const
template<typename T >
bool	update (uint64_t index, const T &value)

Private Attributes
jubatus::util::lang::shared_ptr< abstract_column_base >	base_

Friends
void	swap (abstract_column &l, abstract_column &r)

Detailed Description

Definition at line 388 of file abstract_column.hpp.

Constructor & Destructor Documentation

jubatus::core::storage::detail::abstract_column::abstract_column ( )

inline

Definition at line 390 of file abstract_column.hpp.

Referenced by msgpack_unpack().

                    {
  }

Here is the caller graph for this function:

jubatus::core::storage::detail::abstract_column::abstract_column ( const column_type &  type )

inlineexplicit

Definition at line 393 of file abstract_column.hpp.

References base_, jubatus::core::storage::column_type::bit_vector_type, jubatus::core::storage::column_type::double_type, jubatus::core::storage::column_type::float_type, jubatus::core::storage::column_type::int16_type, jubatus::core::storage::column_type::int32_type, jubatus::core::storage::column_type::int64_type, jubatus::core::storage::column_type::int8_type, jubatus::core::storage::column_type::is(), JUBATUS_ASSERT_UNREACHABLE, jubatus::core::storage::column_type::string_type, jubatus::core::storage::column_type::uint16_type, jubatus::core::storage::column_type::uint32_type, jubatus::core::storage::column_type::uint64_type, and jubatus::core::storage::column_type::uint8_type.

                                                    {
    if (type.is(column_type::uint8_type)) {
      base_.reset(new uint8_column(type));
    } else if (type.is(column_type::uint16_type)) {
      base_.reset(new uint16_column(type));
    } else if (type.is(column_type::uint32_type)) {
      base_.reset(new uint32_column(type));
    } else if (type.is(column_type::uint64_type)) {
      base_.reset(new uint64_column(type));
    } else if (type.is(column_type::int8_type)) {
      base_.reset(new int8_column(type));
    } else if (type.is(column_type::int16_type)) {
      base_.reset(new int16_column(type));
    } else if (type.is(column_type::int32_type)) {
      base_.reset(new int32_column(type));
    } else if (type.is(column_type::int64_type)) {
      base_.reset(new int64_column(type));
    } else if (type.is(column_type::float_type)) {
      base_.reset(new float_column(type));
    } else if (type.is(column_type::double_type)) {
      base_.reset(new double_column(type));
    } else if (type.is(column_type::string_type)) {
      base_.reset(new string_column(type));
    } else if (type.is(column_type::bit_vector_type)) {
      base_.reset(new bit_vector_column(type));
    } else {
      JUBATUS_ASSERT_UNREACHABLE();
    }
  }

Here is the call graph for this function:

Member Function Documentation

void jubatus::core::storage::detail::abstract_column::clear ( )

inline

Definition at line 448 of file abstract_column.hpp.

References base_, and JUBATUS_ASSERT.

               {
    JUBATUS_ASSERT(base_ != NULL);
    base_->clear();
  }

void jubatus::core::storage::detail::abstract_column::dump ( std::ostream &  os, uint64_t  target  ) const

inline

Definition at line 464 of file abstract_column.hpp.

References base_, and JUBATUS_ASSERT.

                                                   {
    JUBATUS_ASSERT(base_ != NULL);
    base_->dump(os, target);
  }

abstract_column_base* jubatus::core::storage::detail::abstract_column::get ( )

inline

Definition at line 457 of file abstract_column.hpp.

References base_.

                              {
    return base_.get();
  }

const abstract_column_base* jubatus::core::storage::detail::abstract_column::get ( ) const

inline

Definition at line 460 of file abstract_column.hpp.

References base_.

                                          {
    return base_.get();
  }

template<typename T >

bool jubatus::core::storage::detail::abstract_column::insert ( uint64_t  index, const T &  value  )

inline

Definition at line 435 of file abstract_column.hpp.

References base_, and JUBATUS_ASSERT.

                                              {
    JUBATUS_ASSERT(base_ != NULL);
    return base_->insert(index, value);
  }

template<class Buffer >

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

inline

Definition at line 477 of file abstract_column.hpp.

References base_, jubatus::core::storage::column_type::bit_vector_type, jubatus::core::storage::column_type::double_type, jubatus::core::storage::column_type::float_type, jubatus::core::storage::column_type::int16_type, jubatus::core::storage::column_type::int32_type, jubatus::core::storage::column_type::int64_type, jubatus::core::storage::column_type::int8_type, jubatus::core::storage::column_type::is(), JUBATUS_ASSERT_UNREACHABLE, jubatus::core::storage::column_type::string_type, type(), jubatus::core::storage::column_type::uint16_type, jubatus::core::storage::column_type::uint32_type, jubatus::core::storage::column_type::uint64_type, and jubatus::core::storage::column_type::uint8_type.

                                                         {
    column_type type = base_->type();

    packer.pack_array(2);
    packer.pack(type);

    if (type.is(column_type::uint8_type)) {
      static_cast<const uint8_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::uint16_type)) {
      static_cast<const uint16_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::uint32_type)) {
      static_cast<const uint32_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::uint64_type)) {
      static_cast<const uint64_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::int8_type)) {
      static_cast<const int8_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::int16_type)) {
      static_cast<const int16_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::int32_type)) {
      static_cast<const int32_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::int64_type)) {
      static_cast<const int64_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::float_type)) {
      static_cast<const float_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::double_type)) {
      static_cast<const double_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::string_type)) {
      static_cast<const string_column&>(*base_).pack_array(packer);
    } else if (type.is(column_type::bit_vector_type)) {
      static_cast<const bit_vector_column&>(*base_).pack_array(packer);
    } else {
      JUBATUS_ASSERT_UNREACHABLE();
    }
  }

Here is the call graph for this function:

void jubatus::core::storage::detail::abstract_column::msgpack_unpack ( msgpack::object  o )

inline

Definition at line 511 of file abstract_column.hpp.

References abstract_column(), base_, jubatus::core::storage::column_type::bit_vector_type, jubatus::core::storage::column_type::double_type, jubatus::core::storage::column_type::float_type, jubatus::core::storage::column_type::int16_type, jubatus::core::storage::column_type::int32_type, jubatus::core::storage::column_type::int64_type, jubatus::core::storage::column_type::int8_type, jubatus::core::storage::column_type::is(), JUBATUS_ASSERT_UNREACHABLE, objs, jubatus::core::storage::column_type::string_type, swap(), type(), jubatus::core::storage::column_type::uint16_type, jubatus::core::storage::column_type::uint32_type, jubatus::core::storage::column_type::uint64_type, and jubatus::core::storage::column_type::uint8_type.

                                       {
    if (o.type != msgpack::type::ARRAY || o.via.array.size != 2) {
      throw msgpack::type_error();
    }
    msgpack::object* objs = o.via.array.ptr;

    column_type type;
    objs[0].convert(&type);

    abstract_column tmp;
    if (!base_) {
      abstract_column(type).swap(tmp);  // NOLINT
    } else if (base_->type() == type) {
      this->swap(tmp);
    } else {
      throw type_unmatch_exception(
        "column: invalid type in serialize(): "
        "expected: " +
        jubatus::util::lang::lexical_cast<std::string>(base_->type()) +
        ", actual: " +
        jubatus::util::lang::lexical_cast<std::string>(type));
    }

    if (type.is(column_type::uint8_type)) {
      static_cast<uint8_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::uint16_type)) {
      static_cast<uint16_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::uint32_type)) {
      static_cast<uint32_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::uint64_type)) {
      static_cast<uint64_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::int8_type)) {
      static_cast<int8_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::int16_type)) {
      static_cast<int16_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::int32_type)) {
      static_cast<int32_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::int64_type)) {
      static_cast<int64_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::float_type)) {
      static_cast<float_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::double_type)) {
      static_cast<double_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::string_type)) {
      static_cast<string_column&>(*tmp.base_).unpack_array(objs[1]);
    } else if (type.is(column_type::bit_vector_type)) {
      static_cast<bit_vector_column&>(*tmp.base_).unpack_array(objs[1]);
    } else {
      JUBATUS_ASSERT_UNREACHABLE();
    }

    this->swap(tmp);
  }

Here is the call graph for this function:

void jubatus::core::storage::detail::abstract_column::pack_with_index ( uint64_t  index, framework::packer &  pk  ) const

inline

Definition at line 452 of file abstract_column.hpp.

References base_, and JUBATUS_ASSERT.

                                                 {
    JUBATUS_ASSERT(base_ != NULL);
    base_->pack_with_index(index, pk);
  }

template<typename T >

void jubatus::core::storage::detail::abstract_column::push_back ( const T &  value )

inline

Definition at line 429 of file abstract_column.hpp.

References base_, and JUBATUS_ASSERT.

                                 {
    JUBATUS_ASSERT(base_ != NULL);
    base_->push_back(value);
  }

bool jubatus::core::storage::detail::abstract_column::remove ( uint64_t  index )

inline

Definition at line 444 of file abstract_column.hpp.

References base_, and JUBATUS_ASSERT.

                              {
    JUBATUS_ASSERT(base_ != NULL);
    return base_->remove(index);
  };

void jubatus::core::storage::detail::abstract_column::swap ( abstract_column &  x )

inline

Definition at line 469 of file abstract_column.hpp.

References base_.

Referenced by msgpack_unpack().

                                {
    base_.swap(x.base_);
  }

Here is the caller graph for this function:

column_type jubatus::core::storage::detail::abstract_column::type ( ) const

inline

Definition at line 423 of file abstract_column.hpp.

References base_, and JUBATUS_ASSERT.

Referenced by msgpack_pack(), and msgpack_unpack().

                           {
    JUBATUS_ASSERT(base_ != NULL);
    return base_->type();
  }

Here is the caller graph for this function:

template<typename T >

bool jubatus::core::storage::detail::abstract_column::update ( uint64_t  index, const T &  value  )

inline

Definition at line 440 of file abstract_column.hpp.

References base_, and JUBATUS_ASSERT.

                                              {
    JUBATUS_ASSERT(base_ != NULL);
    return base_->update(index, value);
  }

Friends And Related Function Documentation

void swap ( abstract_column &  l, abstract_column &  r  )

friend

Definition at line 472 of file abstract_column.hpp.

                                                           {
    l.swap(r);
  }

Member Data Documentation

jubatus::util::lang::shared_ptr<abstract_column_base> jubatus::core::storage::detail::abstract_column::base_

private

Definition at line 566 of file abstract_column.hpp.

Referenced by abstract_column(), clear(), dump(), get(), insert(), msgpack_pack(), msgpack_unpack(), pack_with_index(), push_back(), remove(), swap(), type(), and update().

---

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

• jubatus/core/storage/abstract_column.hpp