ClientContext.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_ContextImpl_h_GUID_9000C62E_3693_4888_83A2_0D26F4591B6A
#define INCLUDED_ContextImpl_h_GUID_9000C62E_3693_4888_83A2_0D26F4591B6A

// Internal Includes
#include <osvr/Common/Export.h>
#include <osvr/Common/ClientContext_fwd.h>
#include <osvr/Common/ClientInterfacePtr.h>
#include <osvr/Common/PathTree_fwd.h>
#include <osvr/Common/Transform_fwd.h>
#include <osvr/Common/ClientInterfaceFactory.h>
#include <osvr/Util/KeyedOwnershipContainer.h>
#include <osvr/Util/UniquePtr.h>
#include <osvr/Util/SharedPtr.h>
#include <osvr/Util/LogLevel.h>
#include <osvr/Util/Logger.h>

// Library/third-party includes
#include <boost/noncopyable.hpp>
#include <boost/any.hpp>

// Standard includes
#include <string>
#include <vector>
#include <map>

struct OSVR_ClientContextObject : boost::noncopyable {
  public:
    typedef std::vector<osvr::common::ClientInterfacePtr> InterfaceList;
    OSVR_COMMON_EXPORT virtual ~OSVR_ClientContextObject();

    OSVR_COMMON_EXPORT void update();

    std::string const &getAppId() const;

    OSVR_COMMON_EXPORT osvr::common::ClientInterfacePtr
    getInterface(const char path[]);

    OSVR_COMMON_EXPORT osvr::common::ClientInterfacePtr
    releaseInterface(osvr::common::ClientInterface *iface);

    InterfaceList const &getInterfaces() const { return m_interfaces; }

    OSVR_COMMON_EXPORT void sendRoute(std::string const &route);

    OSVR_COMMON_EXPORT std::string
    getStringParameter(std::string const &path) const;

    OSVR_COMMON_EXPORT osvr::common::PathTree const &getPathTree() const;

    template <typename T> void *acquireObject(T obj) {
        return m_ownedObjects.acquire(obj);
    }

    OSVR_COMMON_EXPORT bool releaseObject(void *obj);

    OSVR_COMMON_EXPORT osvr::common::Transform const &
    getRoomToWorldTransform() const;

    OSVR_COMMON_EXPORT void
    setRoomToWorldTransform(osvr::common::Transform const &xform);

    OSVR_COMMON_EXPORT osvr::common::ClientContextDeleter getDeleter() const;

    OSVR_COMMON_EXPORT bool getStatus() const;

    OSVR_COMMON_EXPORT void log(osvr::util::log::LogLevel severity,
                                const char *message);

    OSVR_COMMON_EXPORT osvr::util::log::LoggerPtr const &logger() const;

  protected:
    OSVR_COMMON_EXPORT
    OSVR_ClientContextObject(const char appId[],
                             osvr::common::ClientContextDeleter del);
    OSVR_COMMON_EXPORT
    OSVR_ClientContextObject(
        const char appId[],
        osvr::common::ClientInterfaceFactory const &interfaceFactory,
        osvr::common::ClientContextDeleter del);

  private:
    virtual void m_update() = 0;
    virtual void m_sendRoute(std::string const &route) = 0;
    OSVR_COMMON_EXPORT virtual bool m_getStatus() const;
    OSVR_COMMON_EXPORT virtual void
    m_handleNewInterface(osvr::common::ClientInterfacePtr const &iface);
    OSVR_COMMON_EXPORT virtual void
    m_handleReleasingInterface(osvr::common::ClientInterfacePtr const &iface);

    OSVR_COMMON_EXPORT virtual osvr::common::PathTree const &
    m_getPathTree() const = 0;

    virtual osvr::common::Transform const &
    m_getRoomToWorldTransform() const = 0;

    virtual void
    m_setRoomToWorldTransform(osvr::common::Transform const &xform) = 0;

    std::string const m_appId;
    InterfaceList m_interfaces;
    osvr::common::ClientInterfaceFactory m_clientInterfaceFactory;

    osvr::util::MultipleKeyedOwnershipContainer m_ownedObjects;
    osvr::common::ClientContextDeleter m_deleter;

    osvr::util::log::LoggerPtr m_logger;
    osvr::util::log::LoggerPtr m_clientLogger;
};

namespace osvr {
namespace common {
    OSVR_COMMON_EXPORT void deleteContext(ClientContext *ctx);

    namespace detail {
        class ClientContextDeleter {
            void operator()(ClientContext *ctx) const {
                if (ctx) {
                    deleteContext(ctx);
                }
            }
        };
        namespace {
            template <typename T>
            inline void context_deleter(ClientContext *obj) {
                T *o = static_cast<T *>(obj);
                delete o;
            }
        } // namespace
    }     // namespace detail

    template <typename T = ClientContext>
    using ClientContextUniquePtr = unique_ptr<T, ClientContextDeleter>;
    using ClientContextSharedPtr = shared_ptr<ClientContext>;

    template <typename T, typename... Args>
    inline T *makeContext(Args... args) {
        return new T(std::forward<Args>(args)..., &detail::context_deleter<T>);
    }

    template <typename T>
    inline ClientContextSharedPtr wrapSharedContext(T *context) {
        ClientContextSharedPtr ret(context, &deleteContext);
        return ret;
    }
} // namespace common
} // namespace osvr

#endif // INCLUDED_ContextImpl_h_GUID_9000C62E_3693_4888_83A2_0D26F4591B6A