jubatus::core::driver::driver_base::mixable_holder Class Reference

#include <driver.hpp>

Inheritance diagram for jubatus::core::driver::driver_base::mixable_holder:

Collaboration diagram for jubatus::core::driver::driver_base::mixable_holder:

Public Member Functions
framework::diff_object	convert_diff_object (const msgpack::object &) const
void	get_argument (framework::packer &) const
void	get_diff (framework::packer &) const
std::vector< storage::version >	get_versions () const
void	mix (const msgpack::object &obj, framework::diff_object) const
std::set< std::string >	mixables () const
void	pull (const msgpack::object &arg, framework::packer &) const
void	push (const msgpack::object &)
bool	put_diff (const framework::diff_object &obj)
void	register_mixable (framework::mixable *mixable)
Public Member Functions inherited from jubatus::core::framework::linear_mixable
	linear_mixable ()
virtual	~linear_mixable ()
Public Member Functions inherited from jubatus::core::framework::mixable
virtual storage::version	get_version () const
	mixable ()
	mixable (const std::string &name)
virtual	~mixable ()
Public Member Functions inherited from jubatus::core::framework::push_mixable
	push_mixable ()
virtual	~push_mixable ()

Private Attributes
std::vector< mixable * >	mixables_

Additional Inherited Members
Protected Attributes inherited from jubatus::core::framework::mixable
std::set< std::string >	mixables_

Detailed Description

Definition at line 47 of file driver.hpp.

Member Function Documentation

diff_object jubatus::core::driver::driver_base::mixable_holder::convert_diff_object ( const msgpack::object &  o ) const

virtual

Implements jubatus::core::framework::linear_mixable.

Definition at line 90 of file driver.cpp.

References jubatus::core::framework::linear_mixable::convert_diff_object(), and JUBATUS_EXCEPTION.

                                  {
  if (o.type != msgpack::type::ARRAY ||
      o.via.array.size != count_mixable<linear_mixable>(mixables_)) {
    throw JUBATUS_EXCEPTION(
        core::common::exception::runtime_error("conversion failed"));
  }

  vector<diff_object> diffs;
  for (size_t i = 0; i < mixables_.size(); i++) {
    const linear_mixable* mixable =
      dynamic_cast<const linear_mixable*>(mixables_[i]);
    if (!mixable) {
      continue;
    }
    diffs.push_back(mixable->convert_diff_object(o.via.array.ptr[i]));
  }

  return diff_object(new internal_diff_object(diffs));
}

Here is the call graph for this function:

void jubatus::core::driver::driver_base::mixable_holder::get_argument ( framework::packer &  ) const

virtual

Implements jubatus::core::framework::push_mixable.

Definition at line 179 of file driver.cpp.

References jubatus::core::framework::push_mixable::get_argument().

                                                             {
  pk.pack_array(count_mixable<push_mixable>(mixables_));
  for (size_t i = 0; i < mixables_.size(); i++) {
    const push_mixable* mixable =
      dynamic_cast<const push_mixable*>(mixables_[i]);
    if (!mixable) {
      continue;
    }
    mixable->get_argument(pk);
  }
}

Here is the call graph for this function:

void jubatus::core::driver::driver_base::mixable_holder::get_diff ( framework::packer &  ) const

virtual

Implements jubatus::core::framework::linear_mixable.

Definition at line 142 of file driver.cpp.

References jubatus::core::framework::linear_mixable::get_diff().

                                                         {
  pk.pack_array(count_mixable<linear_mixable>(mixables_));
  for (size_t i = 0; i < mixables_.size(); i++) {
    const linear_mixable* mixable =
      dynamic_cast<const linear_mixable*>(mixables_[i]);
    if (!mixable) {
      continue;
    }
    mixable->get_diff(pk);
  }
}

Here is the call graph for this function:

std::vector< storage::version > jubatus::core::driver::driver_base::mixable_holder::get_versions

(

)

const

Definition at line 230 of file driver.cpp.

Referenced by jubatus::core::driver::driver_base::get_versions().

                                              {
  std::vector<storage::version> ret;
  for (size_t i = 0; i < mixables_.size(); ++i) {
    ret.push_back(mixables_[i]->get_version());
  }
  return ret;
}

Here is the caller graph for this function:

void jubatus::core::driver::driver_base::mixable_holder::mix ( const msgpack::object &  obj, framework::diff_object    ) const

virtual

Implements jubatus::core::framework::linear_mixable.

Definition at line 111 of file driver.cpp.

