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

vpack library update

This commit is contained in:
Jan Steemann 2015-11-06 16:28:48 +01:00
parent 746c1a2573
commit 02fc1e4d20
16 changed files with 569 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
3rdParty/velocypack/include/velocypack/Builder.h vendored
View File

@ -63,11 +63,11 @@ namespace arangodb {
private:
Buffer<uint8_t> _buffer; // Here we collect the result
uint8_t* _start; // Always points to the start of _buffer
ValueLength _size; // Always contains the size of _buffer
ValueLength _pos; // the append position, always <= _size
bool _attrWritten; // indicates that an attribute name
// in an object has been written
uint8_t* _start; // Always points to the start of _buffer
ValueLength _size; // Always contains the size of _buffer
ValueLength _pos; // the append position, always <= _size
bool _attrWritten; // indicates that an attribute name
// in an object has been written
std::vector<ValueLength> _stack; // Start positions of
// open objects/arrays
std::vector<std::vector<ValueLength>> _index; // Indices for starts
@ -92,7 +92,7 @@ namespace arangodb {
// allocations. In the beginning, the _stack is empty, which
// allows to build a sequence of unrelated VPack objects in the
// buffer. Whenever the stack is empty, one can use the start,
// size and stealTo methods to get out the ready built VPack
// size and slice methods to get out the ready built VPack
// object(s).
void reserveSpace (ValueLength len) {
@ -145,15 +145,9 @@ namespace arangodb {
~Builder () {
}
Builder (Builder const& that) {
_buffer = that._buffer;
_start = _buffer.data();
_size = _buffer.size();
_pos = that._pos;
_attrWritten = that._attrWritten;
_stack = that._stack;
_index = that._index;
options = that.options;
Builder (Builder const& that)
: _buffer(that._buffer), _start(_buffer.data()), _size(_buffer.size()), _pos(that._pos),
_attrWritten(that._attrWritten), _stack(that._stack), _index(that._index), options(that.options) {
}
Builder& operator= (Builder const& that) {
@ -233,17 +227,23 @@ namespace arangodb {
}
// Add a subvalue into an object from a Value:
void add (std::string const& attrName, Value const& sub);
uint8_t* add (std::string const& attrName, Value const& sub);
// Add a subvalue into an object from a Slice:
uint8_t* add (std::string const& attrName, Slice const& sub);
// Add a subvalue into an object from a ValuePair:
uint8_t* add (std::string const& attrName, ValuePair const& sub);
// Add a subvalue into an array from a Value:
void add (Value const& sub);
uint8_t* add (Value const& sub);
// Add a slice to an array
uint8_t* add (Slice const& sub);
// Add a subvalue into an array from a ValuePair:
uint8_t* add (ValuePair const& sub);
// Seal the innermost array or object:
void close ();
@ -365,6 +365,46 @@ namespace arangodb {
private:
template<typename T>
uint8_t* addInternal (T const& sub) {
if (! _stack.empty()) {
ValueLength& tos = _stack.back();
if (_start[tos] != 0x06 && _start[tos] != 0x0b) {
throw Exception(Exception::BuilderNeedOpenObject);
}
if (_start[tos] == 0x0b) { // Object
if (! _attrWritten && ! sub.isString()) {
throw Exception(Exception::BuilderNeedOpenObject);
}
if (! _attrWritten) {
reportAdd(tos);
}
_attrWritten = ! _attrWritten;
}
else { // Array
reportAdd(tos);
}
}
return set(sub);
}
template<typename T>
uint8_t* addInternal (std::string const& attrName, T const& sub) {
if (_attrWritten) {
throw Exception(Exception::InternalError, "Attribute name already written");
}
if (! _stack.empty()) {
ValueLength& tos = _stack.back();
if (_start[tos] != 0x06 &&
_start[tos] != 0x0b) {
throw Exception(Exception::BuilderNeedOpenObject);
}
reportAdd(tos);
}
set(Value(attrName, ValueType::String));
return set(sub);
}
void addCompoundValue (uint8_t type) {
reserveSpace(9);
// an array is started:
@ -378,10 +418,12 @@ namespace arangodb {
_pos += 8; // Will be filled later with bytelength and nr subs
}
void set (Value const& item);
uint8_t* set (Value const& item);
uint8_t* set (ValuePair const& pair);
uint8_t* set (Slice const& item);
void reportAdd (ValueLength base) {
size_t depth = _stack.size() - 1;
_index[depth].push_back(_pos - base);

112
3rdParty/velocypack/include/velocypack/Collection.h vendored Normal file
View File

@ -0,0 +1,112 @@
////////////////////////////////////////////////////////////////////////////////
/// @brief Library to build up VPack documents.
///
/// DISCLAIMER
///
/// Copyright 2015 ArangoDB 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 Max Neunhoeffer
/// @author Jan Steemann
/// @author Copyright 2015, ArangoDB GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#ifndef VELOCYPACK_COLLECTION_H
#define VELOCYPACK_COLLECTION_H 1
#include <functional>
#include <string>
#include <unordered_set>
#include <vector>
#include "velocypack/velocypack-common.h"
#include "velocypack/Builder.h"
#include "velocypack/Slice.h"
namespace arangodb {
namespace velocypack {
class Collection {
public:
Collection () = delete;
static void forEach (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb);
static void forEach (Slice const* slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
return forEach(*slice, cb);
}
static Builder filter (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb);
static Builder filter (Slice const* slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
return filter(*slice, cb);
}
static Builder map (Slice const& slice, std::function<Value(Slice const&, ValueLength)> const& cb);
static Builder map (Slice const* slice, std::function<Value(Slice const&, ValueLength)> const& cb) {
return map(*slice, cb);
}
static Slice find (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb);
static Slice find (Slice const* slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
return find(*slice, cb);
}
static bool contains (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb);
static bool contains (Slice const* slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
return contains(*slice, cb);
}
static bool all (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb);
static bool all (Slice const* slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
return all(*slice, cb);
}
static bool any (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb);
static bool any (Slice const* slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
return any(*slice, cb);
}
static std::vector<std::string> keys (Slice const& slice);
static std::vector<std::string> keys (Slice const* slice) {
return keys(*slice);
}
static void keys (Slice const& slice, std::vector<std::string>& result);
static void keys (Slice const* slice, std::vector<std::string>& result) {
return keys(*slice, result);
}
static void keys (Slice const& slice, std::unordered_set<std::string>& result);
static void keys (Slice const* slice, std::unordered_set<std::string>& result) {
return keys(*slice, result);
}
};
} // namespace arangodb::velocypack
} // namespace arangodb
#endif

23
3rdParty/velocypack/include/velocypack/Dumper.h vendored
View File

@ -55,15 +55,15 @@ namespace arangodb {
Options options;
enum UnsupportedTypeStrategy {
StrategyNullify,
StrategyFail
StrategyNullifyUnsupportedType,
StrategyFailOnUnsupportedType
};
Dumper (Dumper const&) = delete;
Dumper& operator= (Dumper const&) = delete;
Dumper (T& buffer, UnsupportedTypeStrategy strategy = StrategyFail)
: _buffer(&buffer), _strategy(strategy), _indentation(0) {
Dumper (T& buffer, UnsupportedTypeStrategy strategy = StrategyFailOnUnsupportedType)
: strategy(strategy), _buffer(&buffer), _indentation(0) {
}
~Dumper () {
@ -99,24 +99,24 @@ namespace arangodb {
internalDump(slice, nullptr);
}
static void Dump (Slice const& slice, T& buffer, UnsupportedTypeStrategy strategy = StrategyFail) {
static void Dump (Slice const& slice, T& buffer, UnsupportedTypeStrategy strategy = StrategyFailOnUnsupportedType) {
Dumper dumper(buffer, strategy);
dumper.dump(slice);
}
static void Dump (Slice const* slice, T& buffer, UnsupportedTypeStrategy strategy = StrategyFail) {
static void Dump (Slice const* slice, T& buffer, UnsupportedTypeStrategy strategy = StrategyFailOnUnsupportedType) {
Dumper dumper(buffer, strategy);
dumper.dump(slice);
}
static T Dump (Slice const& slice, UnsupportedTypeStrategy strategy = StrategyFail) {
static T Dump (Slice const& slice, UnsupportedTypeStrategy strategy = StrategyFailOnUnsupportedType) {
T buffer;
Dumper dumper(buffer, strategy);
dumper.dump(slice);
return buffer;
}
static T Dump (Slice const* slice, UnsupportedTypeStrategy strategy = StrategyFail) {
static T Dump (Slice const* slice, UnsupportedTypeStrategy strategy = StrategyFailOnUnsupportedType) {
T buffer;
Dumper dumper(buffer, strategy);
dumper.dump(slice);
@ -473,13 +473,16 @@ namespace arangodb {
}
void handleUnsupportedType (Slice const*) {
if (_strategy == StrategyNullify) {
if (strategy == StrategyNullifyUnsupportedType) {
_buffer->append("null", 4);
return;
}
throw Exception(Exception::NoJsonEquivalent);
}
public:
UnsupportedTypeStrategy strategy;
private:
@ -487,8 +490,6 @@ namespace arangodb {
std::function<bool(T*, Slice const*, Slice const*)> _callback;
UnsupportedTypeStrategy _strategy;
int _indentation;
};

2
3rdParty/velocypack/include/velocypack/Exception.h vendored
View File

@ -109,7 +109,7 @@ namespace arangodb {
case BuilderObjectNotSealed:
return "Object not sealed";
case BuilderNeedOpenObject:
return "Need open array or object for close() call";
return "Need open Array or Object for close() call";
case BuilderUnexpectedType:
return "Unexpected type";
case BuilderUnexpectedValue:

144
3rdParty/velocypack/include/velocypack/Iterator.h vendored Normal file
View File

@ -0,0 +1,144 @@
////////////////////////////////////////////////////////////////////////////////
/// @brief Library to build up VPack documents.
///
/// DISCLAIMER
///
/// Copyright 2015 ArangoDB 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 Max Neunhoeffer
/// @author Jan Steemann
/// @author Copyright 2015, ArangoDB GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#ifndef VELOCYPACK_ITERATOR_H
#define VELOCYPACK_ITERATOR_H 1
#include "velocypack/velocypack-common.h"
#include "velocypack/Exception.h"
#include "velocypack/Slice.h"
#include "velocypack/ValueType.h"
namespace arangodb {
namespace velocypack {
class ArrayIterator {
public:
ArrayIterator () = delete;
ArrayIterator (Slice const& slice)
: _slice(slice), _size(_slice.length()), _position(0) {
if (slice.type() != ValueType::Array) {
throw Exception(Exception::InvalidValueType, "Expecting Array slice");
}
}
ArrayIterator (ArrayIterator const& other)
: _slice(other._slice), _size(other._size), _position(0) {
}
ArrayIterator& operator= (ArrayIterator const& other) {
_slice = other._slice;
_size = other._size;
_position = 0;
return *this;
}
inline bool valid () const throw() {
return (_position < _size);
}
inline Slice value () const {
if (_position >= _size) {
throw Exception(Exception::IndexOutOfBounds);
}
return _slice.at(_position);
}
inline bool next () throw() {
++_position;
return valid();
}
private:
Slice _slice;
ValueLength _size;
ValueLength _position;
};
class ObjectIterator {
public:
ObjectIterator () = delete;
ObjectIterator (Slice const& slice)
: _slice(slice), _size(_slice.length()), _position(0) {
if (slice.type() != ValueType::Object) {
throw Exception(Exception::InvalidValueType, "Expecting Object slice");
}
}
ObjectIterator (ObjectIterator const& other)
: _slice(other._slice), _size(other._size), _position(0) {
}
ObjectIterator& operator= (ObjectIterator const& other) {
_slice = other._slice;
_size = other._size;
_position = 0;
return *this;
}
inline bool valid () const throw() {
return (_position < _size);
}
inline Slice key () const {
if (_position >= _size) {
throw Exception(Exception::IndexOutOfBounds);
}
return _slice.keyAt(_position);
}
inline Slice value () const {
if (_position >= _size) {
throw Exception(Exception::IndexOutOfBounds);
}
return _slice.valueAt(_position);
}
inline bool next () throw() {
++_position;
return valid();
}
private:
Slice _slice;
ValueLength _size;
ValueLength _position;
};
} // namespace arangodb::velocypack
} // namespace arangodb
#endif

22
3rdParty/velocypack/include/velocypack/Slice.h vendored
View File

@ -30,6 +30,7 @@
#include <cstdint>
#include <cstring>
#include <string>
#include <unordered_set>
#include <vector>
#include <ostream>
#include <functional>
@ -411,27 +412,6 @@ namespace arangodb {
}
}
std::vector<std::string> keys () const {
std::vector<std::string> keys;
ValueLength const n = length();
keys.reserve(n);
for (ValueLength i = 0; i < n; ++i) {
keys.emplace_back(keyAt(i).copyString());
}
return keys;
}
void keys (std::vector<std::string>& keys) const {
ValueLength const n = length();
if (! keys.empty()) {
keys.clear();
}
keys.reserve(n);
for (ValueLength i = 0; i < n; ++i) {
keys.emplace_back(keyAt(i).copyString());
}
}
// return the pointer to the data for an External object
char const* getExternal () const {
return extractValue<char const*>();

15
3rdParty/velocypack/include/velocypack/Value.h vendored
View File

@ -106,6 +106,21 @@ namespace arangodb {
: _valueType(t), _cType(CType::UInt64) {
_value.u = u;
}
#ifdef __APPLE__
// MacOS uses the following typedefs:
// - typedef unsigned int uint32_t;
// - typedef unsigned long long uint64_t;
// - typedef unsigned long size_t;
// not defining the method for type unsigned long will prevent
// users from constructing Value objects with a size_t input
// however, defining the method on Linux and with MSVC will lead
// to ambiguous overloads, so this is restricted to __APPLE__ only
explicit Value (unsigned long i, ValueType t = ValueType::Int)
: _valueType(t), _cType(CType::UInt64) {
_value.i = static_cast<uint64_t>(i);
}
#endif
explicit Value (std::string const& s, ValueType t = ValueType::String)
: _valueType(t), _cType(CType::String) {
_value.s = &s;

4
3rdParty/velocypack/include/velocypack/ValueType.h vendored
View File

@ -27,6 +27,8 @@
#ifndef VELOCYPACK_VALUETYPE_H
#define VELOCYPACK_VALUETYPE_H
#include <ostream>
#include "velocypack-common.h"
namespace arangodb {
@ -57,4 +59,6 @@ namespace arangodb {
} // namespace arangodb::velocypack
} // namespace arangodb
std::ostream& operator<< (std::ostream&, arangodb::velocypack::ValueType);
#endif

3
3rdParty/velocypack/include/velocypack/velocypack-aliases.h vendored
View File

@ -29,10 +29,13 @@
#include "velocypack/vpack.h"
using VPackArrayIterator = arangodb::velocypack::ArrayIterator;
using VPackBufferDumper = arangodb::velocypack::BufferDumper;
using VPackBuilder = arangodb::velocypack::Builder;
using VPackCharBuffer = arangodb::velocypack::CharBuffer;
using VPackCollection = arangodb::velocypack::Collection;
using VPackException = arangodb::velocypack::Exception;
using VPackObjectIterator = arangodb::velocypack::ObjectIterator;
using VPackOptions = arangodb::velocypack::Options;
using VPackParser = arangodb::velocypack::Parser;
using VPackStringDumper = arangodb::velocypack::StringDumper;

2
3rdParty/velocypack/include/velocypack/vpack.h vendored
View File

@ -29,8 +29,10 @@
#include "velocypack/velocypack-common.h"
#include "velocypack/Builder.h"
#include "velocypack/Collection.h"
#include "velocypack/Dump.h"
#include "velocypack/Exception.h"
#include "velocypack/Iterator.h"
#include "velocypack/Options.h"
#include "velocypack/Parser.h"
#include "velocypack/Slice.h"

93
3rdParty/velocypack/src/Builder.cpp vendored
View File

@ -295,7 +295,8 @@ void Builder::close () {
// Intentionally leave _index[depth] intact to avoid future allocs!
}
void Builder::set (Value const& item) {
uint8_t* Builder::set (Value const& item) {
auto const oldPos = _start + _pos;
auto ctype = item.cType();
// This method builds a single further VPack item at the current
@ -521,6 +522,15 @@ void Builder::set (Value const& item) {
throw Exception(Exception::BuilderUnexpectedType, "Cannot set a ValueType::Custom with this method");
}
}
return oldPos;
}
uint8_t* Builder::set (Slice const& item) {
ValueLength const l = item.byteSize();
reserveSpace(l);
memcpy(_start + _pos, item.start(), l);
_pos += l;
return _start + _pos - l;
}
uint8_t* Builder::set (ValuePair const& pair) {
@ -615,80 +625,27 @@ void Builder::checkAttributeUniqueness (Slice const obj) const {
}
}
void Builder::add (std::string const& attrName, Value const& sub) {
if (_attrWritten) {
throw Exception(Exception::InternalError, "Attribute name already written");
}
if (! _stack.empty()) {
ValueLength& tos = _stack.back();
if (_start[tos] != 0x06 &&
_start[tos] != 0x0b) {
throw Exception(Exception::BuilderNeedOpenObject);
}
reportAdd(tos);
}
set(Value(attrName, ValueType::String));
set(sub);
uint8_t* Builder::add (std::string const& attrName, Value const& sub) {
return addInternal<Value>(attrName, sub);
}
uint8_t* Builder::add (std::string const& attrName, Slice const& sub) {
return addInternal<Slice>(attrName, sub);
}
uint8_t* Builder::add (std::string const& attrName, ValuePair const& sub) {
if (_attrWritten) {
throw Exception(Exception::InternalError, "Attribute name already written");
}
if (! _stack.empty()) {
ValueLength& tos = _stack.back();
if (_start[tos] != 0x06 &&
_start[tos] != 0x0b) {
throw Exception(Exception::BuilderNeedOpenObject);
}
reportAdd(tos);
}
set(Value(attrName, ValueType::String));
return set(sub);
return addInternal<ValuePair>(attrName, sub);
}
void Builder::add (Value const& sub) {
if (! _stack.empty()) {
ValueLength& tos = _stack.back();
if (_start[tos] != 0x06 && _start[tos] != 0x0b) {
// no array or object
throw Exception(Exception::BuilderNeedOpenObject);
}
if (_start[tos] == 0x0b) { // object
if (! _attrWritten && ! sub.isString()) {
throw Exception(Exception::BuilderNeedOpenObject);
}
if (! _attrWritten) {
reportAdd(tos);
}
_attrWritten = ! _attrWritten;
}
else {
reportAdd(tos);
}
}
set(sub);
uint8_t* Builder::add (Value const& sub) {
return addInternal<Value>(sub);
}
uint8_t* Builder::add (Slice const& sub) {
return addInternal<Slice>(sub);
}
uint8_t* Builder::add (ValuePair const& sub) {
if (! _stack.empty()) {
ValueLength& tos = _stack.back();
if (_start[tos] != 0x06 && _start[tos] != 0x0b) {
throw Exception(Exception::BuilderNeedOpenObject);
}
if (_start[tos] == 0x06) { // object
if (! _attrWritten && ! sub.isString()) {
throw Exception(Exception::BuilderNeedOpenObject);
}
if (! _attrWritten) {
reportAdd(tos);
}
_attrWritten = ! _attrWritten;
}
else {
reportAdd(tos);
}
}
return set(sub);
return addInternal<ValuePair>(sub);
}

179
3rdParty/velocypack/src/Collection.cpp vendored Normal file
View File

@ -0,0 +1,179 @@
////////////////////////////////////////////////////////////////////////////////
/// @brief Library to build up VPack documents.
///
/// DISCLAIMER
///
/// Copyright 2015 ArangoDB 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 Max Neunhoeffer
/// @author Jan Steemann
/// @author Copyright 2015, ArangoDB GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include "velocypack/velocypack-common.h"
#include "velocypack/Collection.h"
#include "velocypack/Iterator.h"
#include "velocypack/Slice.h"
#include "velocypack/Value.h"
#include "velocypack/ValueType.h"
using namespace arangodb::velocypack;
void Collection::forEach (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
ArrayIterator it(slice);
ValueLength index = 0;
while (it.valid()) {
if (! cb(it.value(), index)) {
// abort
return;
}
it.next();
++index;
}
}
Builder Collection::filter (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
// construct a new Array
Builder b;
b.add(Value(ValueType::Array));
ArrayIterator it(slice);
ValueLength index = 0;
while (it.valid()) {
Slice s = it.value();
if (cb(s, index)) {
b.add(s);
}
it.next();
++index;
}
b.close();
return b;
}
Builder Collection::map (Slice const& slice, std::function<Value(Slice const&, ValueLength)> const& cb) {
// construct a new Array
Builder b;
b.add(Value(ValueType::Array));
ArrayIterator it(slice);
ValueLength index = 0;
while (it.valid()) {
b.add(cb(it.value(), index));
it.next();
++index;
}
b.close();
return b;
}
Slice Collection::find (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
ArrayIterator it(slice);
ValueLength index = 0;
while (it.valid()) {
Slice s = it.value();
if (cb(s, index)) {
return s;
}
it.next();
++index;
}
return Slice();
}
bool Collection::contains (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
ArrayIterator it(slice);
ValueLength index = 0;
while (it.valid()) {
Slice s = it.value();
if (cb(s, index)) {
return true;
}
it.next();
++index;
}
return false;
}
bool Collection::all (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
ArrayIterator it(slice);
ValueLength index = 0;
while (it.valid()) {
Slice s = it.value();
if (! cb(s, index)) {
return false;
}
it.next();
++index;
}
return true;
}
bool Collection::any (Slice const& slice, std::function<bool(Slice const&, ValueLength)> const& cb) {
ArrayIterator it(slice);
ValueLength index = 0;
while (it.valid()) {
Slice s = it.value();
if (cb(s, index)) {
return true;
}
it.next();
++index;
}
return false;
}
std::vector<std::string> Collection::keys (Slice const& slice) {
std::vector<std::string> result;
keys(slice, result);
return result;
}
void Collection::keys (Slice const& slice, std::vector<std::string>& result) {
// pre-allocate result vector
result.reserve(slice.length());
ObjectIterator it(slice);
while (it.valid()) {
result.emplace_back(it.key().copyString());
it.next();
}
}
void Collection::keys (Slice const& slice, std::unordered_set<std::string>& result) {
ObjectIterator it(slice);
while (it.valid()) {
result.emplace(it.key().copyString());
it.next();
}
}

3
3rdParty/velocypack/src/Slice.cpp vendored
View File

@ -25,6 +25,7 @@
////////////////////////////////////////////////////////////////////////////////
#include "velocypack/velocypack-common.h"
#include "velocypack/Builder.h"
#include "velocypack/Dump.h"
#include "velocypack/Slice.h"
#include "velocypack/ValueType.h"
@ -144,7 +145,7 @@ unsigned int const Slice::FirstSubMap[256] = {
8, // 0x12, object with unsorted index table
0
};
std::string Slice::toString () const {
return StringPrettyDumper::Dump(this);
}

5
3rdParty/velocypack/src/ValueType.cpp vendored
View File

@ -51,3 +51,8 @@ char const* arangodb::velocypack::ValueTypeName (ValueType type) {
return "unknown";
}
std::ostream& operator<< (std::ostream& stream, ValueType type) {
stream << ValueTypeName(type);
return stream;
}

1
lib/CMakeLists.txt
View File

@ -53,6 +53,7 @@ include_directories(../3rdParty/velocypack/include)
SET(LIB_ARANGO_VPACK
../3rdParty/velocypack/src/Builder.cpp
../3rdParty/velocypack/src/Collection.cpp
../3rdParty/velocypack/src/Exception.cpp
../3rdParty/velocypack/src/Parser.cpp
../3rdParty/velocypack/src/Slice.cpp

3
lib/Makefile.files
View File

@ -59,7 +59,7 @@ lib_libarango_a_SOURCES = \
lib/Basics/SpinLocker.cpp \
lib/Basics/ssl-helper.cpp \
lib/Basics/string-buffer.cpp \
lib/Basics/stringBufferAdapter.cpp \
lib/Basics/StringBufferAdapter.cpp \
lib/Basics/StringUtils.cpp \
lib/Basics/structures.cpp \
lib/Basics/system-functions.cpp \
@ -110,6 +110,7 @@ endif
lib_libarango_a_SOURCES += \
3rdParty/velocypack/src/Builder.cpp \
3rdParty/velocypack/src/Collection.cpp \
3rdParty/velocypack/src/Exception.cpp \
3rdParty/velocypack/src/Parser.cpp \
3rdParty/velocypack/src/Slice.cpp \