FnAttribute.h

// Copyright (c) 2011 The Foundry Visionmongers Ltd. All Rights Reserved.

#ifndef FoundryKatanaAttribute_H
#define FoundryKatanaAttribute_H

#include <stdint.h>
#include <cstring>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include "FnPlatform/StringView.h"
#include "FnPlatform/internal/Portability.h"
#include "FnPluginSystem/FnPluginSystem.h"

#include "FnAttribute/FnAttributeAPI.h"
#include "FnAttribute/FnAttributeBase.h"
#include "FnAttribute/FnConstVector.h"
#include "FnAttribute/FnSampleAccessor.h"
#include "FnAttribute/ns.h"
#include "FnAttribute/suite/FnAttributeSuite.h"

FNATTRIBUTE_NAMESPACE_ENTER
{
    FNATTRIBUTE_API
    bool Bootstrap(const std::string& katanaPath);

    FNATTRIBUTE_API
    void Initialize(const FnAttributeHostSuite *);

    class FNATTRIBUTE_API DataAttribute : public Attribute
    {
    public:
        DataAttribute() {}

        int64_t getTupleSize() const
        {
            return getSuite()->getTupleSize(getHandle());
        }
        int64_t getNumberOfValues() const
        {
            return getSuite()->getNumberOfValues(getHandle());
        }
        int64_t getNumberOfTuples() const
        {
            return getSuite()->getNumberOfTuples(getHandle());
        }
        int64_t getNumberOfTimeSamples() const
        {
            return getSuite()->getNumberOfTimeSamples(getHandle());
        }
        float getSampleTime(int64_t index) const
        {
            return getSuite()->getSampleTime(getHandle(), index);
        }

        bool getBoundingSampleTimes(float *ltime, float *rtime, float sampletime) const
        {
            return (0 != getSuite()->getBoundingSampleTimes(getHandle(), ltime, rtime, sampletime));
        }

        DataAttribute(const Attribute& rhs) : Attribute(0x0)
        {
            checkAndAcceptDataHandle(rhs);
        }

        DataAttribute& operator=(const Attribute& rhs)
        {
            checkAndAcceptDataHandle(rhs);
            return *this;
        }

#if FNKAT_CXX11
        DataAttribute(Attribute&& rhs) :  // NOLINT(runtime/explicit)
            Attribute(nullptr)
        {
            checkAndMoveDataHandle(std::move(rhs));
        }

        DataAttribute& operator=(Attribute&& rhs)
        {
            checkAndMoveDataHandle(std::move(rhs));
            return *this;
        }
#endif  // FNKAT_CXX11


    protected:
        DataAttribute(FnAttributeHandle handle) : Attribute(handle) {}

        static const float kZero[];

    private:
        void checkAndAcceptDataHandle(const Attribute &rhs)
        {
            if (rhs.isValid())
            {
                FnKatAttributeType type = rhs.getType();
                if (type == kFnKatAttributeTypeInt    || type == kFnKatAttributeTypeFloat ||
                    type == kFnKatAttributeTypeDouble || type == kFnKatAttributeTypeString)
                {
                    acceptHandle(rhs);
                    return;
                }
            }

            clearHandle();
        }
#if FNKAT_CXX11
        void checkAndMoveDataHandle(Attribute&& rhs)
        {
            if (rhs.isValid())
            {
                const FnKatAttributeType type = rhs.getType();
                if (type == kFnKatAttributeTypeInt    ||
                    type == kFnKatAttributeTypeFloat  ||
                    type == kFnKatAttributeTypeDouble ||
                    type == kFnKatAttributeTypeString)
                {
                    moveHandle(std::move(rhs));
                    return;
                }
            }

            clearHandle();
        }
#endif  // FNKAT_CXX11
        //@endcond
    };

    class FNATTRIBUTE_API NullAttribute : public Attribute
    {
    public:
        NullAttribute() : Attribute(getSuite()->createNullAttr()) {}
        NullAttribute(const Attribute& rhs) : Attribute(0x0)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeNull);
        }

        NullAttribute& operator=(const Attribute& rhs)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeNull);
            return *this;
        }

