Avro C++
Node.hh
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the
7  * "License"); you may not use this file except in compliance
8  * with the License. You may obtain a copy of the License at
9  *
10  * https://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 
19 #ifndef avro_Node_hh__
20 #define avro_Node_hh__
21 
22 #include "Config.hh"
23 
24 #include <boost/noncopyable.hpp>
25 #include <cassert>
26 #include <memory>
27 #include <utility>
28 
29 #include "CustomFields.hh"
30 #include "Exception.hh"
31 #include "LogicalType.hh"
32 #include "SchemaResolution.hh"
33 #include "Types.hh"
34 
35 namespace avro {
36 
37 class Node;
38 class GenericDatum;
39 
40 using NodePtr = std::shared_ptr<Node>;
41 
42 class AVRO_DECL Name {
43  std::string ns_;
44  std::string simpleName_;
45 
46 public:
47  Name() = default;
48  explicit Name(const std::string &fullname);
49  Name(std::string simpleName, std::string ns) : ns_(std::move(ns)), simpleName_(std::move(simpleName)) { check(); }
50 
51  std::string fullname() const;
52  const std::string &ns() const { return ns_; }
53  const std::string &simpleName() const { return simpleName_; }
54 
55  void ns(std::string n) { ns_ = std::move(n); }
56  void simpleName(std::string n) { simpleName_ = std::move(n); }
57  void fullname(const std::string &n);
58 
59  bool operator<(const Name &n) const;
60  void check() const;
61  bool operator==(const Name &n) const;
62  bool operator!=(const Name &n) const { return !((*this) == n); }
63  void clear() {
64  ns_.clear();
65  simpleName_.clear();
66  }
67  explicit operator std::string() const {
68  return fullname();
69  }
70 };
71 
72 inline std::ostream &operator<<(std::ostream &os, const Name &n) {
73  return os << n.fullname();
74 }
75 
90 
91 class AVRO_DECL Node : private boost::noncopyable {
92 public:
93  explicit Node(Type type) : type_(type),
94  logicalType_(LogicalType::NONE),
95  locked_(false) {}
96 
97  virtual ~Node();
98 
99  Type type() const {
100  return type_;
101  }
102 
103  LogicalType logicalType() const {
104  return logicalType_;
105  }
106 
107  void setLogicalType(LogicalType logicalType);
108 
109  void lock() {
110  locked_ = true;
111  }
112 
113  bool locked() const {
114  return locked_;
115  }
116 
117  virtual bool hasName() const = 0;
118 
119  void setName(const Name &name) {
120  checkLock();
121  checkName(name);
122  doSetName(name);
123  }
124  virtual const Name &name() const = 0;
125 
126  virtual const std::string &getDoc() const = 0;
127  void setDoc(const std::string &doc) {
128  checkLock();
129  doSetDoc(doc);
130  }
131 
132  void addLeaf(const NodePtr &newLeaf) {
133  checkLock();
134  doAddLeaf(newLeaf);
135  }
136  virtual size_t leaves() const = 0;
137  virtual const NodePtr &leafAt(size_t index) const = 0;
138  virtual const GenericDatum &defaultValueAt(size_t index) {
139  throw Exception(boost::format("No default value at: %1%") % index);
140  }
141 
142  void addName(const std::string &name) {
143  checkLock();
144  checkName(Name(name));
145  doAddName(name);
146  }
147  virtual size_t names() const = 0;
148  virtual const std::string &nameAt(size_t index) const = 0;
149  virtual bool nameIndex(const std::string &name, size_t &index) const = 0;
150 
151  void setFixedSize(size_t size) {
152  checkLock();
153  doSetFixedSize(size);
154  }
155  virtual size_t fixedSize() const = 0;
156 
157  void addCustomAttributesForField(const CustomFields& customAttributes) {
158  checkLock();
159  doAddCustomAttribute(customAttributes);
160  }
161 
162  virtual bool isValid() const = 0;
163 
164  virtual SchemaResolution resolve(const Node &reader) const = 0;
165 
166  virtual void printJson(std::ostream &os, size_t depth) const = 0;
167 
168  virtual void printBasicInfo(std::ostream &os) const = 0;
169 
170  virtual void setLeafToSymbolic(size_t index, const NodePtr &node) = 0;
171 
172  // Serialize the default value GenericDatum g for the node contained
173  // in a record node.
174  virtual void printDefaultToJson(const GenericDatum &g, std::ostream &os,
175  size_t depth) const = 0;
176 
177 protected:
178  void checkLock() const {
179  if (locked()) {
180  throw Exception("Cannot modify locked schema");
181  }
182  }
183 
184  virtual void checkName(const Name &name) const {
185  name.check();
186  }
187 
188  virtual void doSetName(const Name &name) = 0;
189  virtual void doSetDoc(const std::string &name) = 0;
190 
191  virtual void doAddLeaf(const NodePtr &newLeaf) = 0;
192  virtual void doAddName(const std::string &name) = 0;
193  virtual void doSetFixedSize(size_t size) = 0;
194  virtual void doAddCustomAttribute(const CustomFields& customFields) = 0;
195 
196 private:
197  const Type type_;
198  LogicalType logicalType_;
199  bool locked_;
200 };
201 
202 } // namespace avro
203 
204 namespace std {
205 inline std::ostream &operator<<(std::ostream &os, const avro::Node &n) {
206  n.printJson(os, 0);
207  return os;
208 }
209 } // namespace std
210 
211 #endif
avro::Node
Node is the building block for parse trees.
Definition: Node.hh:91
avro::Name
Definition: Node.hh:42
avro::CustomFields
Definition: CustomFields.hh:31
avro::GenericDatum
Generic datum which can hold any Avro type.
Definition: GenericDatum.hh:61
avro::LogicalType
Definition: LogicalType.hh:28
avro
A bunch of templates and specializations for encoding and decoding specific types.
Definition: AvroParse.hh:30
avro::SchemaResolution
SchemaResolution
Definition: SchemaResolution.hh:26
avro::Type
Type
The "type" for the schema.
Definition: Types.hh:31
avro::Exception
Wrapper for std::runtime_error that provides convenience constructor for boost::format objects.
Definition: Exception.hh:31