lang/c++/api/Schema.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
 *
 *     http://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_Schema_hh__ 
#define avro_Schema_hh__ 

#include "NodeImpl.hh"

/// \file
///
/// Schemas for representing all the avro types.  The compound schema objects
/// allow composition from other schemas.
///

namespace avro {

class ValidSchema;


/// The root Schema object is a base class.  Nobody constructs this class directly.

class Schema 
{
  public:

    virtual ~Schema();

    Type type() const {
        return node_->type();
    }

    const NodePtr &root() const {
        return node_;
    }

    NodePtr &root() {
        return node_;
    }

  protected:

    friend void compileJsonSchema(std::istream &is, ValidSchema &schema);

    Schema();
    explicit Schema(const NodePtr &node);
    explicit Schema(Node *node);

    NodePtr node_;
};

class NullSchema : public Schema
{
  public:
    NullSchema(): Schema(new NodePrimitive(AVRO_NULL)) {}
};

class BoolSchema : public Schema
{
  public:
    BoolSchema(): Schema(new NodePrimitive(AVRO_BOOL)) {}
};

class IntSchema : public Schema
{
  public:
    IntSchema(): Schema(new NodePrimitive(AVRO_INT)) {}
};

class LongSchema : public Schema
{
  public:
    LongSchema(): Schema(new NodePrimitive(AVRO_LONG)) {}
};

class FloatSchema : public Schema
{
  public:
    FloatSchema(): Schema(new NodePrimitive(AVRO_FLOAT)) {}
};

class DoubleSchema : public Schema
{
  public:
    DoubleSchema(): Schema(new NodePrimitive(AVRO_DOUBLE)) {}
};

class StringSchema : public Schema
{
  public:
    StringSchema(): Schema(new NodePrimitive(AVRO_STRING)) {}
};

class BytesSchema : public Schema
{
  public:
    BytesSchema(): Schema(new NodePrimitive(AVRO_BYTES)) {}
};

class RecordSchema : public Schema
{
  public:

    RecordSchema(const std::string &name);
    void addField(const std::string &name, const Schema &fieldSchema);
};

class EnumSchema : public Schema
{
  public:

    EnumSchema(const std::string &name);
    void addSymbol(const std::string &symbol);
};

class ArraySchema : public Schema
{
  public:

    ArraySchema(const Schema &itemsSchema);
};

class MapSchema : public Schema
{
  public:

    MapSchema(const Schema &valuesSchema);
};


class UnionSchema : public Schema
{
  public:

    UnionSchema();
    void addType(const Schema &typeSchema);
};

class FixedSchema : public Schema
{
  public:

    FixedSchema(int size, const std::string &name);
};

} // namespace avro

#endif