#if FNKAT_CXX11
        NullAttribute(Attribute&& rhs) :  // NOLINT(runtime/explicit)
            Attribute(nullptr)
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeNull);
        }

        NullAttribute& operator=(Attribute&& rhs)
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeNull);
            return *this;
        }
#endif  // FNKAT_CXX11

        static FnKatAttributeType getKatAttributeType()
        {
            return kFnKatAttributeTypeNull;
        }
    private:
        NullAttribute(FnAttributeHandle handle); // NOTE: not implemented
    };

    class FNATTRIBUTE_API IntAttribute : public DataAttribute
    {
    public:
        typedef int32_t value_type;
        typedef IntConstVectorBase internal_array_type;
        typedef IntConstVector array_type;

        typedef SampleAccessor<value_type> accessor_type;
        typedef SampleAccessorBase<value_type> internal_accessor_type;
        typedef Sample<value_type> sample_type;

        IntAttribute() : DataAttribute() {}

        IntAttribute(value_type value) : DataAttribute(getSuite()->createIntAttr1(value)) {}

        IntAttribute(const value_type* values,
                     int64_t valueCount,
                     int64_t tupleSize,
                     void* context = NULL,
                     FnAttributeFreeOwnedDataFunc freeOwnedDataFunc = NULL)
            : DataAttribute(
                  getSuite()->createIntAttrFactory(DataAttribute::kZero,
                                                   1,
                                                   &values,
                                                   valueCount,
                                                   tupleSize,
                                                   context,
                                                   freeOwnedDataFunc))
        {
        }

        IntAttribute(const float* times,
                     int64_t timeCount,
                     const value_type** values,
                     int64_t valueCount,
                     int64_t tupleSize,
                     void* context = NULL,
                     FnAttributeFreeOwnedDataFunc freeOwnedDataFunc = NULL)
            : DataAttribute(getSuite()->createIntAttrFactory(times,
                                                             timeCount,
                                                             values,
                                                             valueCount,
                                                             tupleSize,
                                                             context,
                                                             freeOwnedDataFunc))
        {
        }

        static FnKatAttributeType getKatAttributeType()
        {
            return kFnKatAttributeTypeInt;
        }

#if FNKAT_CXX11
        accessor_type getSamples() const & { return accessor_type(*this); }

        accessor_type getSamples() &&
        {
            return accessor_type(std::move(*this));
        }
#else
        internal_accessor_type getSamples() const
        {
            return internal_accessor_type(*this);
        }
#endif  // FNKAT_CXX11

#if FNKAT_CXX11
        array_type getNearestSample(float time) const &
        {
            return array_type(*this, time);
        }

        array_type getNearestSample(float time) &&
        {
            return array_type(std::move(*this), time);
        }
#else
        internal_array_type getNearestSample(float time) const
        {
            return internal_array_type(*this, time);
        }
#endif  // FNKAT_CXX11

        value_type getValue(const value_type defValue = 0, bool throwOnError=true) const
        {
            value_type value;
            FnAttributeHandle handle = getHandle();
            if (getSuite()->getIntValue(&handle, 0.0f, 0, &value))
            {
                return value;
            }
            if (throwOnError)
            {
                throw std::runtime_error("Error getting int value from IntAttribute.");
            }
            else
            {
                return defValue;
            }
        }

        template <typename T, size_t N>
        T getValuesAs(const T& defValue = T(), bool throwOnError = true) const
        {
            accessor_type accessor(this);
            if (!accessor.empty() &&
                N <= static_cast<size_t>(accessor.getNumberOfValues()))
            {
                const sample_type& sample = accessor.getNearestSample(0.0f);
                return sample.getAs<T, N>(defValue);
            }
            else if (throwOnError)
            {
                throw std::runtime_error(
                    "Error getting int values from IntAttribute.");
            }
            else
            {
                return defValue;
            }
        }

        IntAttribute(const Attribute& rhs) : DataAttribute(0x0)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeInt);
        }

        IntAttribute& operator=(const Attribute& rhs)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeInt);
            return *this;
        }

