Node.hh

/*
 * 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.
 */
 
#ifndef avro_Node_hh__
#define avro_Node_hh__
 
#include "Config.hh"
 
#include <boost/noncopyable.hpp>
#include <cassert>
#include <memory>
#include <utility>
 
#include "CustomFields.hh"
#include "Exception.hh"
#include "LogicalType.hh"
#include "SchemaResolution.hh"
#include "Types.hh"
 
namespace avro {
 
class Node;
class GenericDatum;
 
using NodePtr = std::shared_ptr<Node>;
 
class AVRO_DECL Name {
    std::string ns_;
    std::string simpleName_;
 
public:
    Name() = default;
    explicit Name(const std::string &fullname);
    Name(std::string simpleName, std::string ns) : ns_(std::move(ns)), simpleName_(std::move(simpleName)) { check(); }
 
    std::string fullname() const;
    const std::string &ns() const { return ns_; }
    const std::string &simpleName() const { return simpleName_; }
 
    void ns(std::string n) { ns_ = std::move(n); }
    void simpleName(std::string n) { simpleName_ = std::move(n); }
    void fullname(const std::string &n);
 
    bool operator<(const Name &n) const;
    void check() const;
    bool operator==(const Name &n) const;
    bool operator!=(const Name &n) const { return !((*this) == n); }
    void clear() {
        ns_.clear();
        simpleName_.clear();
    }
    explicit operator std::string() const {
        return fullname();
    }
};
 
inline std::ostream &operator<<(std::ostream &os, const Name &n) {
    return os << n.fullname();
}
 
 
class AVRO_DECL Node : private boost::noncopyable {
public:
    explicit Node(Type type) : type_(type),
                               logicalType_(LogicalType::NONE),
                               locked_(false) {}
 
    virtual ~Node();
 
    Type type() const {
        return type_;
    }
 
    LogicalType logicalType() const {
        return logicalType_;
    }
 
    void setLogicalType(LogicalType logicalType);
 
    void lock() {
        locked_ = true;
    }
 
    bool locked() const {
        return locked_;
    }
 
    virtual bool hasName() const = 0;
 
    void setName(const Name &name) {
        checkLock();
        checkName(name);
        doSetName(name);
    }
    virtual const Name &name() const = 0;
 
    virtual const std::string &getDoc() const = 0;
    void setDoc(const std::string &doc) {
        checkLock();
        doSetDoc(doc);
    }
 
    void addLeaf(const NodePtr &newLeaf) {
        checkLock();
        doAddLeaf(newLeaf);
    }
    virtual size_t leaves() const = 0;
    virtual const NodePtr &leafAt(size_t index) const = 0;
    virtual const GenericDatum &defaultValueAt(size_t index) {
        throw Exception(boost::format("No default value at: %1%") % index);
    }
 
    void addName(const std::string &name) {
        checkLock();
        checkName(Name(name));
        doAddName(name);
    }
    virtual size_t names() const = 0;
    virtual const std::string &nameAt(size_t index) const = 0;
    virtual bool nameIndex(const std::string &name, size_t &index) const = 0;
 
    void setFixedSize(size_t size) {
        checkLock();
        doSetFixedSize(size);
    }
    virtual size_t fixedSize() const = 0;
 
    void addCustomAttributesForField(const CustomFields& customAttributes) {
        checkLock();
        doAddCustomAttribute(customAttributes);
    }
 
    virtual bool isValid() const = 0;
 
    virtual SchemaResolution resolve(const Node &reader) const = 0;
 
    virtual void printJson(std::ostream &os, size_t depth) const = 0;
 
    virtual void printBasicInfo(std::ostream &os) const = 0;
 
    virtual void setLeafToSymbolic(size_t index, const NodePtr &node) = 0;
 
    // Serialize the default value GenericDatum g for the node contained
    // in a record node.
    virtual void printDefaultToJson(const GenericDatum &g, std::ostream &os,
                                    size_t depth) const = 0;
 
protected:
    void checkLock() const {
        if (locked()) {
            throw Exception("Cannot modify locked schema");
        }
    }
 
    virtual void checkName(const Name &name) const {
        name.check();
    }
 
    virtual void doSetName(const Name &name) = 0;
    virtual void doSetDoc(const std::string &name) = 0;
 
    virtual void doAddLeaf(const NodePtr &newLeaf) = 0;
    virtual void doAddName(const std::string &name) = 0;
    virtual void doSetFixedSize(size_t size) = 0;
    virtual void doAddCustomAttribute(const CustomFields& customFields) = 0;
 
private:
    const Type type_;
    LogicalType logicalType_;
    bool locked_;
};
 
} // namespace avro
 
namespace std {
inline std::ostream &operator<<(std::ostream &os, const avro::Node &n) {
    n.printJson(os, 0);
    return os;
}
} // namespace std
 
#endif