path: root/contrib/libs/apache/avro/api/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 
 * 
 *     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_GenericDatum_hh__ 
#define avro_GenericDatum_hh__ 
 
#include <stdint.h> 
#include <vector> 
#include <map> 
#include <string> 
 
#if __cplusplus >= 201703L 
#include <any> 
#else 
#include "boost/any.hpp" 
#endif 
 
#include "LogicalType.hh" 
#include "Node.hh" 
#include "ValidSchema.hh" 
 
namespace avro { 
 
/** 
 * Generic datum which can hold any Avro type. The datum has a type 
 * and a value. The type is one of the Avro data types. The C++ type for 
 * value corresponds to the Avro type. 
 * \li An Avro <tt>null</tt> corresponds to no C++ type. It is illegal to 
 * to try to access values for <tt>null</tt>. 
 * \li Avro <tt>boolean</tt> maps to C++ <tt>bool</tt> 
 * \li Avro <tt>int</tt> maps to C++ <tt>int32_t</tt>. 
 * \li Avro <tt>long</tt> maps to C++ <tt>int64_t</tt>. 
 * \li Avro <tt>float</tt> maps to C++ <tt>float</tt>. 
 * \li Avro <tt>double</tt> maps to C++ <tt>double</tt>. 
 * \li Avro <tt>string</tt> maps to C++ <tt>std::string</tt>. 
 * \li Avro <tt>bytes</tt> maps to C++ <tt>std::vector&lt;uint_t&gt;</tt>. 
 * \li Avro <tt>fixed</tt> maps to C++ class <tt>GenericFixed</tt>. 
 * \li Avro <tt>enum</tt> maps to C++ class <tt>GenericEnum</tt>. 
 * \li Avro <tt>array</tt> maps to C++ class <tt>GenericArray</tt>. 
 * \li Avro <tt>map</tt> maps to C++ class <tt>GenericMap</tt>. 
 * \li There is no C++ type corresponding to Avro <tt>union</tt>. The 
 * object should have the C++ type corresponing to one of the constituent 
 * types of the union. 
 * 
 */ 
class AVRO_DECL GenericDatum { 
protected: 
    Type type_; 
    LogicalType logicalType_; 
#if __cplusplus >= 201703L 
    std::any value_; 
#else 
    boost::any value_; 
#endif 
 
    GenericDatum(Type t) 
        : type_(t), logicalType_(LogicalType::NONE) { } 
 
    GenericDatum(Type t, LogicalType logicalType) 
        : type_(t), logicalType_(logicalType) { } 
 
    template <typename T> 
    GenericDatum(Type t, LogicalType logicalType, const T& v) 
        : type_(t), logicalType_(logicalType), value_(v) { } 
 
    void init(const NodePtr& schema); 
public: 
    /** 
     * The avro data type this datum holds. 
     */ 
    Type type() const; 
 
    /** 
     * The avro logical type that augments the main data type this datum holds. 
     */ 
    LogicalType logicalType() const; 
 
    /** 
     * Returns the value held by this datum. 
     * T The type for the value. This must correspond to the 
     * avro type returned by type(). 
     */ 
    template<typename T> const T& value() const; 
 
    /** 
     * Returns the reference to the value held by this datum, which 
     * can be used to change the contents. Please note that only 
     * value can be changed, the data type of the value held cannot 
     * be changed. 
     * 
     * T The type for the value. This must correspond to the 
     * avro type returned by type(). 
     */ 
    template<typename T> T& value(); 
 
    /** 
     * Returns true if and only if this datum is a union. 
     */ 
    bool isUnion() const { return type_ == AVRO_UNION; } 
 
    /** 
     * Returns the index of the current branch, if this is a union. 
     * \sa isUnion(). 
     */ 
    size_t unionBranch() const; 
 
    /** 
     * Selects a new branch in the union if this is a union. 
     * \sa isUnion(). 
     */ 
    void selectBranch(size_t branch); 
 
    /// Makes a new AVRO_NULL datum. 
    GenericDatum() : type_(AVRO_NULL), logicalType_(LogicalType::NONE) { } 
 
