Inheritance diagram for jubatus::core::burst::burst::impl_:

Collaboration diagram for jubatus::core::burst::burst::impl_:

Classes
class	aggregate_helper_

class	storage_

Public Member Functions
bool	add_document (const string &str, double pos)

bool	add_keyword (const string &keyword, const keyword_params &params, bool processed_in_this_server)

void	calculate_results ()

void	clear ()

result_map	get_all_bursted_results () const

result_map	get_all_bursted_results_at (double pos) const

keyword_list	get_all_keywords () const

void	get_diff (diff_t &ret) const

keyword_list	get_processed_keywords () const

result_t	get_result (const string &keyword) const

result_t	get_result_at (const string &keyword, double pos) const

storage::version	get_version () const

bool	has_been_mixed () const

	impl_ (const burst_options &options)

void	pack (framework::packer &packer) const

bool	put_diff (const diff_t &diff)

bool	remove_all_keywords ()

bool	remove_keyword (const string &keyword)

void	set_processed_keywords (const std::vector< string > &keywords)

void	unpack (msgpack::object o)

Static Public Member Functions
template<class Map >
static keyword_list	get_keyword_list (const Map &m)

Private Types
typedef unordered_map< string, aggregate_helper_ >	aggregators_t

typedef unordered_map< string, storage_ >	storages_t

Private Member Functions
const result_storage *	get_storage_ (const string &keyword) const

Static Private Member Functions
static void	unpack_impl_ (msgpack::object o, burst_options &unpacked_options, aggregators_t &unpacked_aggregators, storages_t &unpacked_storages)

Private Attributes
aggregators_t	aggregators_

bool	has_been_mixed_

burst_options	options_

storages_t	storages_

Detailed Description

Definition at line 76 of file burst.cpp.

Member Typedef Documentation

typedef unordered_map<string, aggregate_helper_> jubatus::core::burst::burst::impl_::aggregators_t

private

Definition at line 173 of file burst.cpp.

typedef unordered_map<string, storage_> jubatus::core::burst::burst::impl_::storages_t

private

Definition at line 172 of file burst.cpp.

Constructor & Destructor Documentation

jubatus::core::burst::burst::impl_::impl_ ( const burst_options & options )

inlineexplicit

Definition at line 176 of file burst.cpp.

References jubatus::core::burst::burst_options::batch_interval, jubatus::core::burst::burst_options::costcut_threshold, JUBATUS_EXCEPTION, jubatus::core::burst::burst_options::max_reuse_batch_num, options_, jubatus::core::burst::burst_options::result_window_rotate_size, and jubatus::core::burst::burst_options::window_batch_size.

       : options_(options),
         has_been_mixed_(false) {
     if (!(options_.window_batch_size > 0)) {
       throw JUBATUS_EXCEPTION(common::invalid_parameter(
           "window_batch_size should > 0"));
     }
     if (!(options_.batch_interval > 0)) {
       throw JUBATUS_EXCEPTION(common::invalid_parameter(
           "batch_interval should > 0"));
     }
     if (!(options_.result_window_rotate_size > 0)) {
       throw JUBATUS_EXCEPTION(common::invalid_parameter(
           "result_window_rotate_size should > 0"));
     }
     if (!(options_.max_reuse_batch_num >= 0)) {
       throw JUBATUS_EXCEPTION(common::invalid_parameter(
           "max_reuse_batch_num should >= 0"));
     }
     if (!(options_.costcut_threshold > 0)) {
       options_.costcut_threshold = DBL_MAX;
     }
   }

Member Function Documentation

bool jubatus::core::burst::burst::impl_::add_document	(	const string &	str,
		double	pos
	)

inline

Definition at line 267 of file burst.cpp.

References jubatus::core::burst::burst::impl_::aggregate_helper_::add_document(), and aggregators_.

                                                    {
     bool result = true;
     for (aggregators_t::iterator iter = aggregators_.begin();
          iter != aggregators_.end(); ++iter) {
       const string& keyword = iter->first;
       aggregate_helper_& a = iter->second;
       int r = str.find(keyword) != str.npos ? 1 : 0;
       result = a.add_document(1, r, pos) && result;
     }
     return result;
   }

Here is the call graph for this function:

bool jubatus::core::burst::burst::impl_::add_keyword	(	const string &	keyword,
		const keyword_params &	params,
		bool	processed_in_this_server
	)

inline

Definition at line 200 of file burst.cpp.

