Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/arangod/Agency/Node.cpp

1170 lines
31 KiB
C++
Raw Blame History

///////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2018 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Kaveh Vahedipour
////////////////////////////////////////////////////////////////////////////////
#include "Node.h"
#include "Store.h"
#include "Basics/StringUtils.h"
#include <velocypack/Compare.h>
#include <velocypack/Iterator.h>
#include <velocypack/Slice.h>
#include <velocypack/velocypack-aliases.h>
#include <deque>
#include <regex>
using namespace arangodb::consensus;
using namespace arangodb::basics;
const Node::Children Node::dummyChildren = Node::Children();
const Node Node::_dummyNode = Node("dumm-di-dumm");
/// @brief Split strings by separator
inline static std::vector<std::string> split(const std::string& str, char separator) {
std::vector<std::string> result;
if (str.empty()) {
return result;
}
std::regex reg("/+");
std::string key = std::regex_replace(str, reg, "/");
if (!key.empty() && key.front() == '/') {
key.erase(0, 1);
}
if (!key.empty() && key.back() == '/') {
key.pop_back();
}
std::string::size_type p = 0;
std::string::size_type q;
while ((q = key.find(separator, p)) != std::string::npos) {
result.emplace_back(key, p, q - p);
p = q + 1;
}
result.emplace_back(key, p);
result.erase(std::find_if(result.rbegin(), result.rend(),
[](std::string const& s) -> bool {
return !s.empty();
}).base(),
result.end());
return result;
}
/// @brief Construct with node name
Node::Node(std::string const& name)
: _nodeName(name), _parent(nullptr), _store(nullptr), _vecBufDirty(true), _isArray(false) {}
/// @brief Construct with node name in tree structure
Node::Node(std::string const& name, Node* parent)
: _nodeName(name), _parent(parent), _store(nullptr), _vecBufDirty(true), _isArray(false) {}
/// @brief Construct for store
Node::Node(std::string const& name, Store* store)
: _nodeName(name), _parent(nullptr), _store(store), _vecBufDirty(true), _isArray(false) {}
/// @brief Default dtor
Node::~Node() {}
/// @brief Get slice to value buffer
Slice Node::slice() const {
// Some array
if (_isArray) {
rebuildVecBuf();
return Slice(_vecBuf.data());
}
// Some value
if (!_value.empty()) {
return Slice(_value.front().data());
}
// Empty object
return arangodb::velocypack::Slice::emptyObjectSlice();
}
/// @brief Optimization, which avoids recreating of Builder for output if
/// changes have not happened since last call
void Node::rebuildVecBuf() const {
if (_vecBufDirty) { // Dirty vector buffer
Builder tmp;
{
VPackArrayBuilder t(&tmp);
for (auto const& i : _value) {
tmp.add(Slice(i.data()));
}
}
_vecBuf = *tmp.steal();
_vecBufDirty = false;
}
}
/// @brief Get name of this node
std::string const& Node::name() const { return _nodeName; }
/// @brief Get full path of this node
std::string Node::uri() const {
Node* par = _parent;
std::stringstream path;
std::deque<std::string> names;
names.push_front(name());
while (par != nullptr) {
names.push_front(par->name());
par = par->_parent;
}
for (size_t i = 1; i < names.size(); ++i) {
path << "/" << names.at(i);
}
return path.str();
}
/// @brief Move constructor
Node::Node(Node&& other)
: _nodeName(std::move(other._nodeName)),
_parent(nullptr),
_store(nullptr),
_children(std::move(other._children)),
_ttl(std::move(other._ttl)),
_value(std::move(other._value)),
_vecBuf(std::move(other._vecBuf)),
_vecBufDirty(std::move(other._vecBufDirty)),
_isArray(std::move(other._isArray)) {
// The _children map has been moved here, therefore we must
// correct the _parent entry of all direct children:
for (auto& child : _children) {
child.second->_parent = this;
}
}
/// @brief Copy constructor
Node::Node(Node const& other)
: _nodeName(other._nodeName),
_parent(nullptr),
_store(nullptr),
_ttl(other._ttl),
_value(other._value),
_vecBuf(other._vecBuf),
_vecBufDirty(other._vecBufDirty),
_isArray(other._isArray) {
for (auto const& p : other._children) {
auto copy = std::make_shared<Node>(*p.second);
copy->_parent = this; // new children have us as _parent!
_children.insert(std::make_pair(p.first, copy));
}
}
/// @brief Assignment operator (slice)
/// 1. remove any existing time to live entry
/// 2. clear children map
/// 3. copy from rhs buffer to my buffer
/// @brief Must not copy _parent, _ttl, _observers
Node& Node::operator=(VPackSlice const& slice) {
removeTimeToLive();
_children.clear();
_value.clear();
if (slice.isArray()) {
_isArray = true;
_value.resize(slice.length());
for (size_t i = 0; i < slice.length(); ++i) {
_value.at(i).append(reinterpret_cast<char const*>(slice[i].begin()),
slice[i].byteSize());
}
} else {
_isArray = false;
_value.resize(1);
_value.front().append(reinterpret_cast<char const*>(slice.begin()), slice.byteSize());
}
_vecBufDirty = true;
return *this;
}
/// @brief Move operator
Node& Node::operator=(Node&& rhs) {
// 1. remove any existing time to live entry
// 2. move children map over
// 3. move value over
// Must not move over rhs's _parent, _observers
_nodeName = std::move(rhs._nodeName);
_children = std::move(rhs._children);
// The _children map has been moved here, therefore we must
// correct the _parent entry of all direct children:
for (auto& child : _children) {
child.second->_parent = this;
}
_value = std::move(rhs._value);
_vecBuf = std::move(rhs._vecBuf);
_vecBufDirty = std::move(rhs._vecBufDirty);
_isArray = std::move(rhs._isArray);
_ttl = std::move(rhs._ttl);
return *this;
}
/// Assignment operator
Node& Node::operator=(Node const& rhs) {
// 1. remove any existing time to live entry
// 2. clear children map
// 3. move from rhs to buffer pointer
// Must not move rhs's _parent, _observers
removeTimeToLive();
_nodeName = rhs._nodeName;
_children.clear();
for (auto const& p : rhs._children) {
auto copy = std::make_shared<Node>(*p.second);
copy->_parent = this; // new child copy has us as _parent
_children.insert(std::make_pair(p.first, copy));
}
_value = rhs._value;
_vecBuf = rhs._vecBuf;
_vecBufDirty = rhs._vecBufDirty;
_isArray = rhs._isArray;
_ttl = rhs._ttl;
return *this;
}
/// @brief Comparison with slice
bool Node::operator==(VPackSlice const& rhs) const {
if (rhs.isObject()) {
// build object recursively, take ttl into account
return VPackNormalizedCompare::equals(toBuilder().slice(), rhs);
} else {
return VPackNormalizedCompare::equals(slice(), rhs);
}
}
/// @brief Comparison with slice
bool Node::operator!=(VPackSlice const& rhs) const { return !(*this == rhs); }
/// @brief Remove this node from store
/// i.e. Remove this node as child of parent node if applicable
bool Node::remove() {
if (_parent == nullptr) {
return false;
}
Node& parent = *_parent;
return parent.removeChild(_nodeName);
}
/// @brief Remove child by name
bool Node::removeChild(std::string const& key) {
auto found = _children.find(key);
if (found == _children.end()) {
return false;
}
found->second->removeTimeToLive();
_children.erase(found);
return true;
}
/// @brief Node type
/// The check is if we are an array or a value. => LEAF. NODE else
NodeType Node::type() const {
return (_isArray || _value.size()) ? LEAF : NODE;
}
/// @brief lh-value at path vector
Node& Node::operator()(std::vector<std::string> const& pv) {
Node* current = this;
for (std::string const& key : pv) {
auto& children = current->_children;
auto child = children.find(key);
if (child == children.end()) {
current->_isArray = false;
if (!current->_value.empty()) {
current->_value.clear();
}
auto const& node = std::make_shared<Node>(key, current);
children.insert(Children::value_type(key, node));
current = node.get();
} else {
current = child->second.get();
}
}
return *current;
}
/// @brief rh-value at path vector. Check if TTL has expired.
Node const& Node::operator()(std::vector<std::string> const& pv) const {
Node const* current = this;
for (std::string const& key : pv) {
auto const& children = current->_children;
auto const child = children.find(key);
if (child == children.end() ||
(child->second->_ttl != std::chrono::system_clock::time_point() &&
child->second->_ttl < std::chrono::system_clock::now())) {
throw StoreException(std::string("Node ") + uri() + "/" + key + " not found!");
} else {
current = child->second.get();
}
}
return *current;
}
/// @brief lh-value at path
Node& Node::operator()(std::string const& path) {
return this->operator()(split(path, '/'));
}
/// @brief rh-value at path
Node const& Node::operator()(std::string const& path) const {
return this->operator()(split(path, '/'));
}
// Get method which always throws when not found:
Node const& Node::get(std::string const& path) const {
return this->operator()(path);
}
// lh-store
Node const& Node::root() const {
Node* par = _parent;
Node const* tmp = this;
while (par != nullptr) {
tmp = par;
par = par->_parent;
}
return *tmp;
}
// rh-store
Node& Node::root() {
Node* par = _parent;
Node* tmp = this;
while (par != nullptr) {
tmp = par;
par = par->_parent;
}
return *tmp;
}
Store& Node::store() { return *(root()._store); }
Store const& Node::store() const { return *(root()._store); }
Store* Node::getStore() {
Node* par = _parent;
Node* tmp = this;
while (par != nullptr) {
tmp = par;
par = par->_parent;
}
return tmp->_store; // Can be nullptr if we are not in a Node that belongs
// to a store.
}
// velocypack value type of this node
ValueType Node::valueType() const { return slice().type(); }
// file time to live entry for this node to now + millis
bool Node::addTimeToLive(long millis) {
auto tkey = std::chrono::system_clock::now() + std::chrono::milliseconds(millis);
store().timeTable().insert(std::pair<TimePoint, std::string>(tkey, uri()));
_ttl = tkey;
return true;
}
void Node::timeToLive(TimePoint const& ttl) {
_ttl = ttl;
}
TimePoint const& Node::timeToLive() const {
return _ttl;
}
// remove time to live entry for this node
bool Node::removeTimeToLive() {
Store* s = getStore(); // We could be in a Node that belongs to a store,
// or in one that doesn't.
if (s != nullptr) {
s->removeTTL(uri());
}
if (_ttl != std::chrono::system_clock::time_point()) {
_ttl = std::chrono::system_clock::time_point();
}
return true;
}
inline bool Node::observedBy(std::string const& url) const {
auto ret = store().observerTable().equal_range(url);
for (auto it = ret.first; it != ret.second; ++it) {
if (it->second == uri()) {
return true;
}
}
return false;
}
namespace arangodb {
namespace consensus {
/// Set value
template <>
bool Node::handle<SET>(VPackSlice const& slice) {
Slice val = slice.get("new");
if (val.isObject()) {
if (val.hasKey("op")) { // No longer a keyword but a regular key "op"
if (_children.find("op") == _children.end()) {
_children["op"] = std::make_shared<Node>("op", this);
}
*(_children["op"]) = val.get("op");
} else { // Deeper down
this->applies(val);
}
} else {
*this = val;
}
if (slice.hasKey("ttl")) {
VPackSlice ttl_v = slice.get("ttl");
if (ttl_v.isNumber()) {
long ttl =
1000l * ((ttl_v.isDouble())
? static_cast<long>(slice.get("ttl").getNumber<double>())
: static_cast<long>(slice.get("ttl").getNumber<int>()));
addTimeToLive(ttl);
} else {
LOG_TOPIC("66da2", WARN, Logger::AGENCY)
<< "Non-number value assigned to ttl: " << ttl_v.toJson();
}
}
return true;
}
/// Increment integer value or set 1
template <>
bool Node::handle<INCREMENT>(VPackSlice const& slice) {
size_t inc = (slice.hasKey("step") && slice.get("step").isUInt())
? slice.get("step").getUInt()
: 1;
Builder tmp;
{
VPackObjectBuilder t(&tmp);
try {
tmp.add("tmp", Value(this->slice().getInt() + inc));
} catch (std::exception const&) {
tmp.add("tmp", Value(1));
}
}
*this = tmp.slice().get("tmp");
return true;
}
/// Decrement integer value or set -1
template <>
bool Node::handle<DECREMENT>(VPackSlice const& slice) {
Builder tmp;
{
VPackObjectBuilder t(&tmp);
try {
tmp.add("tmp", Value(this->slice().getInt() - 1));
} catch (std::exception const&) {
tmp.add("tmp", Value(-1));
}
}
*this = tmp.slice().get("tmp");
return true;
}
/// Append element to array
template <>
bool Node::handle<PUSH>(VPackSlice const& slice) {
if (!slice.hasKey("new")) {
LOG_TOPIC("a9481", WARN, Logger::AGENCY)
<< "Operator push without new value: " << slice.toJson();
return false;
}
Builder tmp;
{
VPackArrayBuilder t(&tmp);
if (this->slice().isArray()) {
for (auto const& old : VPackArrayIterator(this->slice())) tmp.add(old);
}
tmp.add(slice.get("new"));
}
*this = tmp.slice();
return true;
}
/// Remove element from any place in array by value or position
template <>
bool Node::handle<ERASE>(VPackSlice const& slice) {
bool haveVal = slice.hasKey("val");
bool havePos = slice.hasKey("pos");
if (!haveVal && !havePos) {
LOG_TOPIC("b5eaa", WARN, Logger::AGENCY)
<< "Operator erase without value or position to be erased is illegal: "
<< slice.toJson();
return false;
} else if (haveVal && havePos) {
LOG_TOPIC("c2756", WARN, Logger::AGENCY)
<< "Operator erase with value and position to be erased is illegal: "
<< slice.toJson();
return false;
} else if (havePos && (!slice.get("pos").isUInt() && !slice.get("pos").isSmallInt())) {
LOG_TOPIC("d6648", WARN, Logger::AGENCY)
<< "Operator erase with non-positive integer position is illegal: "
<< slice.toJson();
}
Builder tmp;
{
VPackArrayBuilder t(&tmp);
if (this->slice().isArray()) {
if (haveVal) {
VPackSlice valToErase = slice.get("val");
for (auto const& old : VPackArrayIterator(this->slice())) {
if (VelocyPackHelper::compare(old, valToErase, /*useUTF8*/ true) != 0) {
tmp.add(old);
}
}
} else {
size_t pos = slice.get("pos").getNumber<size_t>();
if (pos >= this->slice().length()) {
return false;
}
size_t n = 0;
for (const auto& old : VPackArrayIterator(this->slice())) {
if (n != pos) {
tmp.add(old);
}
++n;
}
}
}
}
*this = tmp.slice();
return true;
}
/// Replace element from any place in array by new value
template <>
bool Node::handle<REPLACE>(VPackSlice const& slice) {
if (!slice.hasKey("val")) {
LOG_TOPIC("27763", WARN, Logger::AGENCY)
<< "Operator erase without value to be erased: " << slice.toJson();
return false;
}
if (!slice.hasKey("new")) {
LOG_TOPIC("28331", WARN, Logger::AGENCY)
<< "Operator replace without new value: " << slice.toJson();
return false;
}
Builder tmp;
{
VPackArrayBuilder t(&tmp);
if (this->slice().isArray()) {
VPackSlice valToRepl = slice.get("val");
for (auto const& old : VPackArrayIterator(this->slice())) {
if (VelocyPackHelper::compare(old, valToRepl, /*useUTF8*/ true) == 0) {
tmp.add(slice.get("new"));
} else {
tmp.add(old);
}
}
}
}
*this = tmp.slice();
return true;
}
/// Remove element from end of array.
template <>
bool Node::handle<POP>(VPackSlice const& slice) {
Builder tmp;
{
VPackArrayBuilder t(&tmp);
if (this->slice().isArray()) {
VPackArrayIterator it(this->slice());
if (it.size() > 1) {
size_t j = it.size() - 1;
for (auto old : it) {
tmp.add(old);
if (--j == 0) break;
}
}
}
}
*this = tmp.slice();
return true;
}
/// Prepend element to array
template <>
bool Node::handle<PREPEND>(VPackSlice const& slice) {
if (!slice.hasKey("new")) {
LOG_TOPIC("5ecb0", WARN, Logger::AGENCY)
<< "Operator prepend without new value: " << slice.toJson();
return false;
}
Builder tmp;
{
VPackArrayBuilder t(&tmp);
tmp.add(slice.get("new"));
if (this->slice().isArray()) {
for (auto const& old : VPackArrayIterator(this->slice())) tmp.add(old);
}
}
*this = tmp.slice();
return true;
}
/// Remove element from front of array
template <>
bool Node::handle<SHIFT>(VPackSlice const& slice) {
Builder tmp;
{
VPackArrayBuilder t(&tmp);
if (this->slice().isArray()) { // If a
VPackArrayIterator it(this->slice());
bool first = true;
for (auto const& old : it) {
if (first) {
first = false;
} else {
tmp.add(old);
}
}
}
}
*this = tmp.slice();
return true;
}
/// Add observer for this node
template <>
bool Node::handle<OBSERVE>(VPackSlice const& slice) {
if (!slice.hasKey("url")) return false;
if (!slice.get("url").isString()) return false;
std::string url(slice.get("url").copyString()), uri(this->uri());
// check if such entry exists
if (!observedBy(url)) {
store().observerTable().emplace(std::pair<std::string, std::string>(url, uri));
store().observedTable().emplace(std::pair<std::string, std::string>(uri, url));
return true;
}
return false;
}
/// Remove observer for this node
template <>
bool Node::handle<UNOBSERVE>(VPackSlice const& slice) {
if (!slice.hasKey("url")) return false;
if (!slice.get("url").isString()) return false;
std::string url(slice.get("url").copyString()), uri(this->uri());
// delete in both cases a single entry (ensured above)
// breaking the iterators is fine then
auto ret = store().observerTable().equal_range(url);
for (auto it = ret.first; it != ret.second; ++it) {
if (it->second == uri) {
store().observerTable().erase(it);
break;
}
}
ret = store().observedTable().equal_range(uri);
for (auto it = ret.first; it != ret.second; ++it) {
if (it->second == url) {
store().observedTable().erase(it);
return true;
}
}
return false;
}
} // namespace consensus
} // namespace arangodb
bool Node::applieOp(VPackSlice const& slice) {
std::string oper = slice.get("op").copyString();
if (oper == "delete") {
if (_parent == nullptr) { // root node
_children.clear();
_value.clear();
_vecBufDirty = true; // just in case there was an array
return true;
} else {
return _parent->removeChild(_nodeName);
}
} else if (oper == "set") { // "op":"set"
return handle<SET>(slice);
} else if (oper == "increment") { // "op":"increment"
return handle<INCREMENT>(slice);
} else if (oper == "decrement") { // "op":"decrement"
return handle<DECREMENT>(slice);
} else if (oper == "push") { // "op":"push"
return handle<PUSH>(slice);
} else if (oper == "pop") { // "op":"pop"
return handle<POP>(slice);
} else if (oper == "prepend") { // "op":"prepend"
return handle<PREPEND>(slice);
} else if (oper == "shift") { // "op":"shift"
return handle<SHIFT>(slice);
} else if (oper == "observe") { // "op":"observe"
return handle<OBSERVE>(slice);
} else if (oper == "unobserve") { // "op":"unobserve"
handle<UNOBSERVE>(slice);
if (_children.empty() && _value.empty()) {
if (_parent == nullptr) { // root node
_children.clear();
_value.clear();
return true;
} else {
return _parent->removeChild(_nodeName);
}
}
return true;
} else if (oper == "erase") { // "op":"erase"
return handle<ERASE>(slice);
} else if (oper == "replace") { // "op":"replace"
return handle<REPLACE>(slice);
} else { // "op" might not be a key word after all
LOG_TOPIC("fb064", WARN, Logger::AGENCY)
<< "Keyword 'op' without known operation. Handling as regular key: \""
<< oper << "\"";
}
return false;
}
// Apply slice to this node
bool Node::applies(VPackSlice const& slice) {
std::regex reg("/+");
clear();
if (slice.isObject()) {
for (auto const& i : VPackObjectIterator(slice)) {
std::string key = std::regex_replace(i.key.copyString(), reg, "/");
if (key.find('/') != std::string::npos) {
(*this)(key).applies(i.value);
} else {
auto found = _children.find(key);
if (found == _children.end()) {
_children[key] = std::make_shared<Node>(key, this);
}
_children[key]->applies(i.value);
}
}
} else {
*this = slice;
}
return true;
}
void Node::toBuilder(Builder& builder, bool showHidden) const {
typedef std::chrono::system_clock clock;
try {
if (type() == NODE) {
VPackObjectBuilder guard(&builder);
for (auto const& child : _children) {
auto const& cptr = child.second;
if ((cptr->_ttl != clock::time_point() && cptr->_ttl < clock::now()) ||
(child.first[0] == '.' && !showHidden)) {
continue;
}
builder.add(VPackValue(child.first));
cptr->toBuilder(builder);
}
} else {
if (!slice().isNone()) {
builder.add(slice());
}
}
} catch (std::exception const& e) {
LOG_TOPIC("44d99", ERR, Logger::AGENCY) << e.what() << " " << __FILE__ << __LINE__;
}
}
// Print internals to ostream
std::ostream& Node::print(std::ostream& o) const {
Builder builder;
toBuilder(builder);
o << builder.toJson();
return o;
}
Node::Children& Node::children() { return _children; }
Node::Children const& Node::children() const { return _children; }
Builder Node::toBuilder() const {
Builder builder;
toBuilder(builder);
return builder;
}
std::string Node::toJson() const { return toBuilder().toJson(); }
Node const* Node::parent() const { return _parent; }
std::vector<std::string> Node::exists(std::vector<std::string> const& rel) const {
std::vector<std::string> result;
Node const* cur = this;
for (auto const& sub : rel) {
auto it = cur->children().find(sub);
if (it != cur->children().end() &&
(it->second->_ttl == std::chrono::system_clock::time_point() ||
it->second->_ttl >= std::chrono::system_clock::now())) {
cur = it->second.get();
result.push_back(sub);
} else {
break;
}
}
return result;
}
std::vector<std::string> Node::exists(std::string const& rel) const {
return exists(split(rel, '/'));
}
bool Node::has(std::vector<std::string> const& rel) const {
return exists(rel).size() == rel.size();
}
bool Node::has(std::string const& rel) const { return has(split(rel, '/')); }
int64_t Node::getInt() const {
if (type() == NODE) {
throw StoreException("Must not convert NODE type to int");
}
return slice().getNumber<int64_t>();
}
uint64_t Node::getUInt() const {
if (type() == NODE) {
throw StoreException("Must not convert NODE type to unsigned int");
}
return slice().getNumber<uint64_t>();
}
bool Node::getBool() const {
if (type() == NODE) {
throw StoreException("Must not convert NODE type to bool");
}
return slice().getBool();
}
bool Node::isBool() const {
if (type() == NODE) {
return false;
}
return slice().isBool();
}
bool Node::isDouble() const {
if (type() == NODE) {
return false;
}
return slice().isDouble();
}
bool Node::isString() const {
if (type() == NODE) {
return false;
}
return slice().isString();
}
bool Node::isUInt() const {
if (type() == NODE) {
return false;
}
return slice().isUInt() || slice().isSmallInt();
}
bool Node::isInt() const {
if (type() == NODE) {
return false;
}
return slice().isInt() || slice().isSmallInt();
}
bool Node::isNumber() const {
if (type() == NODE) {
return false;
}
return slice().isNumber();
}
double Node::getDouble() const {
if (type() == NODE) {
throw StoreException("Must not convert NODE type to double");
}
return slice().getNumber<double>();
}
std::pair<Node const&, bool> Node::hasAsNode(std::string const& url) const {
// *this is bogus initializer
std::pair<Node const&, bool> fail_pair = {*this, false};
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
std::pair<Node const&, bool> good_pair = {target, true};
return good_pair;
} catch (...) {
// do nothing, fail_pair second already false
LOG_TOPIC("3e591", DEBUG, Logger::SUPERVISION)
<< "hasAsNode had exception processing " << url;
} // catch
return fail_pair;
} // hasAsNode
std::pair<Node&, bool> Node::hasAsWritableNode(std::string const& url) {
// *this is bogus initializer
std::pair<Node&, bool> fail_pair = {*this, false};
// retrieve node, throws if does not exist
try {
Node& target(operator()(url));
std::pair<Node&, bool> good_pair = {target, true};
return good_pair;
} catch (...) {
// do nothing, fail_pair second already false
LOG_TOPIC("027ed", DEBUG, Logger::SUPERVISION)
<< "hasAsWritableNode had exception processing " << url;
} // catch
return fail_pair;
} // hasAsWritableNode
std::pair<NodeType, bool> Node::hasAsType(std::string const& url) const {
std::pair<NodeType, bool> ret_pair = {NODE, false};
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
ret_pair.first = target.type();
ret_pair.second = true;
} catch (...) {
// do nothing, fail_pair second already false
LOG_TOPIC("7f66c", DEBUG, Logger::SUPERVISION)
<< "hasAsType had exception processing " << url;
} // catch
return ret_pair;
} // hasAsType
std::pair<Slice, bool> Node::hasAsSlice(std::string const& url) const {
// *this is bogus initializer
std::pair<Slice, bool> ret_pair = {arangodb::velocypack::Slice::emptyObjectSlice(), false};
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
ret_pair.first = target.slice();
ret_pair.second = true;
} catch (...) {
// do nothing, ret_pair second already false
LOG_TOPIC("16f3d", TRACE, Logger::SUPERVISION)
<< "hasAsSlice had exception processing " << url;
} // catch
return ret_pair;
} // hasAsSlice
std::pair<uint64_t, bool> Node::hasAsUInt(std::string const& url) const {
std::pair<uint64_t, bool> ret_pair(0, false);
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
if (target.isNumber()) {
ret_pair.first = target.getUInt();
ret_pair.second = true;
}
} catch (...) {
// do nothing, ret_pair second already false
LOG_TOPIC("eaa6b", DEBUG, Logger::SUPERVISION)
<< "hasAsUInt had exception processing " << url;
} // catch
return ret_pair;
} // hasAsUInt
std::pair<bool, bool> Node::hasAsBool(std::string const& url) const {
std::pair<bool, bool> ret_pair(false, false);
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
if (target.isBool()) {
ret_pair.first = target.getBool();
ret_pair.second = true;
}
} catch (...) {
// do nothing, ret_pair second already false
LOG_TOPIC("99238", DEBUG, Logger::SUPERVISION)
<< "hasAsBool had exception processing " << url;
} // catch
return ret_pair;
} // hasAsBool
std::pair<std::string, bool> Node::hasAsString(std::string const& url) const {
std::pair<std::string, bool> ret_pair;
ret_pair.second = false;
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
if (target.isString()) {
ret_pair.first = target.getString();
ret_pair.second = true;
}
} catch (...) {
// do nothing, ret_pair second already false
LOG_TOPIC("fd020", DEBUG, Logger::SUPERVISION)
<< "hasAsString had exception processing " << url;
} // catch
return ret_pair;
} // hasAsString
std::pair<Node::Children const&, bool> Node::hasAsChildren(std::string const& url) const {
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
return std::pair<Children const&, bool> {target.children(), true};
} catch (...) {
LOG_TOPIC("4e3cb", DEBUG, Logger::SUPERVISION)
<< "hasAsChildren had exception processing " << url;
} // catch
return std::pair<Children const&, bool> {dummyChildren, false};
} // hasAsChildren
std::pair<void*, bool> Node::hasAsBuilder(std::string const& url, Builder& builder,
bool showHidden) const {
std::pair<void*, bool> ret_pair(nullptr, false);
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
target.toBuilder(builder, showHidden);
ret_pair.second = true;
} catch (...) {
// do nothing, ret_pair second already false
LOG_TOPIC("fb685", DEBUG, Logger::SUPERVISION)
<< "hasAsBuilder(1) had exception processing " << url;
} // catch
return ret_pair;
} // hasAsBuilder
std::pair<Builder, bool> Node::hasAsBuilder(std::string const& url) const {
Builder builder;
std::pair<Builder, bool> ret_pair(builder, false);
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
target.toBuilder(builder);
ret_pair.first = builder; // update
ret_pair.second = true;
} catch (...) {
// do nothing, ret_pair second already false
LOG_TOPIC("68a75", DEBUG, Logger::SUPERVISION)
<< "hasAsBuilder(2) had exception processing " << url;
} // catch
return ret_pair;
} // hasAsBuilder
std::pair<Slice, bool> Node::hasAsArray(std::string const& url) const {
// *this is bogus initializer
std::pair<Slice, bool> ret_pair = {arangodb::velocypack::Slice::emptyObjectSlice(), false};
// retrieve node, throws if does not exist
try {
Node const& target(operator()(url));
ret_pair.first = target.getArray();
ret_pair.second = true;
} catch (...) {
// do nothing, ret_pair second already false
LOG_TOPIC("0a72b", DEBUG, Logger::SUPERVISION)
<< "hasAsArray had exception processing " << url;
} // catch
return ret_pair;
} // hasAsArray
std::string Node::getString() const {
if (type() == NODE) {
throw StoreException("Must not convert NODE type to string");
}
return slice().copyString();
}
Slice Node::getArray() const {
if (type() == NODE) {
throw StoreException("Must not convert NODE type to array");
}
if (!_isArray) {
throw StoreException("Not an array type");
}
rebuildVecBuf();
return Slice(_vecBuf.data());
}
void Node::clear() {
_children.clear();
_ttl = std::chrono::system_clock::time_point();
_value.clear();
_vecBuf.clear();
_vecBufDirty = true;
_isArray = false;
}
Reference in New Issue View Git Blame Copy Permalink