options.hpp

/*
    options.hpp - Support file for writing LV2 plugins in C++

    Copyright (C) 2013 Michael Fisher <mfisher31@gmail.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307  USA
*/

#ifndef LVTK_OPTIONS_HPP
#define LVTK_OPTIONS_HPP

#include <lv2/lv2plug.in/ns/ext/options/options.h>


#ifndef LVTK_OPTIONS_IFACE
#define LVTK_OPTIONS_IFACE 1
#endif

namespace lvtk {


    typedef LV2_Options_Option Option;

    typedef enum {
        OPTIONS_INSTANCE    = LV2_OPTIONS_INSTANCE,

        OPTIONS_RESOURCE    = LV2_OPTIONS_RESOURCE,

        OPTIONS_BLANK       = LV2_OPTIONS_BLANK,

        OPTIONS_PORT        = LV2_OPTIONS_PORT
    } OptionsContext;


    typedef enum {
        OPTIONS_SUCCESS         = LV2_OPTIONS_SUCCESS,          
        OPTIONS_ERR_UNKNOWN     = LV2_OPTIONS_ERR_UNKNOWN,      
        OPTIONS_ERR_BAD_SUBJECT = LV2_OPTIONS_ERR_BAD_SUBJECT,  
        OPTIONS_ERR_BAD_KEY     = LV2_OPTIONS_ERR_BAD_KEY,      
        OPTIONS_ERR_BAD_VALUE   = LV2_OPTIONS_ERR_BAD_VALUE     
    } OptionsStatus;


    class OptionsIter
    {
    public:

        OptionsIter (const Option* options)
            : index (0),m_size (0), p_opts (options)
        {
            while (0 != next())
                ++m_size;
            index = 0;
        }

        const Option* next()
        {
            if (p_opts == 0 || (p_opts[index].key   == 0 &&
                                   p_opts[index].value == 0))
                return 0;

            return &p_opts[index++];
        }

        uint32_t size() const { return m_size; }

    private:

        uint32_t           index;

        uint32_t           m_size;

        const Option*      p_opts;

    };


    template <bool Required = false>
    struct Options
    {

        template <class Derived>
        struct I : Extension<Required>
        {

            I() : p_supplied_opts (0) { }

            static void
            map_feature_handlers (FeatureHandlerMap& hmap)
            {
                hmap[LV2_OPTIONS__options] = &I<Derived>::handle_feature;
            }

            static void
            handle_feature (void* instance, FeatureData data)
            {
                Derived* plugin (reinterpret_cast<Derived*> (instance));
                I<Derived>* mixin (static_cast<I<Derived>*> (plugin));
                mixin->p_supplied_opts = (Option*) data;
                mixin->m_ok = true;
            }

            bool
            check_ok()
            {
                if (LVTK_DEBUG) {
                    std::clog <<"    [Options] validation "
                              <<(this->m_ok ? "succeeded" : "failed")<<"."<<std::endl;
                }
                return this->m_ok;
            }

            static const void*
            extension_data (const char* uri)
            {
               #if LVTK_OPTIONS_IFACE
                if (! strcmp (uri, LV2_OPTIONS__interface)) {
                    static LV2_Options_Interface options = { &I<Derived>::_get,
                                                             &I<Derived>::_set };
                    return &options;
                }
               #endif
                return 0;
            }

            const Option* get_supplied_options()       { return p_supplied_opts; }

        protected:

            uint32_t get_options (Option*)              { return OPTIONS_SUCCESS; }




            uint32_t set_options (const Option*)        { return OPTIONS_SUCCESS; }

        private:

            Option* p_supplied_opts;

            /* LV2 Options Implementation */

            static uint32_t _get (LV2_Handle handle, LV2_Options_Option* options)
            {
                Derived* plugin (reinterpret_cast<Derived*> (handle));
                return plugin->get_options (options);
            }

            static uint32_t _set (LV2_Handle handle, const LV2_Options_Option* options)
            {
                Derived* plugin (reinterpret_cast<Derived*> (handle));
                return plugin->set_options (options);
            }

        };
    };

} /* namespace lvtk */

#endif /* LVTK_OPTIONS_HPP */