epics::pvAccess::ServerArrayHandler Class Reference

#include "responseHandlers.h"

Inheritance diagram for epics::pvAccess::ServerArrayHandler:

Collaboration diagram for epics::pvAccess::ServerArrayHandler:

Public Member Functions
	ServerArrayHandler (ServerContextImpl::shared_pointer const &context)
virtual	~ServerArrayHandler ()
virtual void	handleResponse (osiSockAddr *responseFrom, Transport::shared_pointer const &transport, epics::pvData::int8 version, epics::pvData::int8 command, std::size_t payloadSize, epics::pvData::ByteBuffer *payloadBuffer) OVERRIDE FINAL
Public Member Functions inherited from epics::pvAccess::AbstractServerResponseHandler
	AbstractServerResponseHandler (ServerContextImpl::shared_pointer const &context, std::string description)
virtual	~AbstractServerResponseHandler ()
Public Member Functions inherited from epics::pvAccess::ResponseHandler
	POINTER_DEFINITIONS (ResponseHandler)
	ResponseHandler (Context *context, const std::string &description)
virtual	~ResponseHandler ()

Additional Inherited Members
Static Public Attributes inherited from epics::pvAccess::ResponseHandler
static size_t	num_instances
Protected Attributes inherited from epics::pvAccess::AbstractServerResponseHandler
ServerContextImpl::shared_pointer	_context
Protected Attributes inherited from epics::pvAccess::ResponseHandler
std::string	_description
epics::pvData::int32	_debugLevel

Detailed Description

Array request handler.

Definition at line 521 of file responseHandlers.h.

Constructor & Destructor Documentation

epics::pvAccess::ServerArrayHandler::ServerArrayHandler ( ServerContextImpl::shared_pointer const &  context )

inline

Definition at line 524 of file responseHandlers.h.

                                                                        :
        AbstractServerResponseHandler(context, "Array request") {
    }

virtual epics::pvAccess::ServerArrayHandler::~ServerArrayHandler ( )

inlinevirtual

Definition at line 527 of file responseHandlers.h.

{}

Member Function Documentation

void epics::pvAccess::ServerArrayHandler::handleResponse ( osiSockAddr *  responseFrom, Transport::shared_pointer const &  transport, epics::pvData::int8  version, epics::pvData::int8  command, std::size_t  payloadSize, epics::pvData::ByteBuffer *  payloadBuffer  )

virtual

Handle response.

Parameters

[in]	responseFrom	remote address of the responder, 0 if unknown.
[in]	transport	response source transport.
[in]	version	message version.
[in]	payloadSize	size of this message data available in the payloadBuffer.
[in]	payloadBuffer	message payload data. Note that this might not be the only message in the buffer. Code must not manipulate buffer.

Reimplemented from epics::pvAccess::ResponseHandler.

Definition at line 2113 of file responseHandlers.cpp.

                                                                                       {
    AbstractServerResponseHandler::handleResponse(responseFrom,
            transport, version, command, payloadSize, payloadBuffer);

    // NOTE: we do not explicitly check if transport is OK
    detail::BlockingServerTCPTransportCodec* casTransport(static_cast<detail::BlockingServerTCPTransportCodec*>(transport.get()));

    transport->ensureData(2*sizeof(int32)/sizeof(int8)+1);
    const pvAccessID sid = payloadBuffer->getInt();
    const pvAccessID ioid = payloadBuffer->getInt();

    // mode
    const int8 qosCode = payloadBuffer->getByte();

    ServerChannel::shared_pointer channel = casTransport->getChannel(sid);
    if (!channel.get())
    {
        BaseChannelRequester::sendFailureMessage((int8)CMD_ARRAY, transport, ioid, qosCode, BaseChannelRequester::badCIDStatus);
        return;
    }

    const bool init = (QOS_INIT & qosCode) != 0;
    if (init)
    {
        // pvRequest
        PVStructure::shared_pointer pvRequest(SerializationHelper::deserializePVRequest(payloadBuffer, transport.get()));

        // create...
        ServerChannelArrayRequesterImpl::create(_context, channel, ioid, transport, pvRequest);
    }
    else
    {
        const bool lastRequest = (QOS_DESTROY & qosCode) != 0;
        const bool get = (QOS_GET & qosCode) != 0;
        const bool setLength = (QOS_GET_PUT & qosCode) != 0;
        const bool getLength = (QOS_PROCESS & qosCode) != 0;

        ServerChannelArrayRequesterImpl::shared_pointer request = static_pointer_cast<ServerChannelArrayRequesterImpl>(channel->getRequest(ioid));
        if (!request.get())
        {
            BaseChannelRequester::sendFailureMessage((int8)CMD_ARRAY, transport, ioid, qosCode, BaseChannelRequester::badIOIDStatus);
            return;
        }
        atomic::add(request->bytesRX, payloadSize);

        if (!request->startRequest(qosCode))
        {
            BaseChannelRequester::sendFailureMessage((int8)CMD_ARRAY, transport, ioid, qosCode, BaseChannelRequester::otherRequestPendingStatus);
            return;
        }

        ChannelArray::shared_pointer channelArray = request->getChannelArray();
        if (lastRequest)
            channelArray->lastRequest();

        if (get)
        {
            size_t offset = SerializeHelper::readSize(payloadBuffer, transport.get());
            size_t count = SerializeHelper::readSize(payloadBuffer, transport.get());
            size_t stride = SerializeHelper::readSize(payloadBuffer, transport.get());

            request->getChannelArray()->getArray(offset, count, stride);
        }
        else if (setLength)
        {
            size_t length = SerializeHelper::readSize(payloadBuffer, transport.get());

            request->getChannelArray()->setLength(length);
        }
        else if (getLength)
        {
            request->getChannelArray()->getLength();
        }
        else
        {
            // deserialize data to put
            size_t offset;
            size_t stride;
            PVArray::shared_pointer array = request->getPVArray();
            {
                ScopedLock lock(channelArray);   // TODO not needed if read by the same thread

                DESERIALIZE_EXCEPTION_GUARD(
                    offset = SerializeHelper::readSize(payloadBuffer, transport.get());
                    stride = SerializeHelper::readSize(payloadBuffer, transport.get());
                    array->deserialize(payloadBuffer, transport.get());
                );
            }

            channelArray->putArray(array, offset, array->getLength(), stride);
        }
    }
}

---

The documentation for this class was generated from the following files:

• modules/pvAccess/src/server/pv/responseHandlers.h
• modules/pvAccess/src/server/responseHandlers.cpp