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;

private:
    /// Only the connection manager should be touching this information.
    UT_SharedPtr<NET_ConnectionHandler> myNext;
    UT_WeakPtr<NET_ConnectionHandler> myPrev;
};

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);
            handler->myNext = myConnections;
            handler->myPrev.reset();
            if (myConnections)
                myConnections->myPrev = handler;
            myConnections = handler;
        }
        handler->start();
    }
    void stop(const NET_ConnectionHandlerSPtr& handler)
    {
        UT_ASSERT(handler != nullptr);
        {
            UT_AutoLock lock(myLock);
            remove(handler);
        }
        handler->stop(true /*force*/);
    }
    void remove(const NET_ConnectionHandlerSPtr& handler)
    {
        UT_ASSERT(handler != nullptr);
        UT_AutoLock lock(myLock);
        remove_(handler);
    }
    void stopAll(bool force)
    {   
        // 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.
        UT_AutoLock lock(myLock);
        auto head = myConnections;
        myConnections = nullptr;
        while (head != nullptr)
        {
            auto next = head->myNext;
            // Make sure to clear the next and prev so that if stop() calls
            // remove() it doesnt effect our actual next handler to run after
            // the stop().
            head->myNext.reset();
            head->myPrev.reset();
            head->stop(force);
            head = next;
        }
    }

private:
    void remove_(const NET_ConnectionHandlerSPtr& handler)
    {
        UT_ASSERT(handler != nullptr);
        if (myConnections == handler)
            myConnections = handler->myNext;
        if (auto prev = handler->myPrev.lock(); prev != nullptr)
            prev->myNext = handler->myNext;
        if (handler->myNext)
            handler->myNext->myPrev = handler->myPrev;
    }

    UT_Lock myLock;
    UT_SharedPtr<NET_ConnectionHandler> myConnections;
};

#endif // __NET_CONNECTIONHANDLER_H__