References aggregators_, jubatus::core::burst::keyword_params::gamma, JUBATUS_ASSERT_EQ, JUBATUS_EXCEPTION, options_, jubatus::core::burst::keyword_params::scaling_param, and storages_.

                                                   {
     if (!(params.scaling_param > 1)) {
       throw JUBATUS_EXCEPTION(
           common::invalid_parameter("scaling_param must be > 1."));
     }
     if (!(params.gamma > 0)) {
       throw JUBATUS_EXCEPTION(
           common::invalid_parameter("gamma must be > 0."));
     }
 
     if (storages_.count(keyword) > 0 || aggregators_.count(keyword) > 0) {
       return false;
     }
 
     std::pair<storages_t::iterator, bool> r =
         storages_.insert(std::make_pair(keyword, storage_(options_, params)));
 
     JUBATUS_ASSERT_EQ(true, r.second, "");
 
     if (processed_in_this_server) {
       aggregators_.insert(
           std::make_pair(keyword,
                          aggregate_helper_(options_, r.first->second)));
     }
 
     return true;
   }

void jubatus::core::burst::burst::impl_::calculate_results ( )

inline

Definition at line 279 of file burst.cpp.

References aggregators_, and options_.

                            {
     for (aggregators_t::iterator iter = aggregators_.begin();
          iter != aggregators_.end(); ++iter) {
       iter->second.calculate_result(options_);
     }
   }

void jubatus::core::burst::burst::impl_::clear ( )

inline

Definition at line 405 of file burst.cpp.

References aggregators_, and storages_.

Referenced by remove_all_keywords().

                {
     aggregators_t().swap(aggregators_);
     storages_t().swap(storages_);
   }

Here is the caller graph for this function:

result_map jubatus::core::burst::burst::impl_::get_all_bursted_results ( ) const

inline

Definition at line 302 of file burst.cpp.

References aggregators_, jubatus::core::burst::result_storage::get_latest_result(), and jubatus::core::burst::burst_result::is_bursted_at_latest_batch().

                                              {
     result_map results;
     for (aggregators_t::const_iterator iter = aggregators_.begin();
          iter != aggregators_.end(); ++iter) {
       const result_storage& s = *iter->second.get_storage();
       result_t result = s.get_latest_result();
       if (result.is_bursted_at_latest_batch()) {
         results.insert(std::make_pair(iter->first, result));
       }
     }
     return results;
   }

Here is the call graph for this function:

result_map jubatus::core::burst::burst::impl_::get_all_bursted_results_at ( double pos ) const

inline

Definition at line 315 of file burst.cpp.

References aggregators_, jubatus::core::burst::result_storage::get_result_at(), and jubatus::core::burst::burst_result::is_bursted_at().

                                                           {
     result_map results;
     for (aggregators_t::const_iterator iter = aggregators_.begin();
          iter != aggregators_.end(); ++iter) {
       const result_storage& s = *iter->second.get_storage();
       result_t result = s.get_result_at(pos);
       if (result.is_bursted_at(pos)) {
         results.insert(std::make_pair(iter->first, result));
       }
     }
     return results;
   }

Here is the call graph for this function:

keyword_list jubatus::core::burst::burst::impl_::get_all_keywords ( ) const

inline

Definition at line 260 of file burst.cpp.

References get_keyword_list(), and storages_.

                                         {
     return get_keyword_list(storages_);
   }

Here is the call graph for this function:

void jubatus::core::burst::burst::impl_::get_diff ( diff_t & ret ) const

inline

Definition at line 328 of file burst.cpp.

References aggregators_, and jubatus::core::burst::burst::diff_t::p_.

                                    {
     shared_ptr<diff_t::impl_> diff(new diff_t::impl_());
     diff_t::impl_::data_t& data = diff->data;
 
     for (aggregators_t::const_iterator iter = aggregators_.begin();
          iter != aggregators_.end(); ++iter) {
       const string& keyword = iter->first;
       diff_t::impl_::entry_t entry = iter->second.get_diff();
       data.insert(std::make_pair(keyword, entry));
     }
 
     ret.p_ = diff;
   }

template<class Map >

static keyword_list jubatus::core::burst::burst::impl_::get_keyword_list ( const Map & m )

inlinestatic

Definition at line 241 of file burst.cpp.

References jubatus::core::burst::keyword_params::gamma, jubatus::core::burst::keyword_with_params::gamma, jubatus::core::burst::keyword_with_params::keyword, jubatus::core::burst::keyword_params::scaling_param, and jubatus::core::burst::keyword_with_params::scaling_param.

