Skip to content

Commit 4e38db4

Browse files
kounelisagiskounelisagis
committed
Format code using the new clang-format version
1 parent e243bd3 commit 4e38db4

36 files changed

+2953
-2418
lines changed

‎tiledb/cc/array.cc‎

Lines changed: 178 additions & 146 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
1-
#include <tiledb/tiledb.h> // for enums
2-
#include <tiledb/tiledb> // C++
1+
#include <tiledb/tiledb.h> // for enums
2+
#include <tiledb/tiledb> // C++
33

44
#include "common.h"
55

@@ -13,20 +13,22 @@ namespace libtiledbcpp {
1313
using namespace tiledb;
1414
namespace py = pybind11;
1515

16-
void init_array(py::module &m) {
16+
void init_array(py::module& m) {
1717
py::class_<tiledb::Array>(m, "Array")
1818
//.def(py::init<py::object, py::object, py::iterable, py::object,
1919
// py::object, py::object>())
2020
.def(
21-
py::init<const Context &, const std::string &, tiledb_query_type_t>(),
21+
py::init<const Context&, const std::string&, tiledb_query_type_t>(),
2222
py::keep_alive<1, 2>() /* Array keeps Context alive */)
2323

2424
// Temporary initializer while Array is converted from Cython to PyBind.
25-
.def(py::init([](const Context &ctx, py::object array) {
26-
tiledb_array_t *c_array = (py::capsule)array.attr("__capsule__")();
27-
return std::make_unique<Array>(ctx, c_array, false);
28-
}),
29-
py::keep_alive<1, 2>(), py::keep_alive<1, 3>())
25+
.def(
26+
py::init([](const Context& ctx, py::object array) {
27+
tiledb_array_t* c_array = (py::capsule)array.attr("__capsule__")();
28+
return std::make_unique<Array>(ctx, c_array, false);
29+
}),
30+
py::keep_alive<1, 2>(),
31+
py::keep_alive<1, 3>())
3032

3133
// TODO capsule Array(const Context& ctx, tiledb_array_t* carray,
3234
// tiledb_config_t* config)
@@ -38,155 +40,185 @@ void init_array(py::module &m) {
3840
.def("reopen", &Array::reopen)
3941
.def("set_open_timestamp_start", &Array::set_open_timestamp_start)
4042
.def("set_open_timestamp_end", &Array::set_open_timestamp_end)
41-
.def_property_readonly("open_timestamp_start",
42-
&Array::open_timestamp_start)
43+
.def_property_readonly(
44+
"open_timestamp_start", &Array::open_timestamp_start)
4345
.def_property_readonly("open_timestamp_end", &Array::open_timestamp_end)
4446
.def("set_config", &Array::set_config)
4547
.def("config", &Array::config)
4648
.def("close", &Array::close)
47-
.def("consolidate",
48-
[](Array &self, const Context &ctx, Config *config) {
49-
if (self.query_type() == TILEDB_READ) {
50-
throw TileDBError("cannot consolidate array opened in readonly "
51-
"mode (mode='r')");
52-
}
53-
Array::consolidate(ctx, self.uri(), config);
54-
})
55-
.def("consolidate",
56-
[](Array &self, const Context &ctx,
57-
const std::vector<std::string> &fragment_uris, Config *config) {
58-
if (self.query_type() == TILEDB_READ) {
59-
throw TileDBError("cannot consolidate array opened in readonly "
60-
"mode (mode='r')");
61-
}
62-
std::vector<const char *> c_strings;
63-
c_strings.reserve(fragment_uris.size());
64-
for (const auto &str : fragment_uris) {
65-
c_strings.push_back(str.c_str());
66-
}
67-
68-
Array::consolidate(ctx, self.uri(), c_strings.data(),
69-
fragment_uris.size(), config);
70-
})
71-
.def("consolidate",
72-
[](Array &self, const Context &ctx,
73-
const std::tuple<int, int> &timestamp, Config *config) {
74-
if (self.query_type() == TILEDB_READ) {
75-
throw TileDBError("cannot consolidate array opened in readonly "
76-
"mode (mode='r')");
77-
}
78-
int start, end;
79-
std::tie(start, end) = timestamp;
80-
81-
config->set("sm.consolidation.timestamp_start",
82-
std::to_string(start));
83-
config->set("sm.consolidation.timestamp_end", std::to_string(end));
84-
85-
Array::consolidate(ctx, self.uri(), config);
86-
})
49+
.def(
50+
"consolidate",
51+
[](Array& self, const Context& ctx, Config* config) {
52+
if (self.query_type() == TILEDB_READ) {
53+
throw TileDBError(
54+
"cannot consolidate array opened in readonly "
55+
"mode (mode='r')");
56+
}
57+
Array::consolidate(ctx, self.uri(), config);
58+
})
59+
.def(
60+
"consolidate",
61+
[](Array& self,
62+
const Context& ctx,
63+
const std::vector<std::string>& fragment_uris,
64+
Config* config) {
65+
if (self.query_type() == TILEDB_READ) {
66+
throw TileDBError(
67+
"cannot consolidate array opened in readonly "
68+
"mode (mode='r')");
69+
}
70+
std::vector<const char*> c_strings;
71+
c_strings.reserve(fragment_uris.size());
72+
for (const auto& str : fragment_uris) {
73+
c_strings.push_back(str.c_str());
74+
}
75+
76+
Array::consolidate(
77+
ctx,
78+
self.uri(),
79+
c_strings.data(),
80+
fragment_uris.size(),
81+
config);
82+
})
83+
.def(
84+
"consolidate",
85+
[](Array& self,
86+
const Context& ctx,
87+
const std::tuple<int, int>& timestamp,
88+
Config* config) {
89+
if (self.query_type() == TILEDB_READ) {
90+
throw TileDBError(
91+
"cannot consolidate array opened in readonly "
92+
"mode (mode='r')");
93+
}
94+
int start, end;
95+
std::tie(start, end) = timestamp;
96+
97+
config->set(
98+
"sm.consolidation.timestamp_start", std::to_string(start));
99+
config->set("sm.consolidation.timestamp_end", std::to_string(end));
100+
101+
Array::consolidate(ctx, self.uri(), config);
102+
})
87103
.def("vacuum", &Array::vacuum)
88-
.def("create",
89-
py::overload_cast<const std::string &, const ArraySchema &>(
90-
&Array::create))
91-
.def("load_schema",
92-
py::overload_cast<const Context &, const std::string &>(
93-
&Array::load_schema))
104+
.def(
105+
"create",
106+
py::overload_cast<const std::string&, const ArraySchema&>(
107+
&Array::create))
108+
.def(
109+
"load_schema",
110+
py::overload_cast<const Context&, const std::string&>(
111+
&Array::load_schema))
94112
.def("encryption_type", &Array::encryption_type)
95113

96114
// TODO non_empty_domain
97115
// TODO non_empty_domain_var
98116

99117
.def("query_type", &Array::query_type)
100-
.def("consolidate_fragments",
101-
[](Array &self, const Context &ctx,
102-
const std::vector<std::string> &fragment_uris, Config *config) {
103-
std::vector<const char *> c_strings;
104-
c_strings.reserve(fragment_uris.size());
105-
for (const auto &str : fragment_uris) {
106-
c_strings.push_back(str.c_str());
107-
}
108-
ctx.handle_error(tiledb_array_consolidate_fragments(
109-
ctx.ptr().get(), self.uri().c_str(), c_strings.data(),
110-
fragment_uris.size(), config->ptr().get()));
111-
})
112-
.def("consolidate_metadata",
113-
py::overload_cast<const Context &, const std::string &,
114-
Config *const>(&Array::consolidate_metadata))
115-
.def("put_metadata",
116-
[](Array &self, std::string &key, tiledb_datatype_t tdb_type,
117-
const py::buffer &b) {
118-
py::buffer_info info = b.request();
119-
120-
// size_t size = std::reduce(info.shape.begin(),
121-
// info.shape.end());
122-
size_t size = 1;
123-
for (auto s : info.shape) {
124-
size *= s;
125-
}
126-
// size_t nbytes = size * info.itemsize;
127-
128-
self.put_metadata(key, tdb_type, size, info.ptr);
129-
/*
130-
std::cout << "ndim: " << info.ndim << std::endl;
131-
132-
133-
std::cout << "sz: " << size << std::endl;
134-
std::cout << "imsz: " << info.itemsize << std::endl;
135-
136-
std::cout << "--|" << std::endl;
137-
for (auto& s : info.shape) {
138-
std::cout << s << std::endl;
139-
}
140-
*/
141-
})
142-
.def("get_metadata",
143-
[](Array &self, std::string &key) -> py::buffer {
144-
tiledb_datatype_t tdb_type;
145-
uint32_t value_num = 0;
146-
const void *data_ptr = nullptr;
147-
148-
self.get_metadata(key, &tdb_type, &value_num, &data_ptr);
149-
150-
if (data_ptr == nullptr && value_num != 1) {
151-
throw py::key_error();
152-
}
153-
154-
assert(data_ptr != nullptr);
155-
return py::memoryview::from_memory(
156-
data_ptr, value_num * tiledb_datatype_size(tdb_type));
157-
})
158-
.def("get_metadata_from_index",
159-
[](Array &self, uint64_t index) -> py::tuple {
160-
tiledb_datatype_t tdb_type;
161-
uint32_t value_num = 0;
162-
const void *data_ptr = nullptr;
163-
std::string key;
164-
165-
self.get_metadata_from_index(index, &key, &tdb_type, &value_num,
166-
&data_ptr);
167-
168-
if (data_ptr == nullptr && value_num != 1) {
169-
throw py::key_error();
170-
}
171-
// TODO handle empty value case
172-
173-
assert(data_ptr != nullptr);
174-
auto buf = py::memoryview::from_memory(
175-
data_ptr, value_num * tiledb_datatype_size(tdb_type));
176-
177-
return py::make_tuple(tdb_type, buf);
178-
})
118+
.def(
119+
"consolidate_fragments",
120+
[](Array& self,
121+
const Context& ctx,
122+
const std::vector<std::string>& fragment_uris,
123+
Config* config) {
124+
std::vector<const char*> c_strings;
125+
c_strings.reserve(fragment_uris.size());
126+
for (const auto& str : fragment_uris) {
127+
c_strings.push_back(str.c_str());
128+
}
129+
ctx.handle_error(tiledb_array_consolidate_fragments(
130+
ctx.ptr().get(),
131+
self.uri().c_str(),
132+
c_strings.data(),
133+
fragment_uris.size(),
134+
config->ptr().get()));
135+
})
136+
.def(
137+
"consolidate_metadata",
138+
py::overload_cast<const Context&, const std::string&, Config* const>(
139+
&Array::consolidate_metadata))
140+
.def(
141+
"put_metadata",
142+
[](Array& self,
143+
std::string& key,
144+
tiledb_datatype_t tdb_type,
145+
const py::buffer& b) {
146+
py::buffer_info info = b.request();
147+
148+
// size_t size = std::reduce(info.shape.begin(),
149+
// info.shape.end());
150+
size_t size = 1;
151+
for (auto s : info.shape) {
152+
size *= s;
153+
}
154+
// size_t nbytes = size * info.itemsize;
155+
156+
self.put_metadata(key, tdb_type, size, info.ptr);
157+
/*
158+
std::cout << "ndim: " << info.ndim << std::endl;
159+
160+
161+
std::cout << "sz: " << size << std::endl;
162+
std::cout << "imsz: " << info.itemsize << std::endl;
163+
164+
std::cout << "--|" << std::endl;
165+
for (auto& s : info.shape) {
166+
std::cout << s << std::endl;
167+
}
168+
*/
169+
})
170+
.def(
171+
"get_metadata",
172+
[](Array& self, std::string& key) -> py::buffer {
173+
tiledb_datatype_t tdb_type;
174+
uint32_t value_num = 0;
175+
const void* data_ptr = nullptr;
176+
177+
self.get_metadata(key, &tdb_type, &value_num, &data_ptr);
178+
179+
if (data_ptr == nullptr && value_num != 1) {
180+
throw py::key_error();
181+
}
182+
183+
assert(data_ptr != nullptr);
184+
return py::memoryview::from_memory(
185+
data_ptr, value_num * tiledb_datatype_size(tdb_type));
186+
})
187+
.def(
188+
"get_metadata_from_index",
189+
[](Array& self, uint64_t index) -> py::tuple {
190+
tiledb_datatype_t tdb_type;
191+
uint32_t value_num = 0;
192+
const void* data_ptr = nullptr;
193+
std::string key;
194+
195+
self.get_metadata_from_index(
196+
index, &key, &tdb_type, &value_num, &data_ptr);
197+
198+
if (data_ptr == nullptr && value_num != 1) {
199+
throw py::key_error();
200+
}
201+
// TODO handle empty value case
202+
203+
assert(data_ptr != nullptr);
204+
auto buf = py::memoryview::from_memory(
205+
data_ptr, value_num * tiledb_datatype_size(tdb_type));
206+
207+
return py::make_tuple(tdb_type, buf);
208+
})
179209
.def("delete_metadata", &Array::delete_metadata)
180-
.def("has_metadata",
181-
[](Array &self, std::string &key) -> py::tuple {
182-
tiledb_datatype_t has_type;
183-
bool has_it = self.has_metadata(key, &has_type);
184-
return py::make_tuple(has_it, has_type);
185-
})
210+
.def(
211+
"has_metadata",
212+
[](Array& self, std::string& key) -> py::tuple {
213+
tiledb_datatype_t has_type;
214+
bool has_it = self.has_metadata(key, &has_type);
215+
return py::make_tuple(has_it, has_type);
216+
})
186217
.def("metadata_num", &Array::metadata_num)
187-
.def("delete_array",
188-
py::overload_cast<const Context &, const std::string &>(
189-
&Array::delete_array));
218+
.def(
219+
"delete_array",
220+
py::overload_cast<const Context&, const std::string&>(
221+
&Array::delete_array));
190222
}
191223

192-
} // namespace libtiledbcpp
224+
} // namespace libtiledbcpp

0 commit comments

Comments
 (0)