#if FNKAT_CXX11
        IntAttribute(Attribute&& rhs) :  // NOLINT(runtime/explicit)
            DataAttribute()
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeInt);
        }

        IntAttribute& operator=(Attribute&& rhs)
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeInt);
            return *this;
        }
#endif  // FNKAT_CXX11

    private:
        IntAttribute(FnAttributeHandle handle); // NOTE: not implemented
    };

    class FNATTRIBUTE_API FloatAttribute : public DataAttribute
    {
    public:
        typedef float value_type;
        typedef FloatConstVectorBase internal_array_type;
        typedef FloatConstVector array_type;

        typedef SampleAccessor<value_type> accessor_type;
        typedef SampleAccessorBase<value_type> internal_accessor_type;
        typedef Sample<value_type> sample_type;

        FloatAttribute() : DataAttribute() {}
        FloatAttribute(value_type value) : DataAttribute(getSuite()->createFloatAttr1(value)) {}
        FloatAttribute(const value_type* values,
                       int64_t valueCount,
                       int64_t tupleSize,
                       void* context = NULL,
                       FnAttributeFreeOwnedDataFunc freeOwnedDataFunc = NULL)
            : DataAttribute(
                  getSuite()->createFloatAttrFactory(DataAttribute::kZero,
                                                     1,
                                                     &values,
                                                     valueCount,
                                                     tupleSize,
                                                     context,
                                                     freeOwnedDataFunc))
        {
        }

        FloatAttribute(const float* times,
                       int64_t timeCount,
                       const value_type** values,
                       int64_t valueCount,
                       int64_t tupleSize,
                       void* context = NULL,
                       FnAttributeFreeOwnedDataFunc freeOwnedDataFunc = NULL)
            : DataAttribute(
                  getSuite()->createFloatAttrFactory(times,
                                                     timeCount,
                                                     values,
                                                     valueCount,
                                                     tupleSize,
                                                     context,
                                                     freeOwnedDataFunc))
        {
        }

        static FnKatAttributeType getKatAttributeType()
        {
            return kFnKatAttributeTypeFloat;
        }

#if FNKAT_CXX11
        accessor_type getSamples() const & { return accessor_type(*this); }

        accessor_type getSamples() &&
        {
            return accessor_type(std::move(*this));
        }
#else
        internal_accessor_type getSamples() const
        {
            return internal_accessor_type(*this);
        }
#endif  // FNKAT_CXX11

#if FNKAT_CXX11
        array_type getNearestSample(float time) const &
        {
            return array_type(*this, time);
        }

        array_type getNearestSample(float time) &&
        {
            return array_type(std::move(*this), time);
        }
#else
        internal_array_type getNearestSample(float time) const
        {
            return internal_array_type(*this, time);
        }
#endif  // FNKAT_CXX11

        void fillInterpSample(value_type * array, int64_t valueCount,
            float sampleTime,
            const value_type defValue = 0.f, bool throwOnError=true) const;

        value_type getValue(const value_type defValue = 0.f, bool throwOnError=true) const
        {
            value_type value;
            FnAttributeHandle handle = getHandle();
            if (getSuite()->getFloatValue(&handle, 0.0f, 0, &value))
            {
                return value;
            }
            if (throwOnError)
            {
                throw std::runtime_error("Error getting float value from FloatAttribute.");
            }
            else
            {
                return defValue;
            }
        }

        template <typename T, size_t N>
        T getValuesAs(const T& defValue = T(), bool throwOnError = true) const
        {
            accessor_type accessor(this);
            if (!accessor.empty() &&
                N <= static_cast<size_t>(accessor.getNumberOfValues()))
            {
                const sample_type& sample = accessor.getNearestSample(0.0f);
                return sample.getAs<T, N>(defValue);
            }
            else if (throwOnError)
            {
                throw std::runtime_error(
                    "Error getting float values from FloatAttribute.");
            }
            else
            {
                return defValue;
            }
        }

        FloatAttribute(const Attribute& rhs) : DataAttribute(0x0)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeFloat);
        }

        FloatAttribute& operator=(const Attribute& rhs)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeFloat);
            return *this;
        }

