|
diff --git a/jubatus/core/common/unordered_map.hpp b/jubatus/core/common/unordered_map.hpp |
|
index abfb162..2186b6b 100644 |
|
--- a/jubatus/core/common/unordered_map.hpp |
|
+++ b/jubatus/core/common/unordered_map.hpp |
|
@@ -18,16 +18,16 @@ |
|
#define JUBATUS_CORE_COMMON_UNORDERED_MAP_HPP_ |
|
|
|
#include <msgpack.hpp> |
|
-#include <pficommon/data/unordered_map.h> |
|
+#include "jubatus/util/data/unordered_map.h" |
|
|
|
-// to make pfi::data::unordered_map serializable |
|
+// to make util::data::unordered_map serializable |
|
|
|
namespace msgpack { |
|
|
|
template<typename K, typename V, typename H, typename E, typename A> |
|
-inline pfi::data::unordered_map<K, V, H, E, A> operator>>( |
|
+inline jubatus::util::data::unordered_map<K, V, H, E, A> operator>>( |
|
object o, |
|
- pfi::data::unordered_map<K, V, H, E, A>& v) { |
|
+ jubatus::util::data::unordered_map<K, V, H, E, A>& v) { |
|
if (o.type != type::MAP) { |
|
throw type_error(); |
|
} |
|
@@ -48,7 +48,7 @@ template<typename Stream, |
|
typename A> |
|
inline packer<Stream>& operator<<( |
|
packer<Stream>& o, |
|
- const pfi::data::unordered_map<K, V, H, E, A>& v) { |
|
+ const jubatus::util::data::unordered_map<K, V, H, E, A>& v) { |
|
o.pack_map(v.size()); |
|
for (typename std::tr1::unordered_map<K, V, H, E, A>::const_iterator |
|
it = v.begin(); it != v.end(); ++it) { |
|
diff --git a/jubatus/core/framework/wscript b/jubatus/core/framework/wscript |
|
index eda86a8..c7bdf9d 100644 |
|
--- a/jubatus/core/framework/wscript |
|
+++ b/jubatus/core/framework/wscript |
|
@@ -16,7 +16,7 @@ def build(bld): |
|
source=t + '.cpp', |
|
target=t, |
|
includes='.', |
|
- use='MSGPACK'+libassert, |
|
+ use='MSGPACK jubatus_util'+libassert, |
|
) |
|
|
|
tests = [ |
|
diff --git a/jubatus/core/fv_converter/json_converter.hpp b/jubatus/core/fv_converter/json_converter.hpp |
|
index 18458a6..48ed9b6 100644 |
|
--- a/jubatus/core/fv_converter/json_converter.hpp |
|
+++ b/jubatus/core/fv_converter/json_converter.hpp |
|
@@ -17,15 +17,15 @@ |
|
#ifndef JUBATUS_CORE_FV_CONVERTER_JSON_CONVERTER_HPP_ |
|
#define JUBATUS_CORE_FV_CONVERTER_JSON_CONVERTER_HPP_ |
|
|
|
-namespace pfi { |
|
+namespace jubatus { |
|
+namespace util { |
|
namespace text { |
|
namespace json { |
|
class json; |
|
} // namespace json |
|
} // namespace text |
|
-} // namespace pfi |
|
+} // namespace util |
|
|
|
-namespace jubatus { |
|
namespace core { |
|
namespace fv_converter { |
|
|
|
@@ -35,7 +35,7 @@ class json_converter { |
|
public: |
|
static const char* NULL_STRING; |
|
|
|
- static void convert(const pfi::text::json::json& jason, datum& ret_datum); |
|
+ static void convert(const jubatus::util::text::json::json& jason, datum& ret_datum); |
|
}; |
|
|
|
} // namespace fv_converter |
|
diff --git a/jubatus/core/graph/graph_type.hpp b/jubatus/core/graph/graph_type.hpp |
|
index 6dbd081..d084167 100644 |
|
--- a/jubatus/core/graph/graph_type.hpp |
|
+++ b/jubatus/core/graph/graph_type.hpp |
|
@@ -23,8 +23,8 @@ |
|
#include <vector> |
|
|
|
#include <msgpack.hpp> |
|
-#include <pficommon/data/serialization.h> |
|
-#include <pficommon/data/unordered_map.h> |
|
+#include "jubatus/util/data/serialization.h" |
|
+#include "jubatus/util/data/unordered_map.h" |
|
|
|
#include "../common/exception.hpp" |
|
#include "../common/type.hpp" |
|
@@ -49,14 +49,14 @@ struct eigen_vector_info { |
|
|
|
MSGPACK_DEFINE(score, out_degree_num); |
|
|
|
- friend class pfi::data::serialization::access; |
|
+ friend class jubatus::util::data::serialization::access; |
|
template<class Ar> |
|
void serialize(Ar& ar) { |
|
ar & MEMBER(score) & MEMBER(out_degree_num); |
|
} |
|
}; |
|
|
|
-typedef pfi::data::unordered_map<node_id_t, eigen_vector_info> |
|
+typedef jubatus::util::data::unordered_map<node_id_t, eigen_vector_info> |
|
eigen_vector_diff; |
|
|
|
struct node_info { |
|
@@ -66,7 +66,7 @@ struct node_info { |
|
|
|
MSGPACK_DEFINE(property, in_edges, out_edges); |
|
|
|
- friend class pfi::data::serialization::access; |
|
+ friend class jubatus::util::data::serialization::access; |
|
|
|
template<class Ar> |
|
void serialize(Ar& ar) { |
|
@@ -81,7 +81,7 @@ struct edge_info { |
|
|
|
MSGPACK_DEFINE(p, src, tgt); |
|
|
|
- friend class pfi::data::serialization::access; |
|
+ friend class jubatus::util::data::serialization::access; |
|
|
|
template<class Ar> |
|
void serialize(Ar& ar) { |
|
@@ -100,7 +100,7 @@ struct preset_query { |
|
|
|
MSGPACK_DEFINE(edge_query, node_query); |
|
|
|
- friend class pfi::data::serialization::access; |
|
+ friend class jubatus::util::data::serialization::access; |
|
|
|
template<class Ar> |
|
void serialize(Ar& ar) { |
|
@@ -108,7 +108,7 @@ struct preset_query { |
|
} |
|
}; |
|
|
|
-typedef pfi::data::unordered_map<node_id_t, std::pair<uint64_t, node_id_t> > |
|
+typedef jubatus::util::data::unordered_map<node_id_t, std::pair<uint64_t, node_id_t> > |
|
spt_edges; |
|
|
|
struct shortest_path_tree { |
|
@@ -118,7 +118,7 @@ struct shortest_path_tree { |
|
|
|
MSGPACK_DEFINE(landmark, from_root, to_root); |
|
|
|
- friend class pfi::data::serialization::access; |
|
+ friend class jubatus::util::data::serialization::access; |
|
template<class Ar> |
|
void serialize(Ar& ar) { |
|
ar & MEMBER(landmark) & MEMBER(from_root) & MEMBER(to_root); |
|
@@ -127,10 +127,10 @@ struct shortest_path_tree { |
|
|
|
typedef std::vector<shortest_path_tree> spt_diff; |
|
|
|
-typedef pfi::data::unordered_map<preset_query, eigen_vector_diff> |
|
+typedef jubatus::util::data::unordered_map<preset_query, eigen_vector_diff> |
|
eigen_vector_query_diff; |
|
|
|
-typedef pfi::data::unordered_map<preset_query, spt_diff> spt_query_diff; |
|
+typedef jubatus::util::data::unordered_map<preset_query, spt_diff> spt_query_diff; |
|
|
|
class graph_exception : public jubatus::core::common::exception::runtime_error { |
|
public: |
|
@@ -211,9 +211,8 @@ class unknown_query : public graph_exception { |
|
|
|
} // namespace graph |
|
} // namespace core |
|
-} // namespace jubatus |
|
|
|
-namespace pfi { |
|
+namespace util { |
|
namespace data { |
|
|
|
template<> struct hash<jubatus::core::graph::preset_query> { |
|
@@ -242,6 +241,7 @@ template<> struct hash<jubatus::core::graph::preset_query> { |
|
}; |
|
|
|
} // namespace data |
|
-} // namespace pfi |
|
+} // namespace util |
|
+} // namespace jubatus |
|
|
|
#endif // JUBATUS_CORE_GRAPH_GRAPH_TYPE_HPP_ |
|
diff --git a/jubatus/core/storage/lsh_vector.hpp b/jubatus/core/storage/lsh_vector.hpp |
|
index 9ca9d6f..8d9710e 100644 |
|
--- a/jubatus/core/storage/lsh_vector.hpp |
|
+++ b/jubatus/core/storage/lsh_vector.hpp |
|
@@ -21,8 +21,8 @@ |
|
#include <ostream> |
|
#include <utility> |
|
#include <vector> |
|
-#include <pficommon/data/serialization.h> |
|
-#include <pficommon/data/unordered_map.h> |
|
+#include "jubatus/util/data/serialization.h" |
|
+#include "jubatus/util/data/unordered_map.h" |
|
|
|
namespace jubatus { |
|
namespace core { |
|
@@ -54,8 +54,8 @@ class lsh_vector { |
|
void swap(lsh_vector& lv); |
|
|
|
private: |
|
- friend class pfi::data::hash<lsh_vector>; |
|
- friend class pfi::data::serialization::access; |
|
+ friend class jubatus::util::data::hash<lsh_vector>; |
|
+ friend class jubatus::util::data::serialization::access; |
|
|
|
template <class Ar> |
|
void serialize(Ar& ar) { |
|
@@ -76,9 +76,8 @@ inline std::ostream& operator<<(std::ostream& os, const lsh_vector& lv) { |
|
|
|
} // namespace storage |
|
} // namespace core |
|
-} // namespace jubatus |
|
|
|
-namespace pfi { |
|
+namespace util { |
|
namespace data { |
|
|
|
template<> |
|
@@ -99,6 +98,7 @@ class hash<jubatus::core::storage::lsh_vector> { |
|
}; |
|
|
|
} // namespace data |
|
-} // namespace pfi |
|
+} // namespace util |
|
+} // namespace jubatus |
|
|
|
#endif // JUBATUS_CORE_STORAGE_LSH_VECTOR_HPP_ |
|
diff --git a/jubatus/core/table/column/column_table_test.cpp b/jubatus/core/table/column/column_table_test.cpp |
|
index 35db747..6514cff 100644 |
|
--- a/jubatus/core/table/column/column_table_test.cpp |
|
+++ b/jubatus/core/table/column/column_table_test.cpp |
|
@@ -19,11 +19,11 @@ |
|
#include <vector> |
|
|
|
#include <gtest/gtest.h> |
|
-#include <pficommon/text/json.h> |
|
+#include "jubatus/util/text/json.h" |
|
#include <msgpack.hpp> |
|
#include "column_table.hpp" |
|
-#include "pficommon/math/random.h" |
|
-#include "pficommon/lang/shared_ptr.h" |
|
+#include "jubatus/util/math/random.h" |
|
+#include "jubatus/util/lang/shared_ptr.h" |
|
|
|
using std::string; |
|
using std::vector; |
|
@@ -167,7 +167,7 @@ TEST(add, bit_vector) { |
|
schema.push_back(column_type(column_type::ctype##_type)); \ |
|
base.init(schema); \ |
|
for (size_t i = 0; i < num; ++i) { \ |
|
- ASSERT_EQ(base.add(pfi::lang::lexical_cast<std::string>(i) + \ |
|
+ ASSERT_EQ(base.add(jubatus::util::lang::lexical_cast<std::string>(i) + \ |
|
"a", owner("local") , ctype##_t(i)), true); \ |
|
} \ |
|
ASSERT_EQ(num, base.size()); \ |
|
@@ -186,7 +186,7 @@ TEST(get_column, float) { |
|
base.init(schema); |
|
for (size_t i = 0; i < 100; ++i) { |
|
ASSERT_EQ(base.add( |
|
- pfi::lang::lexical_cast<std::string>(i) + |
|
+ jubatus::util::lang::lexical_cast<std::string>(i) + |
|
"a", owner("local"), static_cast<float>(i)), true); |
|
} |
|
ASSERT_EQ(base.size(), 100U); |
|
@@ -201,9 +201,9 @@ TEST(get_column, string) { |
|
base.init(schema); |
|
for (size_t i = 0; i < 100; ++i) { |
|
ASSERT_EQ(base.add( |
|
- pfi::lang::lexical_cast<std::string>(i) + "a", |
|
+ jubatus::util::lang::lexical_cast<std::string>(i) + "a", |
|
owner("local"), |
|
- pfi::lang::lexical_cast<std::string>(i)), true); |
|
+ jubatus::util::lang::lexical_cast<std::string>(i)), true); |
|
} |
|
const string_column& strings = base.get_string_column(0); |
|
ASSERT_EQ(strings.size(), 100U); |
|
@@ -223,7 +223,7 @@ TEST(get_column, bit_vector) { |
|
bv.reverse_bit(j % bit_vector_width); |
|
} |
|
ASSERT_EQ(base.add( |
|
- pfi::lang::lexical_cast<std::string>(i) + "a", owner("local") , bv), |
|
+ jubatus::util::lang::lexical_cast<std::string>(i) + "a", owner("local") , bv), |
|
true); |
|
} |
|
ASSERT_EQ(base.size(), num); |
|
@@ -239,7 +239,7 @@ TEST(get_column, bit_vector) { |
|
column_table base; \ |
|
base.init(schema); \ |
|
for (size_t i = 0; i < num; ++i) { \ |
|
- ASSERT_EQ(base.add(pfi::lang::lexical_cast<std::string>(i) + "a", \ |
|
+ ASSERT_EQ(base.add(jubatus::util::lang::lexical_cast<std::string>(i) + "a", \ |
|
owner("local"), \ |
|
ctype##_t(i)), true); \ |
|
} \ |
|
@@ -263,9 +263,9 @@ TEST(get_and_read_column, string) { |
|
const size_t num = 120; |
|
for (size_t i = 0; i < num; ++i) { |
|
ASSERT_EQ(base.add( |
|
- pfi::lang::lexical_cast<std::string>(i) + "a", |
|
+ jubatus::util::lang::lexical_cast<std::string>(i) + "a", |
|
owner("local"), |
|
- pfi::lang::lexical_cast<std::string>(i)), true); |
|
+ jubatus::util::lang::lexical_cast<std::string>(i)), true); |
|
} |
|
ASSERT_EQ(base.size(), num); |
|
const string_column& strings = base.get_string_column(0); |
|
@@ -283,7 +283,7 @@ TEST(get_and_read_column, bit_vector) { |
|
bit_vector bv(bit_vector_width); |
|
bv.set_bit(i % bit_vector_width); |
|
ASSERT_EQ(base.add( |
|
- pfi::lang::lexical_cast<std::string>(i) + "a", |
|
+ jubatus::util::lang::lexical_cast<std::string>(i) + "a", |
|
owner("local"), bv), true); |
|
} |
|
ASSERT_EQ(base.size(), num); |
|
@@ -296,7 +296,7 @@ TEST(pfi, lexical_cast) { |
|
vector<column_type> schema; |
|
schema.push_back(column_type(column_type::string_type)); |
|
base.init(schema); |
|
- base.add<std::string>(pfi::lang::lexical_cast<std::string>(10), |
|
+ base.add<std::string>(jubatus::util::lang::lexical_cast<std::string>(10), |
|
owner("local"), |
|
"hoge"); |
|
} |
|
@@ -309,7 +309,7 @@ TEST(pfi, lexical_cast) { |
|
column_table base; \ |
|
base.init(schema); \ |
|
for (size_t i = 0; i < num; ++i) { \ |
|
- base.add(pfi::lang::lexical_cast<std::string>(i)+"hoge", \ |
|
+ base.add(jubatus::util::lang::lexical_cast<std::string>(i)+"hoge", \ |
|
owner("local"), \ |
|
ctype##_t(i)); \ |
|
} \ |
|
@@ -330,7 +330,7 @@ TEST(base, iterate_float) { |
|
base.init(schema); |
|
for (size_t i = 0; i < 1000; ++i) { |
|
base.add<float>( |
|
- pfi::lang::lexical_cast<std::string>(i) + "hoge", owner("local"), |
|
+ jubatus::util::lang::lexical_cast<std::string>(i) + "hoge", owner("local"), |
|
0.8 * i); |
|
} |
|
const float_column& ic = base.get_float_column(0); |
|
@@ -346,18 +346,18 @@ TEST(base, iterate_string) { |
|
base.init(schema); |
|
for (size_t i = 0; i < 1000; ++i) { |
|
base.add<std::string>( |
|
- pfi::lang::lexical_cast<std::string>(i)+"key", |
|
+ jubatus::util::lang::lexical_cast<std::string>(i)+"key", |
|
owner("local"), |
|
- pfi::lang::lexical_cast<std::string>(i)+"value"); |
|
+ jubatus::util::lang::lexical_cast<std::string>(i)+"value"); |
|
} |
|
const string_column& ic = base.get_string_column(0); |
|
for (size_t i = 0; i < 1000; ++i) { |
|
- ASSERT_EQ(ic[i], pfi::lang::lexical_cast<std::string>(i)+"value"); |
|
+ ASSERT_EQ(ic[i], jubatus::util::lang::lexical_cast<std::string>(i)+"value"); |
|
} |
|
} |
|
|
|
TEST(base, iterate_bit_vector) { |
|
- typedef pfi::math::random::random<pfi::math::random::mersenne_twister> mt; |
|
+ typedef jubatus::util::math::random::random<jubatus::util::math::random::mersenne_twister> mt; |
|
|
|
column_table base; |
|
vector<column_type> schema; |
|
@@ -371,7 +371,7 @@ TEST(base, iterate_bit_vector) { |
|
bv.reverse_bit((rand1.next_int()*j)%70); |
|
} |
|
base.add( |
|
- pfi::lang::lexical_cast<std::string>(i) + "key", owner("local"), bv); |
|
+ jubatus::util::lang::lexical_cast<std::string>(i) + "key", owner("local"), bv); |
|
} |
|
const bit_vector_column& ic = base.get_bit_vector_column(0); |
|
for (size_t i = 0; i < 1000; ++i) { |
|
@@ -383,7 +383,7 @@ TEST(base, iterate_bit_vector) { |
|
} |
|
} |
|
TEST(column, multi_column) { |
|
- typedef pfi::math::random::random<pfi::math::random::mersenne_twister> mt; |
|
+ typedef jubatus::util::math::random::random<jubatus::util::math::random::mersenne_twister> mt; |
|
column_table base; |
|
vector<column_type> schema; |
|
schema.push_back(column_type(column_type::bit_vector_type, 70)); |
|
@@ -396,7 +396,7 @@ TEST(column, multi_column) { |
|
bv.reverse_bit((rand1.next_int()*j)%70); |
|
} |
|
base.add( |
|
- pfi::lang::lexical_cast<std::string>(i) + "key", owner("local"), bv, |
|
+ jubatus::util::lang::lexical_cast<std::string>(i) + "key", owner("local"), bv, |
|
static_cast<int32_t>(rand1.next_int())); |
|
} |
|
const bit_vector_column& ic1 = base.get_bit_vector_column(0); |
|
@@ -813,7 +813,7 @@ TEST(table, json_dump) { |
|
schema.push_back(column_type(column_type::ctype##_type)); \ |
|
base.init(schema); \ |
|
for (size_t i = 0; i < 3000; i += 20) { \ |
|
- base.add("a" + pfi::lang::lexical_cast<string>(i), \ |
|
+ base.add("a" + jubatus::util::lang::lexical_cast<string>(i), \ |
|
owner("local"), \ |
|
static_cast<ctype##_t>(i)); \ |
|
} \ |
|
@@ -821,7 +821,7 @@ TEST(table, json_dump) { |
|
const uint64_t max_size = base.size(); \ |
|
size_t cnt = 0; \ |
|
for (size_t i = 0; base.size(); i += 20) { \ |
|
- base.delete_row("a" + pfi::lang::lexical_cast<string>(i)); \ |
|
+ base.delete_row("a" + jubatus::util::lang::lexical_cast<string>(i)); \ |
|
++cnt; \ |
|
ASSERT_EQ(max_size - cnt, base.size()); \ |
|
const ctype##_column& ic = base.get_##ctype##_column(0); \ |
|
@@ -842,7 +842,7 @@ TEST(table, json_dump) { |
|
} \ |
|
} \ |
|
for (size_t i = 0; i < 300; i += 20) { \ |
|
- base.add("a" + pfi::lang::lexical_cast<string>(i), \ |
|
+ base.add("a" + jubatus::util::lang::lexical_cast<string>(i), \ |
|
owner("local"), \ |
|
static_cast<ctype##_t>(i)); \ |
|
} \ |
|
diff --git a/wscript b/wscript |
|
index 586f2e6..7723e5a 100644 |
|
--- a/wscript |
|
+++ b/wscript |
|
@@ -61,7 +61,6 @@ def configure(conf): |
|
conf.find_program('pkg-config') # make sure that pkg-config command exists |
|
try: |
|
conf.check_cfg(package = 'libglog', args = '--cflags --libs') |
|
- conf.check_cfg(package = 'pficommon', args = '--cflags --libs') |
|
except conf.errors.ConfigurationError: |
|
e = sys.exc_info()[1] |
|
conf.to_log("PKG_CONFIG_PATH: " + os.environ.get('PKG_CONFIG_PATH', '')) |