CompilerNode.hh

#ifndef avro_CompilerNode_hh__
#define avro_CompilerNode_hh__

#include "NodeConcepts.hh"
#include "Node.hh"

namespace avro {



class CompilerNode
{

  public:

    enum AttributeType {
        NONE,
        FIELDS,
        VALUES,
        ITEMS,
        TYPES
    };

    CompilerNode() :
        type_(AVRO_NUM_TYPES),
        attributeType_(NONE)
    {}

    CompilerNode(const CompilerNode &rhs) :
        type_(rhs.type_),
        attributeType_(rhs.attributeType_)
    {}


    AttributeType attributeType() const {
        return attributeType_;
    }

    void setAttributeType(AttributeType attributeType) {
        attributeType_ = attributeType;
    }

    Type type() const {
        return type_;
    }

    void setType(Type type) {
        type_ = type;
    } 

    void addNode(const NodePtr &node) {
        switch(attributeType_) {
          case FIELDS:
            fieldsAttribute_.add(node);
            break;
          case VALUES:
            valuesAttribute_.add(node);
            break;
          case ITEMS:
            itemsAttribute_.add(node);
            break;
          case TYPES:
            typesAttribute_.add(node);
            break;

          default:
            throw Exception("Can't add node if the attribute type is not set");
        }
    }


    // attribute used by records, enums, symbols, and fixed:
    concepts::SingleAttribute<std::string> nameAttribute_;

    // attribute used by fixed:
    concepts::SingleAttribute<int> sizeAttribute_;

    // attributes used by records:
    concepts::MultiAttribute<NodePtr>     fieldsAttribute_;
    concepts::MultiAttribute<std::string> fieldsNamesAttribute_;

    // attribute used by enums:
    concepts::MultiAttribute<std::string> symbolsAttribute_;

    // attribute used by arrays:
    concepts::SingleAttribute<NodePtr> itemsAttribute_;

    // attribute used by maps:
    concepts::SingleAttribute<NodePtr> valuesAttribute_;

    // attribute used by unions:
    concepts::MultiAttribute<NodePtr> typesAttribute_;

    Type type_;
    AttributeType attributeType_;

};

NodePtr nodeFromCompilerNode(CompilerNode &compilerNode);

} // namespace avro

#endif