lv2types.hpp

/****************************************************************************
    
    lv2types.hpp - support file for writing LV2 plugins in C++
    
    Copyright (C) 2006-2008 Lars Luthman <lars.luthman@gmail.com>

    The first version of the URIMap class was written by Dave Robillard.
    It has since been modified.

    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 LV2TYPES_HPP
#define LV2TYPES_HPP

#include <map>
#include <string>


namespace LV2 {
  
  typedef LV2_Feature Feature;
  
  typedef void(*FeatureHandler)(void*, void*);
  
  typedef std::map<std::string, FeatureHandler> FeatureHandlerMap;
  
  
  struct Empty {

  };
  
  
  struct End {
    typedef Empty C;
  };
  

  template <class A,
            class E1 = End, 
            class E2 = End, 
            class E3 = End, 
            class E4 = End, 
            class E5 = End, 
            class E6 = End, 
            class E7 = End, 
            class E8 = End, 
            class E9 = End>
  struct MixinTree 
    : E1::template I<A>, MixinTree<A, E2, E3, E4, E5, E6, E7, E8, E9> {
    
    typedef MixinTree<A, E2, E3, E4, E5, E6, E7, E8, E9> Parent;
    
    static void map_feature_handlers(FeatureHandlerMap& hmap) {
      E1::template I<A>::map_feature_handlers(hmap);
      Parent::map_feature_handlers(hmap);
    }
    
    bool check_ok() { 
      return E1::template I<A>::check_ok() && Parent::check_ok();
    }
    
    static const void* extension_data(const char* uri) {
      const void* result = E1::template I<A>::extension_data(uri);
      if (result)
        return result;
      return Parent::extension_data(uri);
    }
    
  };


  template <class A>
  struct MixinTree<A, End, End, End, End, End, End, End, End, End> {
    static void map_feature_handlers(FeatureHandlerMap& hmap) { }
    bool check_ok() const { return true; }
    static const void* extension_data(const char* uri) { return 0; }
  };


  template <bool Required>
  struct Extension {
    
    Extension() : m_ok(!Required) { }
    
    static void map_feature_handlers(FeatureHandlerMap& hmap) { }
    
    bool check_ok() { return m_ok; }
  
    static const void* extension_data(const char* uri) { return 0; }
  
  protected:
  
    bool m_ok;
  
  };


  template <bool Required = true>
  struct URIMap {
    
    template <class Derived> struct I : Extension<Required> {
      
      I() : m_callback_data(0), m_func(0) { }
      
      static void map_feature_handlers(FeatureHandlerMap& hmap) {
        hmap[LV2_URI_MAP_URI] = &I<Derived>::handle_feature;
      }
      
      static void handle_feature(void* instance, void* data) { 
        Derived* d = reinterpret_cast<Derived*>(instance);
        I<Derived>* fe = static_cast<I<Derived>*>(d);
        LV2_URI_Map_Feature* umf = reinterpret_cast<LV2_URI_Map_Feature*>(data);
        fe->m_callback_data = umf->callback_data;
        fe->m_func = umf->uri_to_id;
        fe->m_ok = (fe->m_func != 0);
      }
      
    protected:
      
      uint32_t uri_to_id(const char* map, const char* uri) const {
        return m_func(m_callback_data, map, uri);
      }
    
      LV2_URI_Map_Callback_Data m_callback_data;
      uint32_t (*m_func)(LV2_URI_Map_Callback_Data, const char*, const char*);
      
    };
    
  };
  

  
}


#endif