    /// Makes a new AVRO_BOOL datum whose value is of type bool. 
    GenericDatum(bool v) 
        : type_(AVRO_BOOL), logicalType_(LogicalType::NONE), value_(v) { } 
 
    /// Makes a new AVRO_INT datum whose value is of type int32_t. 
    GenericDatum(int32_t v) 
        : type_(AVRO_INT), logicalType_(LogicalType::NONE), value_(v) { } 
 
    /// Makes a new AVRO_LONG datum whose value is of type int64_t. 
    GenericDatum(int64_t v) 
        : type_(AVRO_LONG), logicalType_(LogicalType::NONE), value_(v) { } 
 
    /// Makes a new AVRO_FLOAT datum whose value is of type float. 
    GenericDatum(float v) 
        : type_(AVRO_FLOAT), logicalType_(LogicalType::NONE), value_(v) { } 
 
    /// Makes a new AVRO_DOUBLE datum whose value is of type double. 
    GenericDatum(double v) 
        : type_(AVRO_DOUBLE), logicalType_(LogicalType::NONE), value_(v) { } 
 
    /// Makes a new AVRO_STRING datum whose value is of type std::string. 
    GenericDatum(const std::string& v) 
        : type_(AVRO_STRING), logicalType_(LogicalType::NONE), value_(v) { } 
 
    /// Makes a new AVRO_BYTES datum whose value is of type 
    /// std::vector<uint8_t>. 
    GenericDatum(const std::vector<uint8_t>& v) : 
        type_(AVRO_BYTES), logicalType_(LogicalType::NONE), value_(v) { } 
 
    /** 
     * Constructs a datum corresponding to the given avro type. 
     * The value will the appropriate default corresponding to the 
     * data type. 
     * \param schema The schema that defines the avro type. 
     */ 
    GenericDatum(const NodePtr& schema); 
 
    /** 
     * Constructs a datum corresponding to the given avro type and set 
     * the value. 
     * \param schema The schema that defines the avro type. 
     * \param v The value for this type. 
     */ 
    template<typename T> 
    GenericDatum(const NodePtr& schema, const T& v) : 
        type_(schema->type()), logicalType_(schema->logicalType()) { 
        init(schema); 
#if __cplusplus >= 201703L 
        *std::any_cast<T>(&value_) = v; 
#else 
        *boost::any_cast<T>(&value_) = v; 
#endif 
    } 
 
    /** 
     * Constructs a datum corresponding to the given avro type. 
     * The value will the appropriate default corresponding to the 
     * data type. 
     * \param schema The schema that defines the avro type. 
     */ 
    GenericDatum(const ValidSchema& schema); 
}; 
 
/** 
 * The base class for all generic type for containers. 
 */ 
class AVRO_DECL GenericContainer { 
    NodePtr schema_; 
    static void assertType(const NodePtr& schema, Type type); 
protected: 
    /** 
     * Constructs a container corresponding to the given schema. 
     */ 
    GenericContainer(Type type, const NodePtr& s) : schema_(s) { 
        assertType(s, type); 
    } 
 
public: 
    /// Returns the schema for this object 
    const NodePtr& schema() const { 
        return schema_; 
    } 
}; 
 
/** 
 * Generic container for unions. 
 */ 
class AVRO_DECL GenericUnion : public GenericContainer { 
    size_t curBranch_; 
    GenericDatum datum_; 
 
public: 
    /** 
     * Constructs a generic union corresponding to the given schema \p schema, 
     * and the given value. The schema should be of Avro type union 
     * and the value should correspond to one of the branches of the union. 
     */ 
    GenericUnion(const NodePtr& schema) : 
        GenericContainer(AVRO_UNION, schema), curBranch_(schema->leaves()) { 
        selectBranch(0); 
    } 
 
    /** 
     * Returns the index of the current branch. 
     */ 
    size_t currentBranch() const { return curBranch_; } 
 
    /** 
     * Selects a new branch. The type for the value is changed accordingly. 
     * \param branch The index for the selected branch. 
     */ 
    void selectBranch(size_t branch) { 
        if (curBranch_ != branch) { 
            datum_ = GenericDatum(schema()->leafAt(branch)); 
            curBranch_ = branch; 
        } 
    } 
 