#if FNKAT_CXX11
        FloatAttribute(Attribute&& rhs) :  // NOLINT(runtime/explicit)
            DataAttribute()
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeFloat);
        }

        FloatAttribute& operator=(Attribute&& rhs)
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeFloat);
            return *this;
        }
#endif  // FNKAT_CXX11

    private:
        FloatAttribute(FnAttributeHandle handle); // NOTE: not implemented
    };

    class FNATTRIBUTE_API DoubleAttribute : public DataAttribute
    {
    public:
        typedef double value_type;
        typedef DoubleConstVectorBase internal_array_type;
        typedef DoubleConstVector array_type;

        typedef SampleAccessor<value_type> accessor_type;
        typedef SampleAccessorBase<value_type> internal_accessor_type;
        typedef Sample<value_type> sample_type;

        DoubleAttribute() : DataAttribute() {}
        DoubleAttribute(value_type value) :DataAttribute(getSuite()->createDoubleAttr1(value)) {}

        DoubleAttribute(const value_type* values,
                        int64_t valueCount,
                        int64_t tupleSize,
                        void* context = NULL,
                        FnAttributeFreeOwnedDataFunc freeOwnedDataFunc = NULL)
            : DataAttribute(
                  getSuite()->createDoubleAttrFactory(DataAttribute::kZero,
                                                      1,
                                                      &values,
                                                      valueCount,
                                                      tupleSize,
                                                      context,
                                                      freeOwnedDataFunc))
        {
        }

        DoubleAttribute(const float* times,
                        int64_t timeCount,
                        const value_type** values,
                        int64_t valueCount,
                        int64_t tupleSize,
                        void* context = NULL,
                        FnAttributeFreeOwnedDataFunc freeOwnedDataFunc = NULL)
            : DataAttribute(
                  getSuite()->createDoubleAttrFactory(times,
                                                      timeCount,
                                                      values,
                                                      valueCount,
                                                      tupleSize,
                                                      context,
                                                      freeOwnedDataFunc))
        {
        }

        static FnKatAttributeType getKatAttributeType()
        {
            return kFnKatAttributeTypeDouble;
        }

#if FNKAT_CXX11
        accessor_type getSamples() const & { return accessor_type(*this); }

        accessor_type getSamples() &&
        {
            return accessor_type(std::move(*this));
        }
#else
        internal_accessor_type getSamples() const
        {
            return internal_accessor_type(*this);
        }
#endif  // FNKAT_CXX11

#if FNKAT_CXX11
        array_type getNearestSample(float time) const &
        {
            return array_type(*this, time);
        }

        array_type getNearestSample(float time) &&
        {
            return array_type(std::move(*this), time);
        }
#else
        internal_array_type getNearestSample(float time) const
        {
            return internal_array_type(*this, time);
        }
#endif  // FNKAT_CXX11

        void fillInterpSample(value_type * array, int64_t valueCount,
            float sampleTime,
            const value_type defValue = 0.0, bool throwOnError=true) const;

        value_type getValue(const value_type defValue = 0.0, bool throwOnError=true) const
        {
            value_type value;
            FnAttributeHandle handle = getHandle();
            if (getSuite()->getDoubleValue(&handle, 0.0f, 0, &value))
            {
                return value;
            }
            if (throwOnError)
            {
                throw std::runtime_error("Error getting double value from DoubleAttribute.");
            }
            else
            {
                return defValue;
            }
        }

        template <typename T, size_t N>
        T getValuesAs(const T& defValue = T(), bool throwOnError = true) const
        {
            accessor_type accessor(this);
            if (!accessor.empty() &&
                N <= static_cast<size_t>(accessor.getNumberOfValues()))
            {
                const sample_type& sample = accessor.getNearestSample(0.0f);
                return sample.getAs<T, N>(defValue);
            }
            else if (throwOnError)
            {
                throw std::runtime_error(
                    "Error getting double values from DoubleAttribute.");
            }
            else
            {
                return defValue;
            }
        }

        DoubleAttribute(const Attribute& rhs) : DataAttribute(0x0)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeDouble);
        }

        DoubleAttribute& operator=(const Attribute& rhs)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeDouble);
            return *this;
        }

