NET_ConnectionHandler.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_ConnectionHandler.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_CONNECTIONHANDLER_H__
#define __NET_CONNECTIONHANDLER_H__

#include "NET_API.h"

#include "NET_Error.h"
#include "NET_InfoCallback.h"

#include <UT/UT_Debug.h>
#include <UT/UT_BoostAsio.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_Set.h>
#include <UT/UT_Lock.h>
#include <UT/UT_SharedPtr.h>

#include <SYS/SYS_AtomicInt.h>

class NET_ConnectionManager;

class NET_API NET_ConnectionHandler : public UT_NonCopyable
{
public:
    virtual ~NET_ConnectionHandler() {}
    UT_NON_COPYABLE(NET_ConnectionHandler);

    void setInfoCallback(UT_UniquePtr<NET_InfoCallback> info_clb)
    {
        myInfoCallback = std::move(info_clb);
    }
protected:
    NET_ConnectionHandler(NET_ConnectionManager& conn_mgr) :
        myConnectionManager(conn_mgr)
    {
    }

    friend class NET_ConnectionManager;

    virtual void start() = 0;
    virtual void stop(bool force) = 0;

    NET_ConnectionManager& myConnectionManager;

    UT_UniquePtr<NET_InfoCallback> myInfoCallback;
};

using NET_ConnectionHandlerSPtr = UT_SharedPtr<NET_ConnectionHandler>;

class NET_API NET_ConnectionManager : public UT_NonCopyable
{
public:
    void start(const NET_ConnectionHandlerSPtr& handler)
    {
        UT_ASSERT(handler != nullptr);
        {
            UT_AutoLock lock(myLock);
            myConnections.insert(handler);
        }
        handler->start();
    }
    void stop(const NET_ConnectionHandlerSPtr& handler)
    {
        UT_ASSERT(handler != nullptr);
        {
            UT_AutoLock lock(myLock);
            myConnections.erase(handler);
        }
        handler->stop(true /*force*/);
    }
    void remove(const NET_ConnectionHandlerSPtr& handler)
    {
        UT_ASSERT(handler != nullptr);
        UT_AutoLock lock(myLock);
        myConnections.erase(handler);
    }
    void stopAll(bool force)
    {
        UT_Set<NET_ConnectionHandlerSPtr> connections;
        {
            UT_AutoLock lock(myLock);
            myConnections.swap(connections);
            myConnections.clear();
        }
        // It is possible that the stop calls back into this objects stop which
        // will invalidate the iterator. Use a temp object to hold the
        // connections we need to stop to ensure calling stop from within
        // the users stop doesnt cause undefined behaviour.
        for (auto&& handler : connections)
        {
            UT_ASSERT(handler != nullptr);
            handler->stop(force);
        }
    }

private:
    UT_Lock myLock;
    UT_Set<NET_ConnectionHandlerSPtr> myConnections;
};

#endif // __NET_CONNECTIONHANDLER_H__