261 lines
8.7 KiB
C++
261 lines
8.7 KiB
C++
/*******************************************************************************
|
|
* Copyright (c) 2021 Nerian Vision GmbH
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*******************************************************************************/
|
|
|
|
#include "visiontransfer/deviceparameters.h"
|
|
#include "visiontransfer/parametertransfer.h"
|
|
#include "visiontransfer/exceptions.h"
|
|
#include "visiontransfer/common.h"
|
|
|
|
using namespace visiontransfer;
|
|
using namespace visiontransfer::internal;
|
|
|
|
namespace visiontransfer {
|
|
|
|
/*************** Pimpl class containing all private members ***********/
|
|
|
|
class DeviceParameters::Pimpl {
|
|
public:
|
|
Pimpl(const DeviceInfo& device);
|
|
Pimpl(const char* address, const char* service);
|
|
|
|
int readIntParameter(int id);
|
|
double readDoubleParameter(int id);
|
|
bool readBoolParameter(int id);
|
|
|
|
void writeIntParameter(int id, int value);
|
|
void writeDoubleParameter(int id, double value);
|
|
void writeBoolParameter(int id, bool value);
|
|
|
|
std::map<std::string, ParameterInfo> getAllParameters();
|
|
|
|
// this template is selected for non-floating point arguments (i.e. int and bool).
|
|
template<typename T>
|
|
void setParameter_impl(StandardParameterIDs::ParameterID id, ParameterInfo::ParameterType type, T value, ...)
|
|
{
|
|
int cid = static_cast<int>(id);
|
|
switch (type) {
|
|
case ParameterInfo::TYPE_INT: {
|
|
writeIntParameter(cid, static_cast<int>(value));
|
|
break;
|
|
}
|
|
case ParameterInfo::TYPE_BOOL: {
|
|
writeBoolParameter(cid, value != 0);
|
|
break;
|
|
}
|
|
case ParameterInfo::TYPE_DOUBLE: {
|
|
writeDoubleParameter(cid, static_cast<double>(value));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// this template is selected for floating point arguments
|
|
template<typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
|
|
void setParameter_impl(StandardParameterIDs::ParameterID id, ParameterInfo::ParameterType type, T value, double)
|
|
{
|
|
int cid = static_cast<int>(id);
|
|
switch (type) {
|
|
case ParameterInfo::TYPE_DOUBLE: {
|
|
writeDoubleParameter(cid, value);
|
|
break;
|
|
}
|
|
case ParameterInfo::TYPE_INT: {
|
|
writeIntParameter(cid, static_cast<int>(value));
|
|
break;
|
|
}
|
|
case ParameterInfo::TYPE_BOOL: {
|
|
writeBoolParameter(cid, value != 0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void setParameter(StandardParameterIDs::ParameterID id, ParameterInfo::ParameterType type, T t) {
|
|
setParameter_impl<T>(id, type, t, double{});
|
|
}
|
|
|
|
ParameterInfo getParameter(const std::string& name);
|
|
|
|
void lookupIDAndType(const std::string& name, internal::StandardParameterIDs::ParameterID& id, ParameterInfo::ParameterType& type);
|
|
|
|
private:
|
|
std::map<std::string, ParameterInfo> serverSideEnumeration;
|
|
|
|
std::map<std::string, ParameterInfo> getAllParametersInternal();
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
template<typename T>
|
|
void setNamedParameterInternal(const std::string& name, T value);
|
|
#endif
|
|
|
|
ParameterTransfer paramTrans;
|
|
};
|
|
|
|
/******************** Stubs for all public members ********************/
|
|
|
|
DeviceParameters::DeviceParameters(const DeviceInfo& device):
|
|
pimpl(new Pimpl(device)) {
|
|
// All initialization in the pimpl class
|
|
}
|
|
|
|
DeviceParameters::DeviceParameters(const char* address, const char* service):
|
|
pimpl(new Pimpl(address, service)) {
|
|
// All initialization in the pimpl class
|
|
}
|
|
|
|
DeviceParameters::~DeviceParameters() {
|
|
delete pimpl;
|
|
}
|
|
|
|
int DeviceParameters::readIntParameter(int id) {
|
|
return pimpl->readIntParameter(id);
|
|
}
|
|
|
|
double DeviceParameters::readDoubleParameter(int id) {
|
|
return pimpl->readDoubleParameter(id);
|
|
}
|
|
|
|
bool DeviceParameters::readBoolParameter(int id) {
|
|
return pimpl->readBoolParameter(id);
|
|
}
|
|
|
|
void DeviceParameters::writeIntParameter(int id, int value) {
|
|
pimpl->writeIntParameter(id, value);
|
|
}
|
|
|
|
void DeviceParameters::writeDoubleParameter(int id, double value) {
|
|
pimpl->writeDoubleParameter(id, value);
|
|
}
|
|
|
|
void DeviceParameters::writeBoolParameter(int id, bool value) {
|
|
pimpl->writeBoolParameter(id, value);
|
|
}
|
|
|
|
void DeviceParameters::Pimpl::lookupIDAndType(const std::string& name, StandardParameterIDs::ParameterID& id, ParameterInfo::ParameterType& type) {
|
|
if (serverSideEnumeration.size() == 0) {
|
|
// get the server-side parameter list first (which reports the types as well)
|
|
(void) getAllParameters();
|
|
}
|
|
id = StandardParameterIDs::getParameterIDForName(name);
|
|
if (id == StandardParameterIDs::ParameterID::UNDEFINED) {
|
|
ParameterException ex("Cannot access parameter with unknown name: " + name);
|
|
throw ex;
|
|
}
|
|
auto it = serverSideEnumeration.find(name);
|
|
if (it == serverSideEnumeration.end()) {
|
|
ParameterException ex("Server did not report the parameter in the supported list: " + name);
|
|
throw ex;
|
|
}
|
|
type = it->second.getType();
|
|
}
|
|
|
|
std::map<std::string, ParameterInfo> DeviceParameters::getAllParameters()
|
|
{
|
|
return pimpl->getAllParameters();
|
|
}
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
template<>
|
|
void VT_EXPORT DeviceParameters::setNamedParameter(const std::string& name, double value) {
|
|
StandardParameterIDs::ParameterID id;
|
|
ParameterInfo::ParameterType type;
|
|
pimpl->lookupIDAndType(name, id, type);
|
|
pimpl->setParameter<double>(id, type, value);
|
|
}
|
|
template<>
|
|
void VT_EXPORT DeviceParameters::setNamedParameter(const std::string& name, int value) {
|
|
StandardParameterIDs::ParameterID id;
|
|
ParameterInfo::ParameterType type;
|
|
pimpl->lookupIDAndType(name, id, type);
|
|
pimpl->setParameter<int>(id, type, value);
|
|
}
|
|
template<>
|
|
void VT_EXPORT DeviceParameters::setNamedParameter(const std::string& name, bool value) {
|
|
StandardParameterIDs::ParameterID id;
|
|
ParameterInfo::ParameterType type;
|
|
pimpl->lookupIDAndType(name, id, type);
|
|
pimpl->setParameter<bool>(id, type, value);
|
|
}
|
|
|
|
template<>
|
|
int VT_EXPORT DeviceParameters::getNamedParameter(const std::string& name) {
|
|
StandardParameterIDs::ParameterID id;
|
|
ParameterInfo::ParameterType type;
|
|
pimpl->lookupIDAndType(name, id, type);
|
|
return pimpl->getParameter(name).getValue<int>();
|
|
}
|
|
template<>
|
|
double VT_EXPORT DeviceParameters::getNamedParameter(const std::string& name) {
|
|
StandardParameterIDs::ParameterID id;
|
|
ParameterInfo::ParameterType type;
|
|
pimpl->lookupIDAndType(name, id, type);
|
|
return pimpl->getParameter(name).getValue<double>();
|
|
}
|
|
template<>
|
|
bool VT_EXPORT DeviceParameters::getNamedParameter(const std::string& name) {
|
|
StandardParameterIDs::ParameterID id;
|
|
ParameterInfo::ParameterType type;
|
|
pimpl->lookupIDAndType(name, id, type);
|
|
return pimpl->getParameter(name).getValue<bool>();
|
|
}
|
|
#endif
|
|
|
|
/******************** Implementation in pimpl class *******************/
|
|
|
|
DeviceParameters::Pimpl::Pimpl(const char* address, const char* service)
|
|
: paramTrans(address, service) {
|
|
}
|
|
|
|
DeviceParameters::Pimpl::Pimpl(const DeviceInfo& device)
|
|
: paramTrans(device.getIpAddress().c_str(), "7683") {
|
|
}
|
|
|
|
int DeviceParameters::Pimpl::readIntParameter(int id) {
|
|
return paramTrans.readIntParameter(id);
|
|
}
|
|
|
|
double DeviceParameters::Pimpl::readDoubleParameter(int id) {
|
|
return paramTrans.readDoubleParameter(id);
|
|
}
|
|
|
|
bool DeviceParameters::Pimpl::readBoolParameter(int id) {
|
|
return paramTrans.readBoolParameter(id);
|
|
}
|
|
|
|
void DeviceParameters::Pimpl::writeIntParameter(int id, int value) {
|
|
paramTrans.writeIntParameter(id, value);
|
|
}
|
|
|
|
void DeviceParameters::Pimpl::writeDoubleParameter(int id, double value) {
|
|
paramTrans.writeDoubleParameter(id, value);
|
|
}
|
|
|
|
void DeviceParameters::Pimpl::writeBoolParameter(int id, bool value) {
|
|
paramTrans.writeBoolParameter(id, value);
|
|
}
|
|
|
|
std::map<std::string, ParameterInfo> DeviceParameters::Pimpl::getAllParameters() {
|
|
serverSideEnumeration = paramTrans.getAllParameters();
|
|
return serverSideEnumeration;
|
|
}
|
|
|
|
|
|
ParameterInfo DeviceParameters::Pimpl::getParameter(const std::string& name)
|
|
{
|
|
return serverSideEnumeration[name];
|
|
}
|
|
|
|
} // namespace
|
|
|