Connection.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_Connection_h_GUID_61C65986_E2C9_498F_59F0_8EFC712BA183
#define INCLUDED_Connection_h_GUID_61C65986_E2C9_498F_59F0_8EFC712BA183

// Internal Includes
#include <osvr/Connection/Export.h>
#include <osvr/Connection/MessageTypePtr.h>
#include <osvr/Connection/ConnectionDevicePtr.h>
#include <osvr/Connection/ConnectionPtr.h>
#include <osvr/Connection/DeviceInitObject.h>
#include <osvr/Util/DeviceCallbackTypesC.h>
#include <osvr/PluginHost/RegistrationContext_fwd.h>
#include <osvr/Util/Log.h>

// Library/third-party includes
#include <boost/noncopyable.hpp>
#include <boost/optional.hpp>
#include <boost/range/iterator_range.hpp>

// Standard includes
#include <string>
#include <vector>
#include <functional>
#include <tuple>

namespace osvr {
namespace connection {

    class Connection : boost::noncopyable,
                       public enable_shared_from_this<Connection> {
      public:
        OSVR_CONNECTION_EXPORT static ConnectionPtr createLocalConnection();
        OSVR_CONNECTION_EXPORT static ConnectionPtr
        createSharedConnection(boost::optional<std::string const &> iface,
                               boost::optional<int> port);

        OSVR_CONNECTION_EXPORT static std::tuple<void *, ConnectionPtr>
        createLoopbackConnection();

        OSVR_CONNECTION_EXPORT static ConnectionPtr
        retrieveConnection(const pluginhost::RegistrationContext &ctx);
        OSVR_CONNECTION_EXPORT static void
        storeConnection(pluginhost::RegistrationContext &ctx,
                        ConnectionPtr conn);

        OSVR_CONNECTION_EXPORT MessageTypePtr
        registerMessageType(std::string const &messageId);

        OSVR_CONNECTION_EXPORT ConnectionDevicePtr
        createConnectionDevice(std::string const &deviceName);

        OSVR_CONNECTION_EXPORT ConnectionDevicePtr
        createConnectionDevice(DeviceInitObject &init);

        OSVR_CONNECTION_EXPORT void addDevice(ConnectionDevicePtr device);

        OSVR_CONNECTION_EXPORT void process();

        OSVR_CONNECTION_EXPORT void
        registerConnectionHandler(std::function<void()> handler);

        OSVR_CONNECTION_EXPORT void
        registerDescriptorHandler(std::function<void()> handler);

        OSVR_CONNECTION_EXPORT void triggerDescriptorHandlers();

        OSVR_CONNECTION_EXPORT virtual ~Connection();

        typedef std::vector<ConnectionDevicePtr> DeviceList;

        boost::iterator_range<DeviceList::const_iterator> getDevices() const {
            return boost::make_iterator_range(begin(m_devices), end(m_devices));
        }


        OSVR_CONNECTION_EXPORT ConnectionDevicePtr registerAdvancedDevice(
            std::string const &deviceName,
            OSVR_DeviceUpdateCallback updateFunction, void *userdata);

        typedef std::vector<std::string> NameList;

        OSVR_CONNECTION_EXPORT ConnectionDevicePtr registerAdvancedDevice(
            NameList const &deviceNames,
            OSVR_DeviceUpdateCallback updateFunction, void *userdata);

        OSVR_CONNECTION_EXPORT virtual void *getUnderlyingObject();

        OSVR_CONNECTION_EXPORT virtual const char *getConnectionKindID();

      protected:
        virtual MessageTypePtr
        m_registerMessageType(std::string const &messageId) = 0;

        virtual ConnectionDevicePtr
        m_createConnectionDevice(DeviceInitObject &init) = 0;

        virtual void
        m_registerConnectionHandler(std::function<void()> handler) = 0;

        virtual void m_process() = 0;

        Connection();

      private:
        DeviceList m_devices;
        std::vector<std::function<void()> > m_descriptorHandlers;
        util::log::LoggerPtr m_log;
    };
} // namespace connection
} // namespace osvr
#endif // INCLUDED_Connection_h_GUID_61C65986_E2C9_498F_59F0_8EFC712BA183