Skip to content

Commit

Permalink
remove RETURN_OR_THROW macro (fixes #199)
Browse files Browse the repository at this point in the history
  • Loading branch information
@kmaehashi
kmaehashi committed Dec 19, 2012
1 parent 5e2a797 commit c8768a2
Show file tree
Hide file tree
Showing 7 changed files with 71 additions and 120 deletions.
6 changes: 6 additions & 0 deletions src/common/mprpc/rpc_server.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,8 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

#include "rpc_server.hpp"
#include "../exception.hpp"
#include <glog/logging.h>

using namespace msgpack::rpc;

Expand All @@ -37,7 +39,11 @@ void rpc_server::dispatch( request req ) {
fun->second->invoke( req );
} catch (const msgpack::type_error &e) {
req.error( msgpack::rpc::ARGUMENT_ERROR, std::string(e.what()) );
} catch (const jubatus::exception::jubatus_exception &e) {
LOG(WARNING) << e.diagnostic_information(true);
req.error(std::string(e.what()));
} catch( const std::exception &e ) {
LOG(ERROR) << e.what();
req.error( std::string( e.what()));
}
}
Expand Down
23 changes: 7 additions & 16 deletions src/server/classifier_impl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,15 +4,6 @@
#include "classifier_serv.hpp"
using namespace jubatus;
using namespace jubatus::framework;
#define RETURN_OR_THROW(f) try { \
return f; \
} catch (const jubatus::exception::jubatus_exception& e) { \
LOG(WARNING) << e.diagnostic_information(true); \
throw; \
} catch (const std::exception& e) { \
LOG(ERROR) << e.what(); \
throw; \
}
namespace jubatus { namespace server {
class classifier_impl_ : public classifier<classifier_impl_>
{
Expand All @@ -23,25 +14,25 @@ class classifier_impl_ : public classifier<classifier_impl_>
{}

bool set_config(std::string name, config_data c) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->set_config(c)); }
{ JWLOCK__(p_); return get_p()->set_config(c); }

config_data get_config(std::string name) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->get_config()); }
{ JRLOCK__(p_); return get_p()->get_config(); }

int train(std::string name, std::vector<std::pair<std::string,datum > > data) //update random
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->train(data)); }
{ JWLOCK__(p_); return get_p()->train(data); }

std::vector<std::vector<estimate_result > > classify(std::string name, std::vector<datum > data) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->classify(data)); }
{ JRLOCK__(p_); return get_p()->classify(data); }

bool save(std::string name, std::string id) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->save(id)); }
{ JWLOCK__(p_); return get_p()->save(id); }

bool load(std::string name, std::string id) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->load(id)); }
{ JWLOCK__(p_); return get_p()->load(id); }

std::map<std::string,std::map<std::string,std::string > > get_status(std::string name) //analysis broadcast
{ JRLOCK__(p_); RETURN_OR_THROW(p_->get_status()); }
{ JRLOCK__(p_); return p_->get_status(); }
int run(){ return p_->start(*this); };
common::cshared_ptr<classifier_serv> get_p(){ return p_->server(); };
private:
Expand Down
53 changes: 22 additions & 31 deletions src/server/graph_impl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,15 +4,6 @@
#include "graph_serv.hpp"
using namespace jubatus;
using namespace jubatus::framework;
#define RETURN_OR_THROW(f) try { \
return f; \
} catch (const jubatus::exception::jubatus_exception& e) { \
LOG(WARNING) << e.diagnostic_information(true); \
throw; \
} catch (const std::exception& e) { \
LOG(ERROR) << e.what(); \
throw; \
}
namespace jubatus { namespace server {
class graph_impl_ : public graph<graph_impl_>
{
Expand All @@ -23,70 +14,70 @@ class graph_impl_ : public graph<graph_impl_>
{}

std::string create_node(std::string name) //nolock random
{ NOLOCK__(p_); RETURN_OR_THROW(get_p()->create_node()); }
{ NOLOCK__(p_); return get_p()->create_node(); }

int remove_node(std::string name, std::string nid) //update cht(2)
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->remove_node(nid)); }
{ JWLOCK__(p_); return get_p()->remove_node(nid); }

int update_node(std::string name, std::string nid, property p) //update cht(2)
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->update_node(nid, p)); }
{ JWLOCK__(p_); return get_p()->update_node(nid, p); }

