RemoteConnectionPool.h

Go to the documentation of this file.

/*
 * Copyright (C) by
 *   MetraLabs GmbH (MLAB), GERMANY
 * All rights reserved.
 *
 * Redistribution and modification of this code is strictly prohibited.
 *
 * IN NO EVENT SHALL "MLAB" BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
 * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
 * OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLABS" HS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN
 * "AS IS" BASIS, AND "MLAB" HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
 * SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_FRAMEWORK_INCLUDE_FW_REMOTE_INTERNAL_REMOTECONNECTIONPOOL_H_
#define _MIRA_FRAMEWORK_INCLUDE_FW_REMOTE_INTERNAL_REMOTECONNECTIONPOOL_H_

#include <unordered_map>

#include <serialization/IsTransparentSerializable.h>
#include <fw/RemoteConnection.h>

namespace mira {


// forward declarations
class RemoteOutgoingConnectionBase;
class RemoteIncomingConnection;
class RemoteConnection;
struct KnownFramework;

class RemoteConnectionPool;

class RemoteConnectionProxy : boost::noncopyable
{
    friend class RemoteConnectionPool;
public:
    RemoteConnectionProxy() : mRemoteConnectionPool(nullptr), mRemoteConnection(nullptr) {};
    RemoteConnectionProxy (RemoteConnectionProxy&&) noexcept;
    RemoteConnectionProxy& operator= (RemoteConnectionProxy&&) noexcept;

    ~RemoteConnectionProxy();

    friend void swap(RemoteConnectionProxy& a, RemoteConnectionProxy& b);

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        r.delegate(mRemoteConnection);
    }

    const RemoteConnection* operator->() const { return mRemoteConnection; }
    RemoteConnection* operator->() { return mRemoteConnection; }

    const RemoteConnection& operator*() const  { return *mRemoteConnection; }
    RemoteConnection& operator*()  { return *mRemoteConnection; }

    const RemoteConnection* get() const { return mRemoteConnection; }
    RemoteConnection* get() { return mRemoteConnection; }

    bool valid() const;

    bool operator== (const RemoteConnection* other) const { return mRemoteConnection == other; }

private:
    // only the RemoteConnectionPool has access and can create a valid instance
    RemoteConnectionProxy(RemoteConnectionPool*, RemoteConnection*);

private:
    RemoteConnectionPool* mRemoteConnectionPool;
    RemoteConnection* mRemoteConnection;
};

template <typename SerializerTag>
class IsTransparentSerializable<RemoteConnectionProxy, SerializerTag> : public std::true_type {};


class RemoteConnectionPool
{
    friend RemoteConnectionProxy;
public:
    RemoteConnectionProxy createRemoteOutgoingConnection(const KnownFramework& address);

    RemoteConnectionProxy createRemoteIncomingConnection();

    void releaseStoppedConnections();

protected:
    mutable boost::recursive_mutex mConnectionsMutex;

    void stopConnection(RemoteConnection* connection);

    std::set<RemoteConnection*> mRemoteConnections;

    std::vector<std::unique_ptr<RemoteConnection>> mStoppedConnections;
};



} // namespace

#endif