#if FNKAT_CXX11
        DoubleAttribute(Attribute&& rhs) :  // NOLINT(runtime/explicit)
            DataAttribute()
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeDouble);
        }

        DoubleAttribute& operator=(Attribute&& rhs)
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeDouble);
            return *this;
        }
#endif  // FNKAT_CXX11

    private:
        DoubleAttribute(FnAttributeHandle handle); // NOTE: not implemented
    };

    class FNATTRIBUTE_API StringAttribute : public DataAttribute
    {
    public:
        typedef std::string value_type;
        typedef StringConstVectorBase internal_array_type;
        typedef StringConstVector array_type;

        typedef SampleAccessor<const char*> accessor_type;
        typedef SampleAccessorBase<const char*> internal_accessor_type;
        typedef Sample<const char*> sample_type;

        StringAttribute() : DataAttribute() {}

        StringAttribute(const std::string & value) : DataAttribute(getSuite()->createStringAttr1(value.c_str())) {}

        StringAttribute(const char * value) : DataAttribute(getSuite()->createStringAttr1(value)) {}

        StringAttribute(const value_type* values,
                        int64_t valueCount,
                        int64_t tupleSize);

        StringAttribute(const std::vector<std::string> & stringvec, int64_t tupleSize=1);

        StringAttribute(const char ** values, int64_t valueCount, int64_t tupleSize) :
            DataAttribute(getSuite()->createStringAttr2(values, valueCount, tupleSize)) {}

        static FnKatAttributeType getKatAttributeType()
        {
            return kFnKatAttributeTypeString;
        }

        StringAttribute(const float* times,
                        int64_t timeCount,
                        const char*** values,
                        int64_t valueCount,
                        int64_t tupleSize,
                        void* context = NULL,
                        FnAttributeFreeOwnedDataFunc freeOwnedDataFunc = NULL)
            : DataAttribute(
                  getSuite()->createStringAttrFactory(times,
                                                      timeCount,
                                                      values,
                                                      valueCount,
                                                      tupleSize,
                                                      context,
                                                      freeOwnedDataFunc))
        {
        }

#if FNKAT_CXX11
        accessor_type getSamples() const & { return accessor_type(*this); }

        accessor_type getSamples() &&
        {
            return accessor_type(std::move(*this));
        }
#else
        internal_accessor_type getSamples() const
        {
            return internal_accessor_type(*this);
        }
#endif  // FNKAT_CXX11

#if FNKAT_CXX11
        array_type getNearestSample(float time) const &
        {
            return array_type(*this, time);
        }

        array_type getNearestSample(float time) &&
        {
            return array_type(std::move(*this), time);
        }
#else
        internal_array_type getNearestSample(float time) const
        {
            return internal_array_type(*this, time);
        }
#endif  // FNKAT_CXX11

        value_type getValue(const value_type& defValue = value_type(),
                            bool throwOnError = true) const
        {
            if (const char* value = getValueCStr(NULL, throwOnError))
            {
                return value;
            }
            else
            {
                return defValue;
            }
        }

        template <typename T, size_t N>
        T getValuesAs(const T& defValue = T(), bool throwOnError = true) const
        {
            accessor_type accessor(this);
            if (!accessor.empty() &&
                N <= static_cast<size_t>(accessor.getNumberOfValues()))
            {
                const sample_type& sample = accessor.getNearestSample(0.0f);
                return sample.getAs<T, N>(defValue);
            }
            else if (throwOnError)
            {
                throw std::runtime_error(
                    "Error getting string values from StringAttribute.");
            }
            else
            {
                return defValue;
            }
        }

        const char* getValueCStr(const char* defValue = "",
                                 bool throwOnError = true) const
            FNKAT_LVALUE_REF_QUALIFIER
        {
            const char* value;
            FnAttributeHandle* handlePtr =
                const_cast<FnAttributeHandle*>(&getHandle());
            if (getSuite()->getStringValue(handlePtr, 0.0f, 0, &value))
            {
                return value;
            }
            if (throwOnError)
            {
                throw std::runtime_error("Error getting string value from StringAttribute.");
            }
            else
            {
                return defValue;
            }
        }

#if FNKAT_CXX11

        const char* getValueCStr(const char* defValue = "",
                                 bool throwOnError = true) && = delete;
#endif  // FNKAT_CXX11

        bool operator==(const char* str) const {
            if (isValid()) {
                int64_t valueCount=0;
                FnAttributeHandle handle = getHandle();
                const char** data = getSuite()->getStringNearestSample(
                        handle, 0.f, &valueCount);

                // Tagged pointer then?
                const char* value[1];
                if (!data && getSuite()->getStringValue(&handle,
                        0.0f, 0, &value[0]))
                {
                    data = value;
                    valueCount = 1;
                }

                if (valueCount==1) // len>1 arrays should not equal scalars
                    return strcmp(data[0], str) == 0;
            }
            return false;
        }

        bool operator!=(const char* str) const {
            return !operator==(str);
        }

        bool operator==(const std::string& str) const {
            return this->operator==(str.c_str());
        }

        bool operator!=(const std::string& str) const {
            return !operator==(str);
        }

        StringAttribute(const Attribute& rhs) : DataAttribute(0x0)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeString);
        }

        StringAttribute& operator=(const Attribute& rhs)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeString);
            return *this;
        }