unsigned long create_edge(std::string name, std::string nid, edge_info ei) //nolock cht(1)
{ NOLOCK__(p_); RETURN_OR_THROW(get_p()->create_edge(nid, ei)); }
{ NOLOCK__(p_); return get_p()->create_edge(nid, ei); }

int update_edge(std::string name, std::string nid, unsigned long eid, edge_info ei) //update cht(2)
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->update_edge(nid, eid, ei)); }
{ JWLOCK__(p_); return get_p()->update_edge(nid, eid, ei); }

int remove_edge(std::string name, std::string nid, unsigned long e) //update cht(2)
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->remove_edge(nid, e)); }
{ JWLOCK__(p_); return get_p()->remove_edge(nid, e); }

double centrality(std::string name, std::string nid, int ct, preset_query q) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->centrality(nid, ct, q)); }
{ JRLOCK__(p_); return get_p()->centrality(nid, ct, q); }

bool add_centrality_query(std::string name, preset_query q) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->add_centrality_query(q)); }
{ JWLOCK__(p_); return get_p()->add_centrality_query(q); }

bool add_shortest_path_query(std::string name, preset_query q) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->add_shortest_path_query(q)); }
{ JWLOCK__(p_); return get_p()->add_shortest_path_query(q); }

bool remove_centrality_query(std::string name, preset_query q) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->remove_centrality_query(q)); }
{ JWLOCK__(p_); return get_p()->remove_centrality_query(q); }

bool remove_shortest_path_query(std::string name, preset_query q) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->remove_shortest_path_query(q)); }
{ JWLOCK__(p_); return get_p()->remove_shortest_path_query(q); }

std::vector<std::string > shortest_path(std::string name, shortest_path_req r) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->shortest_path(r)); }
{ JRLOCK__(p_); return get_p()->shortest_path(r); }

int update_index(std::string name) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->update_index()); }
{ JWLOCK__(p_); return get_p()->update_index(); }

int clear(std::string name) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->clear()); }
{ JWLOCK__(p_); return get_p()->clear(); }

node_info get_node(std::string name, std::string nid) //analysis cht(2)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->get_node(nid)); }
{ JRLOCK__(p_); return get_p()->get_node(nid); }

edge_info get_edge(std::string name, std::string nid, unsigned long e) //analysis cht(2)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->get_edge(nid, e)); }
{ JRLOCK__(p_); return get_p()->get_edge(nid, e); }

bool save(std::string name, std::string arg1) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->save(arg1)); }
{ JWLOCK__(p_); return get_p()->save(arg1); }

bool load(std::string name, std::string arg1) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->load(arg1)); }
{ JWLOCK__(p_); return get_p()->load(arg1); }

std::map<std::string,std::map<std::string,std::string > > get_status(std::string name) //analysis broadcast
{ JRLOCK__(p_); RETURN_OR_THROW(p_->get_status()); }
{ JRLOCK__(p_); return p_->get_status(); }

int create_node_here(std::string name, std::string nid) //update
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->create_node_here(nid)); }
{ JWLOCK__(p_); return get_p()->create_node_here(nid); }

int remove_global_node(std::string name, std::string nid) //update
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->remove_global_node(nid)); }
{ JWLOCK__(p_); return get_p()->remove_global_node(nid); }

