NET_Performance.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_Performance.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __NET_PERFORMANCE_H__
#define __NET_PERFORMANCE_H__

#include "NET_API.h"

#include "NET_PacketConnectionHandler.h"
#include "NET_SocketListener.h"

#include <UT/UT_Performance.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_WorkBuffer.h>
#include <UT/UT_Lock.h>

class NET_API NET_Performance : public UT_Performance
{
public:
    class net_PacketConnectionHandler : public NET_IPacketConnectionHandler
    {
    public:
        net_PacketConnectionHandler(
                NET_ConnectionManager& mgr,
                ASIO_TCPSocket socket)
            : NET_IPacketConnectionHandler(mgr, std::move(socket))
            , myFrameNum(0)
            , myValue(0)
        {
        }

        void onPacket(UT_WorkBuffer&& data) override;

    private:
        void registerRemoteEvent(
                const UT_StringHolder& type,
                const UT_StringHolder& category_name,
                int frame_num,
                const UT_StringHolder& object,
                const UT_StringHolder& object_type,
                fpreal value);

        enum eventReadState
        {
            needEventType,
            needEventCategory,
            needEventFrame,
            needEventObject,
            needEventObjectType,
            needEventValue
        };

        eventReadState myReadState;
        UT_StringHolder myEventType;
        UT_StringHolder myCategory;
        UT_StringHolder myObject;
        UT_StringHolder myObjectType;
        int myFrameNum;
        fpreal myValue;
    };

    class net_PacketListener : public NET_SocketListener<ASIO_TCPAcceptor>
    {
    public:
        net_PacketListener(ASIO_IOContext::executor_type& exc) :
            NET_SocketListener<ASIO_TCPAcceptor>(exc)
        {}

    private:
        void onAccept_(
                const hboost::system::error_code& ec,
                ASIO_TCPSocket socket) override
        {
            if (!ec && socket.is_open())
            {
                auto handler = UTmakeShared<net_PacketConnectionHandler>(
                        myConnectionManager, std::move(socket));
                myConnectionManager.start(handler);
            }
        }
    };

    NET_Performance();

    void closeListener();

    int getEventListenPort() const override
    {
        return myPacketListener ? myPacketListener->port() : 0;
    }

protected:
    void startListener_(ASIO_IOContext::executor_type exc);

private:
    UT_Lock myInitLock;
    UT_SharedPtr<net_PacketListener> myPacketListener;
};

#endif // __NET_PERFORMANCE_H__