Referenced by get_all_keywords(), and get_processed_keywords().

                                                      {
     keyword_list result;
     result.reserve(m.size());
 
     for (typename Map::const_iterator iter = m.begin();
          iter != m.end(); ++iter) {
       const string& keyword = iter->first;
       const keyword_params& params = iter->second.get_params();
 
       result.push_back(keyword_with_params());
       keyword_with_params& x = result.back();
       x.keyword = keyword;
       x.scaling_param = params.scaling_param;
       x.gamma = params.gamma;
     }
 
     return result;
   }

Here is the caller graph for this function:

keyword_list jubatus::core::burst::burst::impl_::get_processed_keywords ( ) const

inline

Definition at line 263 of file burst.cpp.

References aggregators_, and get_keyword_list().

                                               {
     return get_keyword_list(aggregators_);
   }

Here is the call graph for this function:

result_t jubatus::core::burst::burst::impl_::get_result ( const string & keyword ) const

inline

Definition at line 286 of file burst.cpp.

References jubatus::core::burst::result_storage::get_latest_result(), and get_storage_().

                                                    {
     const result_storage* s = get_storage_(keyword);
     if (s == NULL) {
       return result_t();
     }
     return s->get_latest_result();
   }

Here is the call graph for this function:

result_t jubatus::core::burst::burst::impl_::get_result_at	(	const string &	keyword,
		double	pos
	)		const

inline

Definition at line 294 of file burst.cpp.

References jubatus::core::burst::result_storage::get_result_at(), and get_storage_().

                                                                   {
     const result_storage* s = get_storage_(keyword);
     if (s == NULL) {
       return result_t();
     }
     return s->get_result_at(pos);
   }

Here is the call graph for this function:

const result_storage* jubatus::core::burst::burst::impl_::get_storage_ ( const string & keyword ) const

inlineprivate

Definition at line 454 of file burst.cpp.

Referenced by get_result(), and get_result_at().

                                                                   {
     storages_t::const_iterator iter = storages_.find(keyword);
     if (iter == storages_.end()) {
       return NULL;
     }
     return iter->second.get_storage().get();
   }

Here is the caller graph for this function:

storage::version jubatus::core::burst::burst::impl_::get_version ( ) const

inline

Definition at line 409 of file burst.cpp.

                                      {
     return storage::version();
   }

bool jubatus::core::burst::burst::impl_::has_been_mixed ( ) const

inline

Definition at line 377 of file burst.cpp.

References has_been_mixed_.

                               {
     return has_been_mixed_;
   }

void jubatus::core::burst::burst::impl_::pack ( framework::packer & packer ) const

inline

Definition at line 413 of file burst.cpp.

References aggregators_, options_, and storages_.

                                            {
     packer.pack_array(3);
 
     packer.pack(options_);
 
     packer.pack_map(storages_.size());
     for (storages_t::const_iterator iter = storages_.begin();
          iter != storages_.end(); ++iter) {
       packer.pack(iter->first);
       packer.pack_array(2);
       packer.pack(iter->second.get_params());
       iter->second.get_storage()->pack(packer);
     }
 
     packer.pack_map(aggregators_.size());
     for (aggregators_t::const_iterator iter = aggregators_.begin();
          iter != aggregators_.end(); ++iter) {
       packer.pack(iter->first);
       iter->second.get_aggregator()->pack(packer);
     }
   }

bool jubatus::core::burst::burst::impl_::put_diff ( const diff_t & diff )

inline

Definition at line 341 of file burst.cpp.

References aggregators_, has_been_mixed_, options_, jubatus::core::burst::burst::diff_t::p_, and storages_.

                                     {
     const diff_t::impl_::data_t& data = diff.p_->data;
 
     for (diff_t::impl_::data_t::const_iterator iter = data.begin();
          iter != data.end(); ++iter) {
       const std::string& keyword = iter->first;
       storages_t::iterator found = storages_.find(keyword);
 
       if (found == storages_.end()) {
         const keyword_params params = iter->second.params;
         std::pair<storages_t::iterator, bool> r =
             storages_.insert(
                 std::make_pair(keyword, storage_(options_, params)));
         found = r.first;
       }
 
       found->second.put_diff(iter->second);
     }
 
     std::vector<std::string> to_be_removed;
 
     for (aggregators_t::iterator iter = aggregators_.begin();
          iter != aggregators_.end(); ++iter) {
       iter->second.tick_removal_count();
       if (iter->second.is_to_be_removed()) {
         to_be_removed.push_back(iter->first);
       }
     }
 
     for (size_t i = 0; i < to_be_removed.size(); ++i) {
       aggregators_.erase(to_be_removed[i]);
     }
 
     has_been_mixed_ = true;
     return true;
   }

