PluginRegistration.h

Go to the documentation of this file.

// Copyright 2014 Sensics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef INCLUDED_PluginRegistration_h_GUID_4F5D6422_2977_40A9_8BA0_F86FD6245CE9
#define INCLUDED_PluginRegistration_h_GUID_4F5D6422_2977_40A9_8BA0_F86FD6245CE9

// Internal Includes
#include <osvr/PluginKit/PluginRegistrationC.h>
#include <osvr/Util/GenericDeleter.h>
#include <osvr/Util/GenericCaller.h>
#include <osvr/Util/BoostIsCopyConstructible.h>

// Library/third-party includes
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/static_assert.hpp>

// Standard includes
#include <cstddef>
#include <string>
#include <stdexcept>

namespace osvr {
namespace pluginkit {
    template <typename T>
    inline T *registerObjectForDeletion(OSVR_PluginRegContext ctx, T *obj) {
        OSVR_ReturnCode ret = osvrPluginRegisterDataWithDeleteCallback(
            ctx, &::osvr::util::generic_deleter<T>, static_cast<void *>(obj));
        if (ret != OSVR_RETURN_SUCCESS) {
            throw std::runtime_error("registerObjectForDeletion failed!");
        }
        return obj;
    }

#ifndef OSVR_DOXYGEN_EXTERNAL
    namespace detail {
        template <typename T>
        inline OSVR_ReturnCode registerHardwareDetectCallbackImpl(
            OSVR_PluginRegContext ctx, T functor,
            typename boost::enable_if<boost::is_pointer<T> >::type * = NULL) {
            typedef typename boost::remove_pointer<T>::type FunctorType;
            registerObjectForDeletion(ctx, functor);
            return osvrPluginRegisterHardwareDetectCallback(
                ctx, &util::GenericCaller<OSVR_HardwareDetectCallback,
                                          FunctorType, util::this_last_t>::call,
                static_cast<void *>(functor));
        }

        template <typename T>
        inline OSVR_ReturnCode registerHardwareDetectCallbackImpl(
            OSVR_PluginRegContext ctx, T functor,
            typename boost::disable_if<boost::is_pointer<T> >::type * = NULL) {
#ifdef OSVR_HAVE_BOOST_IS_COPY_CONSTRUCTIBLE
            BOOST_STATIC_ASSERT_MSG(boost::is_copy_constructible<T>::value,
                                    "Hardware detect callback functors must be "
                                    "either passed as a pointer or be "
                                    "copy-constructible");
#endif
            T *functorCopy = new T(functor);
            return registerHardwareDetectCallbackImpl(ctx, functorCopy);
        }

        template <typename T>
        inline OSVR_ReturnCode registerDriverInstantiationCallbackImpl(
            OSVR_PluginRegContext ctx, const char driverName[], T functor,
            typename boost::enable_if<boost::is_pointer<T> >::type * = NULL) {
            typedef typename boost::remove_pointer<T>::type FunctorType;
            registerObjectForDeletion(ctx, functor);
            return osvrRegisterDriverInstantiationCallback(
                ctx, driverName,
                &util::GenericCaller<OSVR_DriverInstantiationCallback,
                                     FunctorType, util::this_last_t>::call,
                static_cast<void *>(functor));
        }
        template <typename T>
        inline OSVR_ReturnCode registerDriverInstantiationCallbackImpl(
            OSVR_PluginRegContext ctx, const char driverName[], T functor,
            typename boost::disable_if<boost::is_pointer<T> >::type * = NULL) {
#ifdef OSVR_HAVE_BOOST_IS_COPY_CONSTRUCTIBLE
            BOOST_STATIC_ASSERT_MSG(
                boost::is_copy_constructible<T>::value,
                "Driver instantiation callback functors must be "
                "either passed as a pointer or be "
                "copy-constructible");
#endif
            T *functorCopy = new T(functor);
            return registerDriverInstantiationCallbackImpl(ctx, driverName,
                                                           functorCopy);
        }
    } // namespace detail
#endif

    template <typename T>
    inline void registerHardwareDetectCallback(OSVR_PluginRegContext ctx,
                                               T functor) {
        OSVR_ReturnCode ret =
            detail::registerHardwareDetectCallbackImpl(ctx, functor);
        if (ret != OSVR_RETURN_SUCCESS) {
            throw std::runtime_error("registerHardwareDetectCallback failed!");
        }
    }

    template <typename T>
    inline void registerDriverInstantiationCallback(OSVR_PluginRegContext ctx,
                                                    const char driverName[],
                                                    T functor) {
        OSVR_ReturnCode ret = detail::registerDriverInstantiationCallbackImpl(
            ctx, driverName, functor);
        if (ret != OSVR_RETURN_SUCCESS) {
            throw std::runtime_error(
                "registerDriverInstantiationCallback failed!");
        }
    }

    inline void log(OSVR_PluginRegContext ctx, OSVR_LogLevel severity,
             const char *message) {
        osvrPluginLog(ctx, severity, message);
    }

} // namespace pluginkit
} // namespace osvr

#endif // INCLUDED_PluginRegistration_h_GUID_4F5D6422_2977_40A9_8BA0_F86FD6245CE9