FnGroupBuilder.h

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

#ifndef FoundryKatanaGroupBuilder_H
#define FoundryKatanaGroupBuilder_H

#include <FnAttribute/FnAttribute.h>
#include <FnAttribute/FnAttributeAPI.h>
#include <FnAttribute/ns.h>
#include <FnPlatform/StringView.h>

FNATTRIBUTE_NAMESPACE_ENTER
{

    class FNATTRIBUTE_API GroupBuilder
    {
    public:
        GroupBuilder() : _handle(0) {}

        enum BuilderMode
        {
            BuilderModeNormal = kFnKatGroupBuilderModeNormal,

            BuilderModeStrict = kFnKatGroupBuilderModeStrict
        };

        // @cond FN_INTERNAL_DEV
        typedef enum BuilderMode BuilderMode;
        // @endcond

        GroupBuilder(BuilderMode builderMode) : _handle(getSuite()->createGroupBuilder2((BuilderModeType) builderMode)) {}

        ~GroupBuilder() {
            if (_handle != 0x0)
                getSuite()->releaseGroupBuilder(_handle);
        }

        void reset()
        {
            if (_handle != 0x0) {
                getSuite()->releaseGroupBuilder(_handle);
                _handle = NULL;
            }
        }

        bool isValid() const {
            return _handle != 0x0;
        }

        GroupBuilder& set(FnPlatform::StringView path,
                          const Attribute& attr,
                          bool groupInherit = true)
        {
            return set(path.data(), static_cast<int32_t>(path.size()),
                       attr.getHandle(), groupInherit);
        }

        GroupBuilder& set(const char* path,
                          int32_t length,
                          const Attribute& attr,
                          bool groupInherit = true)
        {
            return set(path, length, attr.getHandle(), groupInherit);
        }

        GroupBuilder& set(const char* path,
                          int32_t length,
                          FnAttributeHandle attr,
                          bool groupInherit = true)
        {
            lazyCreate();
            getSuite()->setGroupBuilder(_handle, path, length, attr,
                                        static_cast<uint8_t>(groupInherit));
            return *this;
        }

        GroupBuilder& setWithUniqueName(FnPlatform::StringView path,
                                        const Attribute& attr,
                                        bool groupInherit = true)
        {
            lazyCreate();
            getSuite()->setGroupBuilderUnique(
                _handle, path.data(), static_cast<int32_t>(path.size()),
                attr.getHandle(), uint8_t(groupInherit));
            return (*this);
        }

        GroupBuilder& del(FnPlatform::StringView path)
        {
            lazyCreate();
            getSuite()->delGroupBuilder(_handle, path.data(),
                                        static_cast<int32_t>(path.size()));
            return (*this);
        }


        GroupBuilder & update(const GroupAttribute &attr)
        {
            if (attr.isValid()) {
                lazyCreate();
                getSuite()->updateGroupBuilder(_handle, attr.getHandle());
            }
            return (*this);
        }

        GroupBuilder & deepUpdate(const GroupAttribute &attr)
        {
            if (attr.isValid()) {
                lazyCreate();
                getSuite()->deepUpdateGroupBuilder(_handle, attr.getHandle());
            }
            return (*this);
        }

        GroupBuilder & reserve(int64_t n)
        {
            if (n > 0) {
                lazyCreate();
                getSuite()->reserveGroupBuilder(_handle, n);
            }
            return (*this);
        }

        GroupBuilder & setGroupInherit(bool groupInherit)
        {
            if (_handle || !groupInherit) {
                lazyCreate();
                getSuite()->setGroupBuilderInherit(_handle, (uint8_t) groupInherit);
            }
            return (*this);
        }

        GroupBuilder & sort()
        {
            if (_handle)
                getSuite()->sortGroupBuilder(_handle);
            return (*this);
        }

        enum BuilderBuildMode
        {
            BuildAndFlush = kFnKatGroupBuilderBuildAndFlush,

            BuildAndRetain = kFnKatGroupBuilderBuildAndRetain
        };

        // @cond FN_INTERNAL_DEV
        typedef enum BuilderBuildMode BuilderBuildMode;
        // @endcond

        GroupAttribute build(BuilderBuildMode builderMode = BuildAndFlush)
        {
            if (_handle)
                return Attribute::CreateAndSteal(getSuite()->buildGroupBuilder(
                    _handle, (int32_t) builderMode));
            else
                return GroupAttribute(true);
        }


        FnGroupBuilderHandle getHandle() {
            // this function is used to hand over GroupBuilders through C APIs
            // so we need to make sure we do not return NULL
            lazyCreate();
            return _handle;
        }

        static const FnAttributeHostSuite *getSuite()
        {
            return _attrSuite;
        }

        static void setSuite(const FnAttributeHostSuite *suite);

        static FnPlugStatus setHost(FnPluginHost *host);


    private:
        // no copy/assign
        GroupBuilder(const GroupBuilder& rhs);
        GroupBuilder& operator=(const GroupBuilder& rhs);

        void lazyCreate() {
            if (_handle == 0x0)
                _handle = getSuite()->createGroupBuilder();
        }

        static const FnAttributeHostSuite *_attrSuite;

        FnGroupBuilderHandle _handle;

        //@endcond
    };
}
FNATTRIBUTE_NAMESPACE_EXIT

#endif // FoundryKatanaGroupBuilder_H