References JUBATUS_EXCEPTION, and jubatus::core::framework::linear_mixable::mix().

                           {
  if (o.type != msgpack::type::ARRAY ||
      o.via.array.size != count_mixable<linear_mixable>(mixables_)) {
    throw JUBATUS_EXCEPTION(
        core::common::exception::runtime_error("mix failed"));
  }

  internal_diff_object* diff_obj =
    dynamic_cast<internal_diff_object*>(ptr.get());
  if (!diff_obj) {
    throw JUBATUS_EXCEPTION(
        core::common::exception::runtime_error("bad diff_object"));
  }

  if (mixables_.size() != diff_obj->diffs_.size()) {
    throw JUBATUS_EXCEPTION(
        core::common::exception::runtime_error("diff size is wrong"));
  }

  for (size_t i = 0; i < mixables_.size(); i++) {
    const linear_mixable* mixable =
      dynamic_cast<const linear_mixable*>(mixables_[i]);
    if (!mixable) {
      continue;
    }
    mixable->mix(o.via.array.ptr[i], diff_obj->diffs_[i]);
  }
}

Here is the call graph for this function:

set< string > jubatus::core::driver::driver_base::mixable_holder::mixables ( ) const

virtual

Reimplemented from jubatus::core::framework::mixable.

Definition at line 70 of file driver.cpp.

References mixables_.

                                                      {
  set<string> s;

  if (count_mixable<linear_mixable>(mixables_) > 0) {
    s.insert("linear_mixable");
  }

  if (count_mixable<push_mixable>(mixables_) > 0) {
    s.insert("push_mixable");
  }

  return s;
}

void jubatus::core::driver::driver_base::mixable_holder::pull ( const msgpack::object &  arg, framework::packer &    ) const

virtual

Implements jubatus::core::framework::push_mixable.

Definition at line 191 of file driver.cpp.

References JUBATUS_EXCEPTION, and jubatus::core::framework::push_mixable::pull().

                      {
  if (arg.type != msgpack::type::ARRAY ||
      arg.via.array.size != count_mixable<push_mixable>(mixables_)) {
    throw JUBATUS_EXCEPTION(
        core::common::exception::runtime_error("pull array failed"));
  }

  pk.pack_array(count_mixable<push_mixable>(mixables_));
  for (size_t i = 0, obj_index = 0; i < mixables_.size(); i++) {
    const push_mixable* mixable =
      dynamic_cast<const push_mixable*>(mixables_[i]);
    if (!mixable) {
      continue;
    }
    mixable->pull(arg.via.array.ptr[obj_index], pk);
    obj_index++;
  }
}

Here is the call graph for this function:

void jubatus::core::driver::driver_base::mixable_holder::push ( const msgpack::object &  o )

virtual

Implements jubatus::core::framework::push_mixable.

Definition at line 212 of file driver.cpp.

References JUBATUS_EXCEPTION, and jubatus::core::framework::push_mixable::push().

                                                           {
  if (o.type != msgpack::type::ARRAY ||
      o.via.array.size != count_mixable<push_mixable>(mixables_)) {
    throw JUBATUS_EXCEPTION(
        core::common::exception::runtime_error("push failed"));
  }

  for (size_t i = 0, obj_index = 0; i < mixables_.size(); i++) {
    push_mixable* mixable = dynamic_cast<push_mixable*>(mixables_[i]);
    if (!mixable) {
      continue;
    }
    mixable->push(o.via.array.ptr[obj_index]);
    obj_index++;
  }
}

Here is the call graph for this function:

bool jubatus::core::driver::driver_base::mixable_holder::put_diff ( const framework::diff_object &  obj )

virtual

Implements jubatus::core::framework::linear_mixable.

Definition at line 154 of file driver.cpp.

References JUBATUS_EXCEPTION, and jubatus::core::framework::linear_mixable::put_diff().

                                                               {
  internal_diff_object* diff_obj =
    dynamic_cast<internal_diff_object*>(obj.get());
  if (!diff_obj) {
    throw JUBATUS_EXCEPTION(
        core::common::exception::runtime_error("bad diff_object"));
  }

  if (count_mixable<linear_mixable>(mixables_) != diff_obj->diffs_.size()) {
    throw JUBATUS_EXCEPTION(
        core::common::exception::runtime_error("diff size is wrong"));
  }

  bool success = true;
  for (size_t i = 0; i < mixables_.size(); i++) {
    linear_mixable* mixable = dynamic_cast<linear_mixable*>(mixables_[i]);
    if (!mixable) {
      continue;
    }
    success = mixable->put_diff(diff_obj->diffs_[i]) && success;
  }

  return success;
}

Here is the call graph for this function:

void jubatus::core::driver::driver_base::mixable_holder::register_mixable

(

framework::mixable *

mixable

)

Definition at line 84 of file driver.cpp.

Referenced by jubatus::core::driver::driver_base::register_mixable().

                                                                 {
  if (find(mixables_.begin(), mixables_.end(), mixable) == mixables_.end()) {
    mixables_.push_back(mixable);
  }
}

Here is the caller graph for this function:

Member Data Documentation

std::vector<mixable*> jubatus::core::driver::driver_base::mixable_holder::mixables_

private

Definition at line 66 of file driver.hpp.

Referenced by mixables().

---

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

• jubatus/core/driver/driver.hpp
• jubatus/core/driver/driver.cpp