1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include "value.h"
#include "nix_value.h"
#include "resolved_symbol.h"
#include "empty_value_factory.h"
#include "basic_value_factory.h"
#include "external_data_value_factory.h"
#include <vespa/vespalib/data/simple_buffer.h>
#include "json_format.h"
namespace vespalib::slime {
bool
Value::valid() const {
return (this != NixValue::invalid());
}
Type
Value::type() const {
return NIX::instance;
}
size_t
Value::children() const {
return 0;
}
size_t
Value::entries() const {
return 0;
}
size_t
Value::fields() const {
return 0;
}
// default NOPs for leaf values
Cursor &
Value::addLeaf(const ValueFactory &) { return *NixValue::invalid(); }
Cursor &
Value::setLeaf(Symbol, const ValueFactory &) { return *NixValue::invalid(); }
Cursor &
Value::setLeaf(Memory, const ValueFactory &) { return *NixValue::invalid(); }
// default values for accessors
bool
Value::asBool() const { return false; }
int64_t
Value::asLong() const { return 0; }
double
Value::asDouble() const { return 0.0; }
Memory
Value::asString() const { return Memory(); }
Memory
Value::asData() const { return Memory(); }
Cursor &
Value::operator[](size_t) const { return *NixValue::invalid(); }
Cursor &
Value::operator[](Symbol) const { return *NixValue::invalid(); }
Cursor &
Value::operator[](Memory) const { return *NixValue::invalid(); }
// default NOPs for traversal
void
Value::traverse(ArrayTraverser &) const {}
void
Value::traverse(ObjectSymbolTraverser &) const {}
void
Value::traverse(ObjectTraverser &) const {}
// generate string representation
vespalib::string
Value::toString() const
{
SimpleBuffer buf;
slime::JsonFormat::encode(*this, buf, false);
return buf.get().make_string();
}
// 7 x add
Cursor &
Value::addNix() { return addLeaf(NixValueFactory()); }
Cursor &
Value::addBool(bool bit) { return addLeaf(BoolValueFactory(bit)); }
Cursor &
Value::addLong(int64_t l) { return addLeaf(LongValueFactory(l)); }
Cursor &
Value::addDouble(double d) { return addLeaf(DoubleValueFactory(d)); }
Cursor &
Value::addString(Memory str) { return addLeaf(StringValueFactory(str)); }
Cursor &
Value::addData(Memory data) { return addLeaf(DataValueFactory(data)); }
Cursor &
Value::addData(ExternalMemory::UP data) { return addLeaf(ExternalDataValueFactory(std::move(data))); }
// 7 x set (with numeric symbol id)
Cursor &
Value::setNix(Symbol sym) { return setLeaf(sym, NixValueFactory()); }
Cursor &
Value::setBool(Symbol sym, bool bit) { return setLeaf(sym, BoolValueFactory(bit)); }
Cursor &
Value::setLong(Symbol sym, int64_t l) { return setLeaf(sym, LongValueFactory(l)); }
Cursor &
Value::setDouble(Symbol sym, double d) { return setLeaf(sym, DoubleValueFactory(d)); }
Cursor &
Value::setString(Symbol sym, Memory str) { return setLeaf(sym, StringValueFactory(str)); }
Cursor &
Value::setData(Symbol sym, Memory data) { return setLeaf(sym, DataValueFactory(data)); }
Cursor &
Value::setData(Symbol sym, ExternalMemory::UP data) { return setLeaf(sym, ExternalDataValueFactory(std::move(data))); }
// 7 x set (with symbol name)
Cursor &
Value::setNix(Memory name) { return setLeaf(name, NixValueFactory()); }
Cursor &
Value::setBool(Memory name, bool bit) { return setLeaf(name, BoolValueFactory(bit)); }
Cursor &
Value::setLong(Memory name, int64_t l) { return setLeaf(name, LongValueFactory(l)); }
Cursor &
Value::setDouble(Memory name, double d) { return setLeaf(name, DoubleValueFactory(d)); }
Cursor &
Value::setString(Memory name, Memory str) { return setLeaf(name, StringValueFactory(str)); }
Cursor &
Value::setData(Memory name, Memory data) { return setLeaf(name, DataValueFactory(data)); }
Cursor &
Value::setData(Memory name, ExternalMemory::UP data) { return setLeaf(name, ExternalDataValueFactory(std::move(data))); }
// nop defaults for array/objects
Cursor &
Value::addArray(size_t) { return *NixValue::invalid(); }
Cursor &
Value::addObject() { return *NixValue::invalid(); }
Cursor &
Value::setArray(Symbol, size_t) { return *NixValue::invalid(); }
Cursor &
Value::setObject(Symbol) { return *NixValue::invalid(); }
Cursor &
Value::setArray(Memory, size_t) { return *NixValue::invalid(); }
Cursor &
Value::setObject(Memory) { return *NixValue::invalid(); }
Symbol
Value::resolve(Memory) { return Symbol(); }
} // namespace vespalib::slime
|