#if FNKAT_CXX11
        StringAttribute(Attribute&& rhs) :  // NOLINT(runtime/explicit)
            DataAttribute()
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeString);
        }

        StringAttribute& operator=(Attribute&& rhs)
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeString);
            return *this;
        }
#endif  // FNKAT_CXX11

    private:
        StringAttribute(FnAttributeHandle handle); // NOTE: not implemented
    };

    class FNATTRIBUTE_API GroupAttribute : public Attribute
    {
    public:

        typedef std::pair<std::string, Attribute> NamedAttr_Type;
        typedef std::vector<NamedAttr_Type> NamedAttrVector_Type;

        GroupAttribute() : Attribute() {}

        explicit GroupAttribute(const bool groupInherit)
            : Attribute(getSuite()->createGroupAttr(NULL, NULL, 0,
                                                    (uint8_t)groupInherit))
        {
        }

        // Note: These constructors do not support delimited child names
        // (i.e., no dots in the name). If you wish to construct
        // a GroupAttribute with a deep hierarchy, use GroupBuilder instead.

        GroupAttribute(const std::string & name1, const Attribute & attr1,
                       const bool groupInherit)  : Attribute(NULL)
        {
            const char * names[] = { name1.c_str() };
            FnAttributeHandle attrs[] = { attr1.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 1, (uint8_t) groupInherit));
        }

        GroupAttribute(const char * name1, const Attribute & attr1,
                       const bool groupInherit)  : Attribute(NULL)
        {
            const char * names[] = { name1 };
            FnAttributeHandle attrs[] = { attr1.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 1, (uint8_t) groupInherit));
        }

        GroupAttribute(const std::string & name1, const Attribute & attr1,
                       const std::string & name2, const Attribute & attr2,
                       const bool groupInherit) : Attribute(NULL)
        {
            const char * names[] = { name1.c_str(), name2.c_str() };
            FnAttributeHandle attrs[] = { attr1.getHandle(), attr2.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 2, (uint8_t) groupInherit));
        }

        GroupAttribute(const char * name1, const Attribute & attr1,
                       const char * name2, const Attribute & attr2,
                       const bool groupInherit) : Attribute(NULL)
        {
            const char * names[] = { name1, name2 };
            FnAttributeHandle attrs[] = { attr1.getHandle(), attr2.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 2, (uint8_t) groupInherit));
        }

        GroupAttribute(const std::string & name1, const Attribute & attr1,
                       const std::string & name2, const Attribute & attr2,
                       const std::string & name3, const Attribute & attr3,
                       const bool groupInherit) : Attribute(NULL)
        {
            const char * names[] = { name1.c_str(), name2.c_str(),
                name3.c_str() };
            FnAttributeHandle attrs[] = { attr1.getHandle(), attr2.getHandle(),
                attr3.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 3, (uint8_t) groupInherit));
        }

        GroupAttribute(const char * name1, const Attribute & attr1,
                       const char * name2, const Attribute & attr2,
                       const char * name3, const Attribute & attr3,
                       const bool groupInherit) : Attribute(NULL)
        {
            const char * names[] = { name1, name2, name3 };
            FnAttributeHandle attrs[] = { attr1.getHandle(), attr2.getHandle(),
                attr3.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 3, (uint8_t) groupInherit));
        }

        GroupAttribute(const std::string & name1, const Attribute & attr1,
                       const std::string & name2, const Attribute & attr2,
                       const std::string & name3, const Attribute & attr3,
                       const std::string & name4, const Attribute & attr4,
                       const bool groupInherit) : Attribute(NULL)
        {
            const char * names[] = { name1.c_str(), name2.c_str(),
                name3.c_str(), name4.c_str() };
            FnAttributeHandle attrs[] = { attr1.getHandle(), attr2.getHandle(),
                attr3.getHandle(), attr4.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 4, (uint8_t) groupInherit));
        }

        GroupAttribute(const char * name1, const Attribute & attr1,
                       const char * name2, const Attribute & attr2,
                       const char * name3, const Attribute & attr3,
                       const char * name4, const Attribute & attr4,
                       const bool groupInherit) : Attribute(NULL)
        {
            const char * names[] = { name1, name2, name3, name4 };
            FnAttributeHandle attrs[] = { attr1.getHandle(), attr2.getHandle(),
                attr3.getHandle(), attr4.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 4, (uint8_t) groupInherit));
        }

        GroupAttribute(const std::string & name1, const Attribute & attr1,
                       const std::string & name2, const Attribute & attr2,
                       const std::string & name3, const Attribute & attr3,
                       const std::string & name4, const Attribute & attr4,
                       const std::string & name5, const Attribute & attr5,
                       const bool groupInherit) : Attribute(NULL)
        {
            const char * names[] = { name1.c_str(), name2.c_str(),
                name3.c_str(), name4.c_str(), name5.c_str() };
            FnAttributeHandle attrs[] = { attr1.getHandle(), attr2.getHandle(),
                attr3.getHandle(), attr4.getHandle(), attr5.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 5, (uint8_t) groupInherit));
        }

        GroupAttribute(const char * name1, const Attribute & attr1,
                       const char * name2, const Attribute & attr2,
                       const char * name3, const Attribute & attr3,
                       const char * name4, const Attribute & attr4,
                       const char * name5, const Attribute & attr5,
                       const bool groupInherit) : Attribute(NULL)
        {
            const char * names[] = { name1, name2, name3, name4, name5 };
            FnAttributeHandle attrs[] = { attr1.getHandle(), attr2.getHandle(),
                attr3.getHandle(), attr4.getHandle(), attr5.getHandle() };
            stealHandle(getSuite()->createGroupAttr(
                names, attrs, 5, (uint8_t) groupInherit));
        }

        GroupAttribute(const NamedAttrVector_Type &children,
                       const bool inheritChildren);

        static FnKatAttributeType getKatAttributeType()
        {
            return kFnKatAttributeTypeGroup;
        }

        int64_t getNumberOfChildren() const
        {
            return getSuite()->getNumberOfChildren(getHandle());
        }

        std::string getChildName(int64_t index) const
        {
            int32_t nameSize = 0;
            const char *name = getSuite()->getChildNameByIndex(getHandle(), index, &nameSize);
            if (nameSize > 0)
            {
                return std::string(name, static_cast<std::size_t>(nameSize));
            }
            return std::string();
        }

        const char* getChildNameCStr(int64_t index) const
            FNKAT_LVALUE_REF_QUALIFIER
        {
            int32_t nameSize = 0;
            return getChildNameCStr(index, nameSize);
        }

        const char* getChildNameCStr(int64_t index, int32_t &namelen) const
            FNKAT_LVALUE_REF_QUALIFIER
        {
            const char *name = getSuite()->getChildNameByIndex(
                getHandle(), index, &namelen);
            return name;
        }

        FnPlatform::StringView getChildNameStringView(int64_t index) const
            FNKAT_LVALUE_REF_QUALIFIER
        {
            int32_t namelen = 0;
            const char* name = getSuite()->getChildNameByIndex(
                getHandle(), index, &namelen);
            return FnPlatform::StringView(name, namelen);
        }