    /** 
     * Returns the datum corresponding to the currently selected branch 
     * in this union. 
     */ 
    GenericDatum& datum() { 
        return datum_; 
    } 
 
    /** 
     * Returns the datum corresponding to the currently selected branch 
     * in this union. 
     */ 
    const GenericDatum& datum() const { 
        return datum_; 
    } 
}; 
 
/** 
 * The generic container for Avro records. 
 */ 
class AVRO_DECL GenericRecord : public GenericContainer { 
    std::vector<GenericDatum> fields_; 
public: 
    /** 
     * Constructs a generic record corresponding to the given schema \p schema, 
     * which should be of Avro type record. 
     */ 
    GenericRecord(const NodePtr& schema); 
 
    /** 
     * Returns the number of fields in the current record. 
     */ 
    size_t fieldCount() const { 
        return fields_.size(); 
    } 
 
    /** 
     * Returns index of the field with the given name \p name 
     */ 
    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; 
    } 
 
    /** 
     * Returns true if a field with the given name \p name is located in this r 
     * false otherwise 
     */ 
    bool hasField(const std::string& name) const { 
        size_t index = 0; 
        return schema()->nameIndex(name, index); 
    } 
 
    /** 
     * Returns the field with the given name \p name. 
     */ 
    const GenericDatum& field(const std::string& name) const { 
        return fieldAt(fieldIndex(name)); 
    } 
 
    /** 
     * Returns the reference to the field with the given name \p name, 
     * which can be used to change the contents. 
     */ 
    GenericDatum& field(const std::string& name) { 
        return fieldAt(fieldIndex(name)); 
    } 
 
    /** 
     * Returns the field at the given position \p pos. 
     */ 
    const GenericDatum& fieldAt(size_t pos) const { 
        return fields_[pos]; 
    } 
 
    /** 
     * Returns the reference to the field at the given position \p pos, 
     * which can be used to change the contents. 
     */ 
    GenericDatum& fieldAt(size_t pos) { 
        return fields_[pos]; 
    } 
 
    /** 
     * Replaces the field at the given position \p pos with \p v. 
     */ 
    void setFieldAt(size_t pos, const GenericDatum& v) { 
        // assertSameType(v, schema()->leafAt(pos)); 
        fields_[pos] = v; 
    } 
}; 
 
/** 
 * The generic container for Avro arrays. 
 */ 
class AVRO_DECL GenericArray : public GenericContainer { 
public: 
    /** 
     * The contents type for the array. 
     */ 
    typedef std::vector<GenericDatum> Value; 
 
    /** 
     * Constructs a generic array corresponding to the given schema \p schema, 
     * which should be of Avro type array. 
     */ 
    GenericArray(const NodePtr& schema) : GenericContainer(AVRO_ARRAY, schema) { 
    } 
 
    /** 
     * Returns the contents of this array. 
     */ 
    const Value& value() const { 
        return value_; 
    } 
 
    /** 
     * Returns the reference to the contents of this array. 
     */ 
    Value& value() { 
        return value_; 
    } 
private: 
    Value value_; 
}; 
 
/** 
 * The generic container for Avro maps. 
 */ 
class AVRO_DECL GenericMap : public GenericContainer { 
public: 
    /** 
     * The contents type for the map. 
     */ 
    typedef std::vector<std::pair<std::string, GenericDatum> > Value; 
 
    /** 
     * Constructs a generic map corresponding to the given schema \p schema, 
     * which should be of Avro type map. 
     */ 
    GenericMap(const NodePtr& schema) : GenericContainer(AVRO_MAP, schema) { 
    } 
 
    /** 
     * Returns the contents of this map. 
     */ 
    const Value& value() const { 
        return value_; 
    } 
 
    /** 
     * Returns the reference to the contents of this map. 
     */ 
    Value& value() { 
        return value_; 
    } 
private: 
    Value value_; 
}; 
 