int create_edge_here(std::string name, unsigned long eid, edge_info ei) //update
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->create_edge_here(eid, ei)); }
{ JWLOCK__(p_); return get_p()->create_edge_here(eid, ei); }
int run(){ return p_->start(*this); };
common::cshared_ptr<graph_serv> get_p(){ return p_->server(); };
private:
Expand Down
41 changes: 16 additions & 25 deletions src/server/recommender_impl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,15 +4,6 @@
#include "recommender_serv.hpp"
using namespace jubatus;
using namespace jubatus::framework;
#define RETURN_OR_THROW(f) try { \
return f; \
} catch (const jubatus::exception::jubatus_exception& e) { \
LOG(WARNING) << e.diagnostic_information(true); \
throw; \
} catch (const std::exception& e) { \
LOG(ERROR) << e.what(); \
throw; \
}
namespace jubatus { namespace server {
class recommender_impl_ : public recommender<recommender_impl_>
{
Expand All @@ -23,52 +14,52 @@ class recommender_impl_ : public recommender<recommender_impl_>
{}

bool set_config(std::string name, config_data c) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->set_config(c)); }
{ JWLOCK__(p_); return get_p()->set_config(c); }

config_data get_config(std::string name) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->get_config()); }
{ JRLOCK__(p_); return get_p()->get_config(); }

bool clear_row(std::string name, std::string id) //update cht(2)
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->clear_row(id)); }
{ JWLOCK__(p_); return get_p()->clear_row(id); }

bool update_row(std::string name, std::string id, datum d) //update cht(2)
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->update_row(id, d)); }
{ JWLOCK__(p_); return get_p()->update_row(id, d); }

bool clear(std::string name) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->clear()); }
{ JWLOCK__(p_); return get_p()->clear(); }

datum complete_row_from_id(std::string name, std::string id) //analysis cht(2)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->complete_row_from_id(id)); }
{ JRLOCK__(p_); return get_p()->complete_row_from_id(id); }

datum complete_row_from_data(std::string name, datum d) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->complete_row_from_data(d)); }
{ JRLOCK__(p_); return get_p()->complete_row_from_data(d); }

similar_result similar_row_from_id(std::string name, std::string id, unsigned int size) //analysis cht(2)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->similar_row_from_id(id, size)); }
{ JRLOCK__(p_); return get_p()->similar_row_from_id(id, size); }

similar_result similar_row_from_data(std::string name, datum data, unsigned int size) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->similar_row_from_data(data, size)); }
{ JRLOCK__(p_); return get_p()->similar_row_from_data(data, size); }

datum decode_row(std::string name, std::string id) //analysis cht(2)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->decode_row(id)); }
{ JRLOCK__(p_); return get_p()->decode_row(id); }

std::vector<std::string > get_all_rows(std::string name) //analysis broadcast
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->get_all_rows()); }
{ JRLOCK__(p_); return get_p()->get_all_rows(); }

float similarity(std::string name, datum lhs, datum rhs) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->similarity(lhs, rhs)); }
{ JRLOCK__(p_); return get_p()->similarity(lhs, rhs); }

float l2norm(std::string name, datum d) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->l2norm(d)); }
{ JRLOCK__(p_); return get_p()->l2norm(d); }

bool save(std::string name, std::string id) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->save(id)); }
{ JWLOCK__(p_); return get_p()->save(id); }

bool load(std::string name, std::string id) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->load(id)); }
{ JWLOCK__(p_); return get_p()->load(id); }

std::map<std::string,std::map<std::string,std::string > > get_status(std::string name) //analysis broadcast
{ JRLOCK__(p_); RETURN_OR_THROW(p_->get_status()); }
{ JRLOCK__(p_); return p_->get_status(); }
int run(){ return p_->start(*this); };
common::cshared_ptr<recommender_serv> get_p(){ return p_->server(); };
private:
Expand Down
23 changes: 7 additions & 16 deletions src/server/regression_impl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,15 +4,6 @@
#include "regression_serv.hpp"
using namespace jubatus;
using namespace jubatus::framework;
#define RETURN_OR_THROW(f) try { \
return f; \
} catch (const jubatus::exception::jubatus_exception& e) { \
LOG(WARNING) << e.diagnostic_information(true); \
throw; \
} catch (const std::exception& e) { \
LOG(ERROR) << e.what(); \
throw; \
}
namespace jubatus { namespace server {
class regression_impl_ : public regression<regression_impl_>
{
Expand All @@ -23,25 +14,25 @@ class regression_impl_ : public regression<regression_impl_>
{}

bool set_config(std::string name, config_data c) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->set_config(c)); }
{ JWLOCK__(p_); return get_p()->set_config(c); }

config_data get_config(std::string name) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->get_config()); }
{ JRLOCK__(p_); return get_p()->get_config(); }

