blob: 0ef108727e30019704a4b0958cc1501386b7733d (
plain) (
blame)
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
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include "primitivedatatype.h"
#include <vespa/document/fieldvalue/fieldvalues.h>
#include <vespa/vespalib/util/exceptions.h>
#include <vespa/vespalib/util/stringfmt.h>
#include <sstream>
#include <vespa/log/log.h>
LOG_SETUP(".document.datatype.primitivedatatype");
namespace document {
namespace {
const char *Int = "Int";
const char *Short = "Short";
const char *Float = "Float";
const char *String = "String";
const char *Raw = "Raw";
const char *Long = "Long";
const char *Double = "Double";
const char *Uri = "Uri";
const char *Byte = "Byte";
const char *Bool = "Bool";
const char *Predicate = "Predicate";
const char *Tensor = "Tensor";
const vespalib::stringref getTypeName(DataType::Type type) {
switch (type) {
case DataType::T_INT: return Int;
case DataType::T_SHORT: return Short;
case DataType::T_FLOAT: return Float;
case DataType::T_STRING: return String;
case DataType::T_RAW: return Raw;
case DataType::T_LONG: return Long;
case DataType::T_DOUBLE: return Double;
case DataType::T_URI: return Uri;
case DataType::T_BYTE: return Byte;
case DataType::T_BOOL: return Bool;
case DataType::T_PREDICATE: return Predicate;
case DataType::T_TENSOR: return Tensor;
default:
throw vespalib::IllegalArgumentException(vespalib::make_string(
"Type %i is not a primitive type", type), VESPA_STRLOC);
}
}
}
PrimitiveDataType::PrimitiveDataType(Type type)
: DataType(getTypeName(type), type)
{
}
FieldValue::UP
PrimitiveDataType::createFieldValue() const
{
switch (getId()) {
case T_INT: return IntFieldValue::make();
case T_SHORT: return ShortFieldValue::make();
case T_FLOAT: return FloatFieldValue::make();
case T_URI: return StringFieldValue::make();
case T_STRING: return StringFieldValue::make();
case T_RAW: return std::make_unique<RawFieldValue>();
case T_LONG: return LongFieldValue::make();
case T_DOUBLE: return DoubleFieldValue::make();
case T_BOOL: return BoolFieldValue::make();
case T_BYTE: return ByteFieldValue::make();
case T_PREDICATE: return std::make_unique<PredicateFieldValue>();
}
LOG_ABORT("getId() returned value out of range");
}
void
PrimitiveDataType::print(std::ostream& out, bool verbose, const std::string& indent) const
{
(void) verbose; (void) indent;
out << "PrimitiveDataType(" << getName() << ", id " << getId() << ")";
}
void
PrimitiveDataType::onBuildFieldPath(FieldPath &, vespalib::stringref rest) const
{
if ( ! rest.empty()) {
std::ostringstream ost;
ost << "Datatype " << *this << " does not support further recursive structure: " << rest;
throw vespalib::IllegalArgumentException(ost.str());
}
}
} // document
|