/** 
 * Generic container for Avro enum. 
 */ 
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: 
    /** 
     * Constructs a generic enum corresponding to the given schema \p schema, 
     * which should be of Avro type enum. 
     */ 
    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)) { 
    } 
 
    /** 
     * Returns the symbol corresponding to the cardinal \p n. If the 
     * value for \p n is not within the limits an exception is thrown. 
     */ 
    const std::string& symbol(size_t n) { 
        if (n < schema()->names()) { 
            return schema()->nameAt(n); 
        } 
        throw Exception("Not as many symbols"); 
    } 
 
    /** 
     * Returns the cardinal for the given symbol \c symbol. If the symbol 
     * is not defined for this enum and exception is thrown. 
     */ 
    size_t index(const std::string& symbol) const { 
        return index(schema(), symbol); 
    } 
 
    /** 
     * Set the value for this enum corresponding to the given symbol \c symbol. 
     */ 
    size_t set(const std::string& symbol) { 
        return value_ = index(symbol); 
    } 
 
    /** 
     * Set the value for this enum corresponding to the given cardinal \c n. 
     */ 
    void set(size_t n) { 
        if (n < schema()->names()) { 
            value_ = n; 
            return; 
        } 
        throw Exception("Not as many symbols"); 
    } 
 
    /** 
     * Returns the cardinal for the current value of this enum. 
     */ 
    size_t value() const { 
        return value_; 
    } 
 
    /** 
     * Returns the symbol for the current value of this enum. 
     */ 
    const std::string& symbol() const { 
        return schema()->nameAt(value_); 
    } 
}; 
 
/** 
 * Generic container for Avro fixed. 
 */ 
class AVRO_DECL GenericFixed : public GenericContainer { 
    std::vector<uint8_t> value_; 
public: 
    /** 
     * Constructs a generic enum corresponding to the given schema \p schema, 
     * which should be of Avro type fixed. 
     */ 
    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) { } 
 
    /** 
     * Returns the contents of this fixed. 
     */ 
    const std::vector<uint8_t>& value() const { 
        return value_; 
    } 
 
    /** 
     * Returns the reference to the contents of this fixed. 
     */ 
    std::vector<uint8_t>& value() { 
        return value_; 
    } 
}; 
 
inline Type GenericDatum::type() const { 
    return (type_ == AVRO_UNION) ? 
#if __cplusplus >= 201703L 
        std::any_cast<GenericUnion>(&value_)->datum().type() : 
#else 
        boost::any_cast<GenericUnion>(&value_)->datum().type() : 
#endif 
        type_; 
} 
 
inline LogicalType GenericDatum::logicalType() const { 
    return logicalType_; 
} 
 
template<typename T> T& GenericDatum::value() { 
    return (type_ == AVRO_UNION) ? 
#if __cplusplus >= 201703L 
        std::any_cast<GenericUnion>(&value_)->datum().value<T>() : 
        *std::any_cast<T>(&value_); 
#else 
        boost::any_cast<GenericUnion>(&value_)->datum().value<T>() : 
        *boost::any_cast<T>(&value_); 
#endif 
} 
 
template<typename T> const T& GenericDatum::value() const { 
    return (type_ == AVRO_UNION) ? 
#if __cplusplus >= 201703L 
        std::any_cast<GenericUnion>(&value_)->datum().value<T>() : 
        *std::any_cast<T>(&value_); 
#else 
        boost::any_cast<GenericUnion>(&value_)->datum().value<T>() : 
        *boost::any_cast<T>(&value_); 
#endif 
} 
 
inline size_t GenericDatum::unionBranch() const { 
#if __cplusplus >= 201703L 
    return std::any_cast<GenericUnion>(&value_)->currentBranch(); 
#else 
    return boost::any_cast<GenericUnion>(&value_)->currentBranch(); 
#endif 
} 
 
inline void GenericDatum::selectBranch(size_t branch) { 
#if __cplusplus >= 201703L 
    std::any_cast<GenericUnion>(&value_)->selectBranch(branch); 
#else 
    boost::any_cast<GenericUnion>(&value_)->selectBranch(branch); 
#endif 
} 
 
}   // namespace avro 
#endif // avro_GenericDatum_hh__