int train(std::string name, std::vector<std::pair<float,datum > > train_data) //update random
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->train(train_data)); }
{ JWLOCK__(p_); return get_p()->train(train_data); }

std::vector<float > estimate(std::string name, std::vector<datum > estimate_data) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->estimate(estimate_data)); }
{ JRLOCK__(p_); return get_p()->estimate(estimate_data); }

bool save(std::string name, std::string arg1) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->save(arg1)); }
{ JWLOCK__(p_); return get_p()->save(arg1); }

bool load(std::string name, std::string arg1) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->load(arg1)); }
{ JWLOCK__(p_); return get_p()->load(arg1); }

std::map<std::string,std::map<std::string,std::string > > get_status(std::string name) //analysis broadcast
{ JRLOCK__(p_); RETURN_OR_THROW(p_->get_status()); }
{ JRLOCK__(p_); return p_->get_status(); }
int run(){ return p_->start(*this); };
common::cshared_ptr<regression_serv> get_p(){ return p_->server(); };
private:
Expand Down
33 changes: 12 additions & 21 deletions src/server/stat_impl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,15 +4,6 @@
#include "stat_serv.hpp"
using namespace jubatus;
using namespace jubatus::framework;
#define RETURN_OR_THROW(f) try { \
return f; \
} catch (const jubatus::exception::jubatus_exception& e) { \
LOG(WARNING) << e.diagnostic_information(true); \
throw; \
} catch (const std::exception& e) { \
LOG(ERROR) << e.what(); \
throw; \
}
namespace jubatus { namespace server {
class stat_impl_ : public stat<stat_impl_>
{
Expand All @@ -23,40 +14,40 @@ class stat_impl_ : public stat<stat_impl_>
{}

bool set_config(std::string name, config_data c) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->set_config(c)); }
{ JWLOCK__(p_); return get_p()->set_config(c); }

config_data get_config(std::string name) //analysis random
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->get_config()); }
{ JRLOCK__(p_); return get_p()->get_config(); }

bool push(std::string name, std::string key, double val) //update cht(1)
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->push(key, val)); }
{ JWLOCK__(p_); return get_p()->push(key, val); }

double sum(std::string name, std::string key) //analysis cht(1)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->sum(key)); }
{ JRLOCK__(p_); return get_p()->sum(key); }

double stddev(std::string name, std::string key) //analysis cht(1)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->stddev(key)); }
{ JRLOCK__(p_); return get_p()->stddev(key); }

double max(std::string name, std::string key) //analysis cht(1)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->max(key)); }
{ JRLOCK__(p_); return get_p()->max(key); }

double min(std::string name, std::string key) //analysis cht(1)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->min(key)); }
{ JRLOCK__(p_); return get_p()->min(key); }

double entropy(std::string name, std::string key) //analysis cht(1)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->entropy(key)); }
{ JRLOCK__(p_); return get_p()->entropy(key); }

double moment(std::string name, std::string key, int n, double c) //analysis cht(1)
{ JRLOCK__(p_); RETURN_OR_THROW(get_p()->moment(key, n, c)); }
{ JRLOCK__(p_); return get_p()->moment(key, n, c); }

bool save(std::string name, std::string id) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->save(id)); }
{ JWLOCK__(p_); return get_p()->save(id); }

bool load(std::string name, std::string id) //update broadcast
{ JWLOCK__(p_); RETURN_OR_THROW(get_p()->load(id)); }
{ JWLOCK__(p_); return get_p()->load(id); }

std::map<std::string,std::map<std::string,std::string > > get_status(std::string name) //analysis broadcast
{ JRLOCK__(p_); RETURN_OR_THROW(p_->get_status()); }
{ JRLOCK__(p_); return p_->get_status(); }
int run(){ return p_->start(*this); };
common::cshared_ptr<stat_serv> get_p(){ return p_->server(); };
private:
Expand Down

0 comments on commit c8768a2

Please sign in to comment.