GenericDatum.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_GenericDatum_hh__
#define avro_GenericDatum_hh__

#include <stdint.h>
#include <vector>
#include <map>
#include <string>

#include <boost/any.hpp>

#include "Node.hh"
#include "ValidSchema.hh"

namespace avro {
class AVRO_DECL GenericDatum {
    Type type_;
    boost::any value_;

    GenericDatum(Type t) : type_(t) { }

    template <typename T>
    GenericDatum(Type t, const T& v) : type_(t), value_(v) { }

    void init(const NodePtr& schema);
public:
    Type type() const {
        return type_;
    }

    template<typename T> const T& value() const {
        return *boost::any_cast<T>(&value_);
    }

    template<typename T> T& value() {
        return *boost::any_cast<T>(&value_);
    }

    bool isUnion() const { return type_ == AVRO_UNION; }

    size_t unionBranch() const;

    void selectBranch(size_t branch);

    GenericDatum() : type_(AVRO_NULL) { }

    GenericDatum(bool v) : type_(AVRO_BOOL), value_(v) { }

    GenericDatum(int32_t v) : type_(AVRO_INT), value_(v) { }

    GenericDatum(int64_t v) : type_(AVRO_LONG), value_(v) { }

    GenericDatum(float v) : type_(AVRO_FLOAT), value_(v) { }

    GenericDatum(double v) : type_(AVRO_DOUBLE), value_(v) { }

    GenericDatum(const std::string& v) : type_(AVRO_STRING), value_(v) { }

    GenericDatum(const std::vector<uint8_t>& v) :
        type_(AVRO_BYTES), value_(v) { }

    GenericDatum(const NodePtr& schema);

    template<typename T>
    GenericDatum(const NodePtr& schema, const T& v) :
        type_(schema->type()) {
        init(schema);
        value<T>() = v;
    }

    GenericDatum(const ValidSchema& schema);
};

class AVRO_DECL GenericContainer {
    NodePtr schema_;
    static void assertType(const NodePtr& schema, Type type);
protected:
    GenericContainer(Type type, const NodePtr& s) : schema_(s) {
        assertType(s, type);
    }

public:
    const NodePtr& schema() const {
        return schema_;
    }
};

class AVRO_DECL GenericUnion : public GenericContainer {
    size_t curBranch_;
    GenericDatum datum_;

public:
    GenericUnion(const NodePtr& schema) :
        GenericContainer(AVRO_UNION, schema), curBranch_(schema->leaves()) {
    }

    size_t currentBranch() const { return curBranch_; }

    void selectBranch(size_t branch) {
        if (curBranch_ != branch) {
            datum_ = GenericDatum(schema()->leafAt(branch));
            curBranch_ = branch;
        }
    }

    GenericDatum& datum() {
        return datum_;
    }

    const GenericDatum& datum() const {
        return datum_;
    }
};

class AVRO_DECL GenericRecord : public GenericContainer {
    std::vector<GenericDatum> fields_;
public:
    GenericRecord(const NodePtr& schema);

    size_t fieldCount() const {
        return fields_.size();
    }

    size_t fieldIndex(const std::string& name) const { 
        size_t index = 0;
        if (!schema()->nameIndex(name, index)) {
            throw Exception("Invalid field name: " + name);
        }
        return index;
    }

    bool hasField(const std::string& name) const {
        size_t index = 0;
        return schema()->nameIndex(name, index);
    }

    const GenericDatum& field(const std::string& name) const {
        return fieldAt(fieldIndex(name));
    }

    GenericDatum& field(const std::string& name) {
        return fieldAt(fieldIndex(name));
    }

    const GenericDatum& fieldAt(size_t pos) const {
        return fields_[pos];
    }

    GenericDatum& fieldAt(size_t pos) {
        return fields_[pos];
    }

    void setFieldAt(size_t pos, const GenericDatum& v) {
        // assertSameType(v, schema()->leafAt(pos));    
        fields_[pos] = v;
    }
};

class AVRO_DECL GenericArray : public GenericContainer {
public:
    typedef std::vector<GenericDatum> Value;

    GenericArray(const NodePtr& schema) : GenericContainer(AVRO_ARRAY, schema) {
    }

    const Value& value() const {
        return value_;
    }

    Value& value() {
        return value_;
    }
private:
    Value value_;
};

class AVRO_DECL GenericMap : public GenericContainer {
public:
    typedef std::vector<std::pair<std::string, GenericDatum> > Value;

    GenericMap(const NodePtr& schema) : GenericContainer(AVRO_MAP, schema) {
    }

    const Value& value() const {
        return value_;
    }

    Value& value() {
        return value_;
    }
private:
    Value value_;
};

class AVRO_DECL GenericEnum : public GenericContainer {
    size_t value_;

    static size_t index(const NodePtr& schema, const std::string& symbol) {
        size_t result;
        if (schema->nameIndex(symbol, result)) {
            return result;
        }
        throw Exception("No such symbol");
    }

public:
    GenericEnum(const NodePtr& schema) :
        GenericContainer(AVRO_ENUM, schema), value_(0) {
    }

    GenericEnum(const NodePtr& schema, const std::string& symbol) :
        GenericContainer(AVRO_ENUM, schema), value_(index(schema, symbol)) {
    }

    const std::string& symbol(size_t n) {
        if (n < schema()->names()) {
            return schema()->nameAt(n);
        }
        throw Exception("Not as many symbols");
    }

    size_t index(const std::string& symbol) const {
        return index(schema(), symbol);
    }

    size_t set(const std::string& symbol) {
        return value_ = index(symbol);
    }

    void set(size_t n) {
        if (n < schema()->names()) {
            value_ = n;
            return;
        }
        throw Exception("Not as many symbols");
    }

    size_t value() const {
        return value_;
    }

    const std::string& symbol() const {
        return schema()->nameAt(value_);
    }
};

class AVRO_DECL GenericFixed : public GenericContainer {
    std::vector<uint8_t> value_;
public:
    GenericFixed(const NodePtr& schema) : GenericContainer(AVRO_FIXED, schema) {
        value_.resize(schema->fixedSize());
    }

    GenericFixed(const NodePtr& schema, const std::vector<uint8_t>& v) :
        GenericContainer(AVRO_FIXED, schema), value_(v) { }

    const std::vector<uint8_t>& value() const {
        return value_;
    }

    std::vector<uint8_t>& value() {
        return value_;
    }
};

inline size_t GenericDatum::unionBranch() const {
    return boost::any_cast<GenericUnion>(&value_)->currentBranch();
}

inline void GenericDatum::selectBranch(size_t branch) {
    boost::any_cast<GenericUnion>(&value_)->selectBranch(branch);
}

}   // namespace avro
#endif // avro_GenericDatum_hh__