state.hpp

/*
    state.hpp - support file for writing LV2 plugins in C++
    Copyright (C) 2012 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_STATE_HPP
#define LVTK_STATE_HPP

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

namespace lvtk {

    typedef enum {
        STATE_IS_POD = LV2_STATE_IS_POD,

        STATE_IS_PORTABLE = LV2_STATE_IS_PORTABLE,

        STATE_IS_NATIVE = LV2_STATE_IS_NATIVE
    } StateFlags;

    typedef enum {
        STATE_SUCCESS         = LV2_STATE_SUCCESS,          
        STATE_ERR_UNKNOWN     = LV2_STATE_ERR_UNKNOWN,      
        STATE_ERR_BAD_TYPE    = LV2_STATE_ERR_BAD_TYPE,     
        STATE_ERR_BAD_FLAGS   = LV2_STATE_ERR_BAD_FLAGS,    
        STATE_ERR_NO_FEATURE  = LV2_STATE_ERR_NO_FEATURE,   
        STATE_ERR_NO_PROPERTY = LV2_STATE_ERR_NO_PROPERTY   
    } StateStatus;


    struct StateRetrieve {
        StateRetrieve(LV2_State_Retrieve_Function srfunc, LV2_State_Handle handle)
        : p_handle(handle), p_srfunc(srfunc) { }

        const void* operator () (uint32_t key, size_t *size  = NULL,
                uint32_t *type  = NULL,
                uint32_t *flags = NULL) const
        {
            return p_srfunc(p_handle, key, size, type, flags);
        }

    private:
        LV2_State_Handle              p_handle;
        LV2_State_Retrieve_Function   p_srfunc;
    };

    /* A little redundant */

    struct StateStore {
        StateStore (LV2_State_Store_Function ssfunc, LV2_State_Handle handle)
        : p_handle(handle), p_ssfunc(ssfunc) { }

        inline StateStatus operator () (uint32_t key, const void* value,
                size_t   size,
                uint32_t type,
                uint32_t flags = 0) const
        {
            return (StateStatus) p_ssfunc (p_handle, key, value, size, type, flags);
        }

    private:
        LV2_State_Handle              p_handle;
        LV2_State_Store_Function      p_ssfunc;
    };

    template <bool Required = true>
    struct State
    {
        template <class Derived>
        struct I : Extension<Required>
        {

            I() : p_make_path (NULL) { }

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

            static void
            handle_make_feature(void* instance, FeatureData data)
            {
                Derived* d = reinterpret_cast<Derived*>(instance);
                I<Derived>* mixin = static_cast<I<Derived>*>(d);
                mixin->p_make_path =
                        reinterpret_cast<LV2_State_Make_Path*> (data);
            }

            bool
            check_ok()
            {
                if (Required) {
                    this->m_ok = (p_make_path != NULL);
                } else {
                    this->m_ok = true;
                }

                if (LVTK_DEBUG) {
                    std::clog<<"    [State] Validation "
                            <<(this->m_ok ? "succeeded" : "failed")<<"."
                            <<std::endl;
                }

                return this->m_ok;
            }

            static const void*
            extension_data (const char* uri)
            {
                if (!std::strcmp (uri, LV2_STATE__interface))
                {
                    static LV2_State_Interface state = { &I<Derived>::_save,
                                                         &I<Derived>::_restore };
                    return &state;
                }
                return 0;
            }


            StateStatus
            save (StateStore &store, uint32_t flags,
                    const FeatureVec &features)
            {
                return STATE_SUCCESS;
            }

            StateStatus
            restore (StateRetrieve &retrieve, uint32_t flags,
                     const FeatureVec &features)
            {
                return STATE_SUCCESS;
            }

        protected:

#if 0
            SAVEME - Map Path is for the State interface methods only.

            char*
            abstract_path (const char* absolute_path);

            char*
            absolute_path(const char* abstract_path)
            {
                return p_map_path->absolute_path (p_map_path->handle, abstract_path);
            }
#endif

            char*
            path (const char* path)
            {
                assert (p_make_path != NULL);
                return p_make_path->path (p_make_path->handle, path);
            }


            /* ==============  LV2 Boiler Plate Implementation ================= */

            LV2_State_Make_Path * p_make_path;

            static LV2_State_Status _save(LV2_Handle                 instance,
                    LV2_State_Store_Function   store,
                    LV2_State_Handle           handle,
                    uint32_t                   flags,
                    const LV2_Feature *const * features)
            {
                Derived* plugin = reinterpret_cast<Derived*>(instance);

                StateStore ss (store, handle);

                FeatureVec feature_set;
                for (int i = 0; features[i]; ++i) {
                    feature_set.push_back (features[i]);
                }

                return (LV2_State_Status)plugin->save(ss, flags, feature_set);
            }

            static LV2_State_Status _restore(LV2_Handle                  instance,
                    LV2_State_Retrieve_Function retrieve,
                    LV2_State_Handle            handle,
                    uint32_t                    flags,
                    const LV2_Feature *const *  features)
            {
                Derived* plugin = reinterpret_cast<Derived*>(instance);

                StateRetrieve sr (retrieve, handle);

                FeatureVec feature_set;
                for (int i = 0; features[i]; ++i) {
                    feature_set.push_back (features[i]);
                }

                return (LV2_State_Status)plugin->restore(sr, flags, feature_set);
            }
        };
    };

} /* namespace lvtk */

#endif /* LVTK_STATE_HPP */