bool jubatus::core::burst::burst::impl_::remove_all_keywords ( )

inline

Definition at line 235 of file burst.cpp.

References clear().

                              {
     clear();
     return true;
   }

Here is the call graph for this function:

bool jubatus::core::burst::burst::impl_::remove_keyword ( const string & keyword )

inline

Definition at line 230 of file burst.cpp.

References aggregators_, and storages_.

                                              {
     aggregators_.erase(keyword);
     return storages_.erase(keyword) > 0;
   }

void jubatus::core::burst::burst::impl_::set_processed_keywords ( const std::vector< string > & keywords )

inline

Definition at line 381 of file burst.cpp.

References aggregators_, JUBATUS_EXCEPTION, options_, and storages_.

                                                                  {
     for (aggregators_t::iterator iter = aggregators_.begin();
          iter != aggregators_.end(); ++iter) {
       iter->second.set_unprocessed();
     }
 
     for (size_t i = 0; i < keywords.size(); ++i) {
       aggregators_t::iterator found = aggregators_.find(keywords[i]);
       if (found != aggregators_.end()) {
         found->second.set_processed();
       } else {
         storages_t::iterator s = storages_.find(keywords[i]);
         if (s == storages_.end()) {
           throw JUBATUS_EXCEPTION(
               common::exception::runtime_error(
                   "something went wrong in burst"));
         }
         aggregators_.insert(
             std::make_pair(keywords[i],
                            aggregate_helper_(options_, s->second)));
       }
     }
   }

void jubatus::core::burst::burst::impl_::unpack ( msgpack::object o )

inline

Definition at line 435 of file burst.cpp.

References aggregators_, options_, storages_, and unpack_impl_().

                                {
     burst_options unpacked_options = options_;
     aggregators_t unpacked_aggregators;
     storages_t unpacked_storages;
 
     unpack_impl_(o, unpacked_options, unpacked_aggregators, unpacked_storages);
 
     // assign
     options_ = unpacked_options;
     storages_.swap(unpacked_storages);
     aggregators_.swap(unpacked_aggregators);
   }

Here is the call graph for this function:

static void jubatus::core::burst::burst::impl_::unpack_impl_	(	msgpack::object	o,
		burst_options &	unpacked_options,
		aggregators_t &	unpacked_aggregators,
		storages_t &	unpacked_storages
	)

inlinestaticprivate

Definition at line 462 of file burst.cpp.

References jubatus::core::burst::burst::impl_::aggregate_helper_::get_aggregator(), and jubatus::core::burst::burst::impl_::storage_::get_storage().

Referenced by unpack().

                                                           {
     if (o.type != msgpack::type::ARRAY || o.via.array.size != 3) {
       throw msgpack::type_error();
     }
 
     o.via.array.ptr[0].convert(&unpacked_options);
 
     {
       const msgpack::object& m = o.via.array.ptr[1];
       if (m.type != msgpack::type::MAP) {
         throw msgpack::type_error();
       }
       size_t n = m.via.map.size;
       for (size_t i = 0; i < n; ++i) {
         string keyword;
         m.via.map.ptr[i].key.convert(&keyword);
 
         std::pair<keyword_params, msgpack::object> val;
         m.via.map.ptr[i].val.convert(&val);
         storage_ s(unpacked_options, val.first);
         s.get_storage()->unpack(val.second);
 
         unpacked_storages.insert(std::make_pair(keyword, s));
       }
     }
 
     {
       const msgpack::object& m = o.via.array.ptr[2];
       if (m.type != msgpack::type::MAP) {
         throw msgpack::type_error();
       }
       size_t n = m.via.map.size;
       for (size_t i = 0; i < n; ++i) {
         string keyword;
         m.via.map.ptr[i].key.convert(&keyword);
 
         storages_t::const_iterator iter = unpacked_storages.find(keyword);
         if (iter == unpacked_storages.end()) {
           throw msgpack::type_error();
         }
 
         aggregate_helper_ a(unpacked_options, iter->second);
         a.get_aggregator()->unpack(m.via.map.ptr[i].val);
 
         unpacked_aggregators.insert(std::make_pair(keyword, a));
       }
     }
   }