592 lines
19 KiB
C++
592 lines
19 KiB
C++
|
|
/* testRemoteClientImpl.cpp */
|
|
/* Author: Matej Sekoranja Date: 2011.1.1 */
|
|
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <epicsExit.h>
|
|
#include <pv/clientContextImpl.h>
|
|
#include <pv/clientFactory.h>
|
|
|
|
using namespace epics::pvData;
|
|
using namespace epics::pvAccess;
|
|
|
|
|
|
class ChannelFindRequesterImpl : public ChannelFindRequester
|
|
{
|
|
virtual void channelFindResult(const epics::pvData::Status& status,
|
|
ChannelFind::shared_pointer const & /*channelFind*/,
|
|
bool wasFound)
|
|
{
|
|
std::cout << "[ChannelFindRequesterImpl] channelFindResult("
|
|
<< status.toString() << ", ..., " << wasFound << ")" << std::endl;
|
|
}
|
|
};
|
|
|
|
class ChannelRequesterImpl : public ChannelRequester
|
|
{
|
|
virtual String getRequesterName()
|
|
{
|
|
return "ChannelRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void channelCreated(const epics::pvData::Status& status, Channel::shared_pointer const & channel)
|
|
{
|
|
std::cout << "channelCreated(" << status.toString() << ", "
|
|
<< (channel ? channel->getChannelName() : "(0)") << ")" << std::endl;
|
|
}
|
|
|
|
virtual void channelStateChange(Channel::shared_pointer const & c, Channel::ConnectionState connectionState)
|
|
{
|
|
std::cout << "channelStateChange(" << c->getChannelName() << ", " << Channel::ConnectionStateNames[connectionState] << ")" << std::endl;
|
|
}
|
|
};
|
|
|
|
class GetFieldRequesterImpl : public GetFieldRequester
|
|
{
|
|
virtual String getRequesterName()
|
|
{
|
|
return "GetFieldRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void getDone(const epics::pvData::Status& status,epics::pvData::FieldConstPtr const & field)
|
|
{
|
|
std::cout << "getDone(" << status.toString() << ", ";
|
|
if (status.isSuccess() && field)
|
|
{
|
|
String str;
|
|
field->toString(&str);
|
|
std::cout << str;
|
|
}
|
|
else
|
|
std::cout << "(0)";
|
|
std::cout << ")" << std::endl;
|
|
}
|
|
};
|
|
|
|
class ChannelGetRequesterImpl : public ChannelGetRequester
|
|
{
|
|
private:
|
|
|
|
//ChannelGet::shared_pointer m_channelGet;
|
|
epics::pvData::PVStructure::shared_pointer m_pvStructure;
|
|
epics::pvData::BitSet::shared_pointer m_bitSet;
|
|
|
|
public:
|
|
|
|
virtual String getRequesterName()
|
|
{
|
|
return "ChannelGetRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void channelGetConnect(const epics::pvData::Status& status,ChannelGet::shared_pointer const & /*channelGet*/,
|
|
epics::pvData::PVStructure::shared_pointer const & pvStructure,
|
|
epics::pvData::BitSet::shared_pointer const & bitSet)
|
|
{
|
|
std::cout << "channelGetConnect(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String st;
|
|
pvStructure->toString(&st);
|
|
std::cout << st << std::endl;
|
|
}
|
|
|
|
//m_channelGet = channelGet;
|
|
m_pvStructure = pvStructure;
|
|
m_bitSet = bitSet;
|
|
}
|
|
|
|
virtual void getDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "getDone(" << status.toString() << ")" << std::endl;
|
|
|
|
if (status.isSuccess())
|
|
{
|
|
String str;
|
|
m_pvStructure->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
};
|
|
|
|
class ChannelPutRequesterImpl : public ChannelPutRequester
|
|
{
|
|
private:
|
|
|
|
//ChannelPut::shared_pointer m_channelPut;
|
|
epics::pvData::PVStructure::shared_pointer m_pvStructure;
|
|
epics::pvData::BitSet::shared_pointer m_bitSet;
|
|
|
|
public:
|
|
|
|
virtual String getRequesterName()
|
|
{
|
|
return "ChannelPutRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void channelPutConnect(const epics::pvData::Status& status,ChannelPut::shared_pointer const & /*channelPut*/,
|
|
epics::pvData::PVStructure::shared_pointer const & pvStructure,
|
|
epics::pvData::BitSet::shared_pointer const & bitSet)
|
|
{
|
|
std::cout << "channelPutConnect(" << status.toString() << ")" << std::endl;
|
|
|
|
//m_channelPut = channelPut;
|
|
m_pvStructure = pvStructure;
|
|
m_bitSet = bitSet;
|
|
}
|
|
|
|
virtual void getDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "getDone(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String str;
|
|
m_pvStructure->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
|
|
virtual void putDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "putDone(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String str;
|
|
m_pvStructure->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
class ChannelPutGetRequesterImpl : public ChannelPutGetRequester
|
|
{
|
|
private:
|
|
|
|
//ChannelPutGet::shared_pointer m_channelPutGet;
|
|
epics::pvData::PVStructure::shared_pointer m_putData;
|
|
epics::pvData::PVStructure::shared_pointer m_getData;
|
|
|
|
public:
|
|
|
|
virtual String getRequesterName()
|
|
{
|
|
return "ChannelGetPutRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void channelPutGetConnect(const epics::pvData::Status& status, ChannelPutGet::shared_pointer const & /*channelPutGet*/,
|
|
epics::pvData::PVStructure::shared_pointer const & putData,
|
|
epics::pvData::PVStructure::shared_pointer const & getData)
|
|
{
|
|
std::cout << "channelGetPutConnect(" << status.toString() << ")" << std::endl;
|
|
|
|
//m_channelPutGet = channelPutGet;
|
|
m_putData = putData;
|
|
m_getData = getData;
|
|
|
|
if (m_putData)
|
|
{
|
|
String str;
|
|
m_putData->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
if (m_getData)
|
|
{
|
|
String str;
|
|
m_getData->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
|
|
virtual void getGetDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "getGetDone(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String str;
|
|
m_getData->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
|
|
virtual void getPutDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "getPutDone(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String str;
|
|
m_putData->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
|
|
virtual void putGetDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "putGetDone(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String str;
|
|
m_putData->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
|
|
class ChannelRPCRequesterImpl : public ChannelRPCRequester
|
|
{
|
|
//ChannelRPC::shared_pointer m_channelRPC;
|
|
|
|
virtual String getRequesterName()
|
|
{
|
|
return "ChannelRPCRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void channelRPCConnect(const epics::pvData::Status& status,
|
|
ChannelRPC::shared_pointer const & /*channelRPC*/)
|
|
{
|
|
std::cout << "channelRPCConnect(" << status.toString() << ")" << std::endl;
|
|
|
|
//m_channelRPC = channelRPC;
|
|
}
|
|
|
|
virtual void requestDone(const epics::pvData::Status& status,epics::pvData::PVStructure::shared_pointer const & pvResponse)
|
|
{
|
|
std::cout << "requestDone(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String str;
|
|
pvResponse->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
};
|
|
|
|
class ChannelArrayRequesterImpl : public ChannelArrayRequester
|
|
{
|
|
private:
|
|
|
|
//ChannelArray::shared_pointer m_channelArray;
|
|
epics::pvData::PVArray::shared_pointer m_pvArray;
|
|
|
|
public:
|
|
|
|
virtual String getRequesterName()
|
|
{
|
|
return "ChannelArrayRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void channelArrayConnect(const epics::pvData::Status& status,ChannelArray::shared_pointer const & /*channelArray*/,
|
|
epics::pvData::PVArray::shared_pointer const & pvArray)
|
|
{
|
|
std::cout << "channelArrayConnect(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String st;
|
|
pvArray->toString(&st);
|
|
std::cout << st << std::endl;
|
|
}
|
|
|
|
//m_channelArray = channelArray;
|
|
m_pvArray = pvArray;
|
|
}
|
|
|
|
virtual void getArrayDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "getArrayDone(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess())
|
|
{
|
|
String str;
|
|
m_pvArray->toString(&str);
|
|
std::cout << str;
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
|
|
virtual void putArrayDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "putArrayDone(" << status.toString() << ")" << std::endl;
|
|
}
|
|
|
|
virtual void setLengthDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "setLengthDone(" << status.toString() << ")" << std::endl;
|
|
}
|
|
};
|
|
|
|
class MonitorRequesterImpl : public MonitorRequester
|
|
{
|
|
virtual String getRequesterName()
|
|
{
|
|
return "MonitorRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void monitorConnect(const epics::pvData::Status& status,
|
|
Monitor::shared_pointer const & /*monitor*/, StructureConstPtr const & structure)
|
|
{
|
|
std::cout << "monitorConnect(" << status.toString() << ")" << std::endl;
|
|
if (status.isSuccess() && structure)
|
|
{
|
|
String str;
|
|
structure->toString(&str);
|
|
std::cout << str << std::endl;
|
|
}
|
|
}
|
|
|
|
virtual void monitorEvent(Monitor::shared_pointer const & monitor)
|
|
{
|
|
std::cout << "monitorEvent" << std::endl;
|
|
|
|
MonitorElement::shared_pointer element = monitor->poll();
|
|
|
|
String str("changed/overrun ");
|
|
element->changedBitSet->toString(&str);
|
|
str += '/';
|
|
element->overrunBitSet->toString(&str);
|
|
str += '\n';
|
|
element->pvStructurePtr->toString(&str);
|
|
std::cout << str << std::endl;
|
|
|
|
monitor->release(element);
|
|
}
|
|
|
|
virtual void unlisten(Monitor::shared_pointer const & /*monitor*/)
|
|
{
|
|
std::cout << "unlisten" << std::endl;
|
|
}
|
|
};
|
|
|
|
|
|
class ChannelProcessRequesterImpl : public ChannelProcessRequester
|
|
{
|
|
//ChannelProcess::shared_pointer const & m_channelProcess;
|
|
|
|
virtual String getRequesterName()
|
|
{
|
|
return "ProcessRequesterImpl";
|
|
};
|
|
|
|
virtual void message(String const & message,MessageType messageType)
|
|
{
|
|
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << getMessageTypeName(messageType) << ")" << std::endl;
|
|
}
|
|
|
|
virtual void channelProcessConnect(const epics::pvData::Status& status,
|
|
ChannelProcess::shared_pointer const & /*channelProcess*/)
|
|
{
|
|
std::cout << "channelProcessConnect(" << status.toString() << ")" << std::endl;
|
|
|
|
//m_channelProcess = channelProcess;
|
|
}
|
|
|
|
virtual void processDone(const epics::pvData::Status& status)
|
|
{
|
|
std::cout << "processDone(" << status.toString() << ")" << std::endl;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
int main()
|
|
{
|
|
for (int i = 0; i < 10; i++) {
|
|
{
|
|
/*
|
|
ClientContextImpl::shared_pointer context = createClientContextImpl();
|
|
context->printInfo();
|
|
|
|
context->initialize();
|
|
context->printInfo();
|
|
|
|
epicsThreadSleep ( 1.0 );
|
|
|
|
ChannelProvider::shared_pointer provider = context->getProvider();
|
|
*/
|
|
|
|
ClientFactory::start();
|
|
ChannelProvider::shared_pointer provider = getChannelAccess()->getProvider("pvAccess");
|
|
|
|
ChannelFindRequester::shared_pointer findRequester(new ChannelFindRequesterImpl());
|
|
ChannelFind::shared_pointer channelFind = provider->channelFind("something", findRequester);
|
|
epicsThreadSleep ( 1.0 );
|
|
//channelFind->destroy();
|
|
|
|
ChannelRequester::shared_pointer channelRequester(new ChannelRequesterImpl());
|
|
Channel::shared_pointer channel = provider->createChannel("structureArrayTest", channelRequester);
|
|
epicsThreadSleep ( 1.0 );
|
|
channel->printInfo();
|
|
|
|
{
|
|
GetFieldRequester::shared_pointer getFieldRequesterImpl(new GetFieldRequesterImpl());
|
|
channel->getField(getFieldRequesterImpl, "");
|
|
epicsThreadSleep ( 1.0 );
|
|
}
|
|
|
|
{
|
|
ChannelProcessRequester::shared_pointer channelProcessRequester(new ChannelProcessRequesterImpl());
|
|
PVStructure::shared_pointer pvRequest;
|
|
ChannelProcess::shared_pointer channelProcess = channel->createChannelProcess(channelProcessRequester, pvRequest);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelProcess->process(false);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelProcess->destroy();
|
|
epicsThreadSleep ( 1.0 );
|
|
}
|
|
|
|
{
|
|
ChannelGetRequester::shared_pointer channelGetRequesterImpl(new ChannelGetRequesterImpl());
|
|
PVStructure::shared_pointer pvRequest = getCreateRequest()->createRequest("field()",channelGetRequesterImpl);
|
|
ChannelGet::shared_pointer channelGet = channel->createChannelGet(channelGetRequesterImpl, pvRequest);
|
|
epicsThreadSleep ( 3.0 );
|
|
channelGet->get(false);
|
|
epicsThreadSleep ( 3.0 );
|
|
channelGet->destroy();
|
|
}
|
|
|
|
{
|
|
ChannelPutRequester::shared_pointer channelPutRequesterImpl(new ChannelPutRequesterImpl());
|
|
PVStructure::shared_pointer pvRequest = getCreateRequest()->createRequest("field(value,timeStamp)",channelPutRequesterImpl);
|
|
ChannelPut::shared_pointer channelPut = channel->createChannelPut(channelPutRequesterImpl, pvRequest);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelPut->get();
|
|
epicsThreadSleep ( 1.0 );
|
|
channelPut->put(false);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelPut->destroy();
|
|
}
|
|
|
|
{
|
|
ChannelPutGetRequester::shared_pointer channelPutGetRequesterImpl(new ChannelPutGetRequesterImpl());
|
|
PVStructure::shared_pointer pvRequest = getCreateRequest()->createRequest("putField(value,timeStamp)getField(timeStamp)",channelPutGetRequesterImpl);
|
|
ChannelPutGet::shared_pointer channelPutGet = channel->createChannelPutGet(channelPutGetRequesterImpl, pvRequest);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelPutGet->getGet();
|
|
epicsThreadSleep ( 1.0 );
|
|
channelPutGet->getPut();
|
|
epicsThreadSleep ( 1.0 );
|
|
channelPutGet->putGet(false);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelPutGet->destroy();
|
|
}
|
|
|
|
{
|
|
ChannelRPCRequester::shared_pointer channelRPCRequesterImpl(new ChannelRPCRequesterImpl());
|
|
PVStructure::shared_pointer pvRequest = getCreateRequest()->createRequest("record[]field(arguments)",channelRPCRequesterImpl);
|
|
ChannelRPC::shared_pointer channelRPC = channel->createChannelRPC(channelRPCRequesterImpl, pvRequest);
|
|
epicsThreadSleep ( 1.0 );
|
|
// for test simply use pvRequest as arguments
|
|
channelRPC->request(pvRequest, false);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelRPC->destroy();
|
|
}
|
|
|
|
{
|
|
ChannelArrayRequester::shared_pointer channelArrayRequesterImpl(new ChannelArrayRequesterImpl());
|
|
StringArray fieldNames; fieldNames.push_back("field");
|
|
FieldConstPtrArray fields; fields.push_back(getFieldCreate()->createScalar(pvString));
|
|
PVStructure::shared_pointer pvRequest(getPVDataCreate()->createPVStructure(getFieldCreate()->createStructure(fieldNames, fields)));
|
|
|
|
ChannelArray::shared_pointer channelArray = channel->createChannelArray(channelArrayRequesterImpl, pvRequest);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelArray->getArray(false,0,-1);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelArray->putArray(false,0,-1);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelArray->setLength(false,3,4);
|
|
epicsThreadSleep ( 1.0 );
|
|
channelArray->destroy();
|
|
}
|
|
|
|
{
|
|
MonitorRequester::shared_pointer monitorRequesterImpl(new MonitorRequesterImpl());
|
|
PVStructure::shared_pointer pvRequest = getCreateRequest()->createRequest("field()",monitorRequesterImpl);
|
|
Monitor::shared_pointer monitor = channel->createMonitor(monitorRequesterImpl, pvRequest);
|
|
|
|
epicsThreadSleep( 1.0 );
|
|
|
|
Status status = monitor->start();
|
|
std::cout << "monitor->start() = " << status.toString() << std::endl;
|
|
|
|
epicsThreadSleep( 3.0 );
|
|
|
|
status = monitor->stop();
|
|
std::cout << "monitor->stop() = " << status.toString() << std::endl;
|
|
|
|
|
|
monitor->destroy();
|
|
}
|
|
|
|
epicsThreadSleep ( 3.0 );
|
|
printf("Destroying channel... \n");
|
|
channel->destroy();
|
|
printf("done.\n");
|
|
|
|
epicsThreadSleep ( 3.0 );
|
|
|
|
}
|
|
|
|
ClientFactory::stop();
|
|
|
|
/*
|
|
printf("Destroying context... \n");
|
|
context->destroy();
|
|
printf("done.\n");
|
|
*/
|
|
|
|
epicsThreadSleep ( 1.0 ); }
|
|
//std::cout << "-----------------------------------------------------------------------" << std::endl;
|
|
//epicsExitCallAtExits();
|
|
return(0);
|
|
}
|