#if FNKAT_CXX11

        const char* getChildNameCStr(int64_t index) && = delete;
        const char* getChildNameCStr(int64_t index, int32_t &len) && = delete;
        FnPlatform::StringView
            getChildNameStringView(int64_t index) && = delete;
#endif  // FNKAT_CXX11

        Attribute getChildByIndex(int64_t index) const
        {
            return Attribute::CreateAndSteal(getSuite()->getChildByIndex(getHandle(), index));
        }

        Attribute getChildByName(FnPlatform::StringView name) const
        {
            return getChildByName(name.data(),
                                  static_cast<int32_t>(name.size()));
        }

        Attribute getChildByName(const char* name, int32_t length) const
        {
            return Attribute::CreateAndSteal(
                getSuite()->getChildByName(getHandle(), name, length));
        }

        bool getGroupInherit() const
        {
            return (0 != getSuite()->getGroupInherit(getHandle()));
        }

        void fillChildVector(NamedAttrVector_Type * children) const;

        GroupAttribute(const Attribute& rhs) : Attribute(0x0)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeGroup);
        }

        GroupAttribute& operator=(const Attribute& rhs)
        {
            checkAndAcceptHandle(rhs, kFnKatAttributeTypeGroup);
            return *this;
        }

#if FNKAT_CXX11
        GroupAttribute(Attribute&& rhs) :  // NOLINT(runtime/explicit)
            Attribute(nullptr)
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeGroup);
        }

        GroupAttribute& operator=(Attribute&& rhs)
        {
            checkAndMoveHandle(std::move(rhs), kFnKatAttributeTypeGroup);
            return *this;
        }
#endif  // FNKAT_CXX11

    private:
        GroupAttribute(FnAttributeHandle handle); // NOTE: not implemented
    };

    FNATTRIBUTE_API
    std::string DelimiterEncode(const std::string & str);

    FNATTRIBUTE_API
    std::string DelimiterDecode(const std::string & str);

    FNATTRIBUTE_API
    uint64_t GetTotalSize();

}
FNATTRIBUTE_NAMESPACE_EXIT

#endif // FoundryKatanaAttribute_H