Node.hh

#ifndef avro_Node_hh__
#define avro_Node_hh__

#include <cassert>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>

#include "Exception.hh"
#include "Types.hh"
#include "SchemaResolution.hh"

namespace avro {

class Node;

typedef boost::shared_ptr<Node> NodePtr;



class Node : private boost::noncopyable
{
  public:

    Node(Type type) :
        type_(type),
        locked_(false)
    {}

    virtual ~Node();

    Type type() const {
        return type_;
    }

    void lock() {
        locked_ = true;
    }

    bool locked() const {
        return locked_;
    }

    virtual bool hasName() const = 0;

    void setName(const std::string &name) {
        checkLock();
        checkName(name);
        doSetName(name);
    }
    virtual const std::string &name() const = 0;

    void addLeaf(const NodePtr &newLeaf) {
        checkLock();
        doAddLeaf(newLeaf);
    }
    virtual size_t leaves() const = 0;
    virtual const NodePtr& leafAt(int index) const = 0;

    void addName(const std::string &name) {
        checkLock();
        checkName(name);
        doAddName(name);
    }
    virtual size_t names() const = 0;
    virtual const std::string &nameAt(int index) const = 0;
    virtual bool nameIndex(const std::string &name, size_t &index) const = 0;

    void setFixedSize(int size) {
        checkLock();
        doSetFixedSize(size);
    }
    virtual int fixedSize() const = 0;

    virtual bool isValid() const = 0;

    virtual SchemaResolution resolve(const Node &reader) const = 0;

    virtual void printJson(std::ostream &os, int depth) const = 0;

    virtual void printBasicInfo(std::ostream &os) const = 0;

  protected:

    friend class ValidSchema;

    virtual void setLeafToSymbolic(int index, const NodePtr &node) = 0;

    void checkLock() const {
        if(locked()) {
            throw Exception("Cannot modify locked schema");
        }
    }

    void checkName(const std::string &name) const;

    virtual void doSetName(const std::string &name) = 0;
    virtual void doAddLeaf(const NodePtr &newLeaf) = 0;
    virtual void doAddName(const std::string &name) = 0;
    virtual void doSetFixedSize(int size) = 0;

  private:

    const Type type_;
    bool locked_;
};

} // namespace avro

#endif