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
|
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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
*
* https://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.
*/
#include <utility>
#include "Schema.hh"
#include "CustomAttributes.hh"
namespace avro {
RecordSchema::RecordSchema(const std::string &name) : Schema(new NodeRecord) {
node_->setName(Name(name));
}
void RecordSchema::addField(const std::string &name, const Schema &fieldSchema) {
const CustomAttributes emptyCustomAttribute;
addField(name, fieldSchema, emptyCustomAttribute);
}
void RecordSchema::addField(const std::string &name, const Schema &fieldSchema, const CustomAttributes &customFields) {
// add the name first. it will throw if the name is a duplicate, preventing
// the leaf from being added
node_->addName(name);
node_->addLeaf(fieldSchema.root());
node_->addCustomAttributesForField(customFields);
}
std::string RecordSchema::getDoc() const {
return node_->getDoc();
}
void RecordSchema::setDoc(const std::string &doc) {
node_->setDoc(doc);
}
EnumSchema::EnumSchema(const std::string &name) : Schema(new NodeEnum) {
node_->setName(Name(name));
}
void EnumSchema::addSymbol(const std::string &symbol) {
node_->addName(symbol);
}
ArraySchema::ArraySchema(const Schema &itemsSchema) : Schema(new NodeArray) {
node_->addLeaf(itemsSchema.root());
}
ArraySchema::ArraySchema(const ArraySchema &itemsSchema) : Schema(new NodeArray) {
node_->addLeaf(itemsSchema.root());
}
MapSchema::MapSchema(const Schema &valuesSchema) : Schema(new NodeMap) {
node_->addLeaf(valuesSchema.root());
}
MapSchema::MapSchema(const MapSchema &valuesSchema) : Schema(new NodeMap) {
node_->addLeaf(valuesSchema.root());
}
UnionSchema::UnionSchema() : Schema(new NodeUnion) {}
void UnionSchema::addType(const Schema &typeSchema) {
if (typeSchema.type() == AVRO_UNION) {
throw Exception("Cannot add unions to unions");
}
if (typeSchema.type() == AVRO_RECORD) {
// check for duplicate records
size_t types = node_->leaves();
for (size_t i = 0; i < types; ++i) {
const NodePtr &leaf = node_->leafAt(i);
// TODO, more checks?
if (leaf->type() == AVRO_RECORD && leaf->name() == typeSchema.root()->name()) {
throw Exception("Records in unions cannot have duplicate names");
}
}
}
node_->addLeaf(typeSchema.root());
}
FixedSchema::FixedSchema(int size, const std::string &name) : Schema(new NodeFixed) {
node_->setFixedSize(size);
node_->setName(Name(name));
}
SymbolicSchema::SymbolicSchema(const Name &name, const NodePtr &link) : Schema(new NodeSymbolic(HasName(name), link)) {
}
} // namespace avro
|
