Public/lutango
1
0
Fork 0
forked from daneos/lutango
Code Issues Pull Requests Packages Projects Releases Wiki Activity

unify Tango types conversion

Browse Source
This commit is contained in:
Grzegorz Kowalski 2023-02-06 22:16:13 +01:00
parent 6cf75b0da6
commit 7d379fd5dd
9 changed files with 179 additions and 501 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/core/tango/AttributeProxy/lut_AttributeProxy.cpp
View File

@ -129,7 +129,7 @@ int lut_AttributeProxy_call(lua_State* L)
{
// called without arguments - read attribute
LUT_LOG(TRACE, "Reading attribute %s", attr_name.c_str());
unpack_attr_data(L, read_attr(udata));
lut_fromTangoType(L, read_attr(udata), udata->type_desc.type, udata->type_desc.format);
return 1;
}
else
@ -141,7 +141,8 @@ int lut_AttributeProxy_call(lua_State* L)
read_attr(udata);
}
Tango::DeviceAttribute v = pack_attr_data(L, 2, udata->type_desc, attr_name.c_str());
Tango::DeviceAttribute v = lut_toTangoType<Tango::DeviceAttribute>(L, 2, udata->type_desc.type, udata->type_desc.format);
v.set_name(attr_name);
udata->attr->write(v);
return 0;
}

2
src/core/tango/AttributeProxy/lut_AttributeProxy.h
View File

@ -25,7 +25,7 @@
#include <core/lua/version_agnostic.h>
#include <core/logging/log.h>
#include <core/tango/attrdata.h>
#include <core/tango/types.h>
#include <core/tango/DevState/lut_DevState.h>
#include <core/tango/DevFailed/lut_DevFailed.h>

9
src/core/tango/DeviceProxy/lut_DeviceProxy.cpp
View File

@ -46,9 +46,9 @@ int cmd_wrapper(lua_State* L)
LUT_LOG(TRACE, "Command: %s in:%d out:%d", full_name.c_str(), in_type, out_type);
Tango::DeviceData in = pack_cmd_data(L, 1, in_type);
Tango::DeviceData in = lut_toTangoType<Tango::DeviceData>(L, 1, in_type);
Tango::DeviceData out = udata->dev->command_inout(cmd_name, in);
unpack_cmd_data(L, out, out_type);
lut_fromTangoType(L, out, out_type);
}
catch(Tango::DevFailed e)
{
@ -199,7 +199,7 @@ int lut_DeviceProxy_index(lua_State* L)
Tango::DeviceAttribute attr = udata->dev->read_attribute(name);
udata->type_map[name].type = attr.get_type();
udata->type_map[name].format = attr.get_data_format();
unpack_attr_data(L, attr);
lut_fromTangoType(L, attr, attr.get_type(), attr.get_data_format());
}
delete cmdlist;
}
@ -241,7 +241,8 @@ int lut_DeviceProxy_newindex(lua_State* L)
udata->type_map[attr_name].format = attr.get_data_format();
}
Tango::DeviceAttribute v = pack_attr_data(L, 3, udata->type_map[attr_name], attr_name);
Tango::DeviceAttribute v = lut_toTangoType<Tango::DeviceAttribute>(L, 3, udata->type_map[attr_name].type, udata->type_map[attr_name].format);
v.set_name(attr_name);
udata->dev->write_attribute(v);
}
catch(Tango::DevFailed e)

3
src/core/tango/DeviceProxy/lut_DeviceProxy.h
View File

@ -25,8 +25,7 @@
#include <core/lua/version_agnostic.h>
#include <core/logging/log.h>
#include <core/tango/attrdata.h>
#include <core/tango/cmddata.h>
#include <core/tango/types.h>
#include <core/tango/DevFailed/lut_DevFailed.h>
#define LUT_DEVICEPROXY "lut_DeviceProxy"

357
src/core/tango/attrdata.cpp
View File

@ -1,357 +0,0 @@
//-----------------------------------------------------------------------------
//
// luTango - Lua binding for Tango
//
// Copyright (C) 2023 Grzegorz Kowalski
// See LICENSE for legal information
//
// file: attrdata.cpp
//
// Attribute data handling, type conversions
//
//-----------------------------------------------------------------------------
#include "attrdata.h"
void unpack_attr_data(lua_State* L, Tango::DeviceAttribute attr)
{
switch(attr.get_type())
{
case Tango::DEV_VOID: // 0 - void
lua_pushnil(L);
break;
case Tango::DEV_BOOLEAN: // 1 - bool
push_attr_bool(L, attr);
break;
case Tango::DEV_SHORT: // 2 - short
push_attr_number<short>(L, attr);
break;
case Tango::DEV_LONG: // 3 - long
push_attr_number<long>(L, attr);
break;
case Tango::DEV_FLOAT: // 4 - float
push_attr_number<float>(L, attr);
break;
case Tango::DEV_DOUBLE: // 5 - double
push_attr_number<double>(L, attr);
break;
case Tango::DEV_USHORT: // 6 - ushort
push_attr_number<unsigned short>(L, attr);
break;
case Tango::DEV_ULONG: // 7 - ulong
push_attr_number<unsigned long>(L, attr);
break;
case Tango::DEV_STRING: // 8 - string
case Tango::DEVVAR_CHARARRAY: // 9 - char[]
case Tango::CONST_DEV_STRING: // 20 - const string
push_attr_string(L, attr);
break;
case Tango::DEVVAR_SHORTARRAY: // 10 - short[]
{
std::vector<short> v;
attr >> v;
push_number_table(L, v);
break;
}
case Tango::DEVVAR_LONGARRAY: // 11 - long[]
{
std::vector<long> v;
attr >> v;
push_number_table(L, v);
break;
}
case Tango::DEVVAR_FLOATARRAY: // 12 - float[]
{
std::vector<float> v;
attr >> v;
push_number_table(L, v);
break;
}
case Tango::DEVVAR_DOUBLEARRAY: // 13 - double[]
{
std::vector<double> v;
attr >> v;
push_number_table(L, v);
break;
}
case Tango::DEVVAR_USHORTARRAY: // 14 - ushort[]
{
std::vector<unsigned short> v;
attr >> v;
push_number_table(L, v);
break;
}
case Tango::DEVVAR_ULONGARRAY: // 15 - ulong[]
{
std::vector<unsigned long> v;
attr >> v;
push_number_table(L, v);
break;
}
case Tango::DEVVAR_STRINGARRAY: // 16 - string[]
{
std::vector<std::string> v;
attr >> v;
push_string_table(L, v);
break;
}
case Tango::DEV_STATE: // 19 - DevState
{
Tango::DevState v;
attr >> v;
lut_DevState(L, v);
break;
}
case Tango::DEVVAR_BOOLEANARRAY: // 21 - bool[]
{
std::vector<bool> v;
attr >> v;
push_bool_table(L, v);
break;
}
case Tango::DEV_UCHAR: // 22 - uchar
{
unsigned char v;
attr >> v;
lua_pushstring(L, (const char *)&v);
break;
}
case Tango::DEV_LONG64: // 23 - long64
push_attr_number<int64_t>(L, attr);
break;
case Tango::DEV_ULONG64: // 24 - ulong64
push_attr_number<uint64_t>(L, attr);
break;
case Tango::DEVVAR_LONG64ARRAY: // 25 - long64[]
{
std::vector<int64_t> v;
attr >> v;
push_number_table(L, v);
break;
}
case Tango::DEVVAR_ULONG64ARRAY: // 26 - ulong64[]
{
std::vector<uint64_t> v;
attr >> v;
push_number_table(L, v);
break;
}
case Tango::DEV_INT: // 27 - int
push_attr_number<int>(L, attr);
break;
case Tango::DEVVAR_LONGSTRINGARRAY: // 17 - longstring[] ???
case Tango::DEVVAR_DOUBLESTRINGARRAY: // 18 - doublestring[] ???
case Tango::DEV_ENCODED: // 28 - DevEncoded
case Tango::DEV_ENUM: // 29 - DevEnum
case Tango::DEV_PIPE_BLOB: // 30 - DevPipeBlob
case Tango::DEVVAR_STATEARRAY: // 31 - DevState[]
LUT_LOG(WARNING, "%s: Attribute type not implemented for reading yet: %d", attr.name.c_str(), attr.get_type());
lua_pushnil(L);
break;
case Tango::DATA_TYPE_UNKNOWN: // 32 - unknown
default:
LUT_LOG(ERROR, "%s: Device returned unknown type: %d", attr.name.c_str(), attr.get_type());
lua_pushnil(L);
//return luaL_error(L, "Device returned type %d, that is unknown or unsupported.", attr.get_type());
}
}
template<class T>
void push_attr_number(lua_State* L, Tango::DeviceAttribute attr)
{
Tango::AttrDataFormat fmt = attr.get_data_format();
if(fmt == Tango::SCALAR)
{
T v;
attr >> v;
lua_pushnumber(L, v);
}
else if(fmt == Tango::SPECTRUM)
{
std::vector<T> v;
attr >> v;
push_number_table(L, v);
}
else if(fmt == Tango::IMAGE)
{
// std::vector<std::vector<T>> v;
// //attr >> v;
// // push_number_2d(L, v);
LUT_LOG(WARNING, "%s: IMAGE data format is not supported yet", attr.name.c_str());
lua_pushnil(L);
}
else
{
LUT_LOG(ERROR, "%s: Invalid data format", attr.name.c_str());
lua_pushnil(L);
}
}
void push_attr_bool(lua_State* L, Tango::DeviceAttribute attr)
{
Tango::AttrDataFormat fmt = attr.get_data_format();
if(fmt == Tango::SCALAR)
{
bool v;
attr >> v;
lua_pushboolean(L, v);
}
else if(fmt == Tango::SPECTRUM)
{
std::vector<bool> v;
attr >> v;
push_bool_table(L, v);
}
else if(fmt == Tango::IMAGE)
{
LUT_LOG(WARNING, "%s: IMAGE data format is not supported yet", attr.name.c_str());
lua_pushnil(L);
}
else
{
LUT_LOG(ERROR, "%s: Invalid data format", attr.name.c_str());
lua_pushnil(L);
}
}
void push_attr_string(lua_State* L, Tango::DeviceAttribute attr)
{
Tango::AttrDataFormat fmt = attr.get_data_format();
if(fmt == Tango::SCALAR)
{
std::string v;
attr >> v;
lua_pushstring(L, v.c_str());
}
else if(fmt == Tango::SPECTRUM)
{
std::vector<std::string> v;
attr >> v;
push_string_table(L, v);
}
else if(fmt == Tango::IMAGE)
{
LUT_LOG(WARNING, "%s: IMAGE data format is not supported yet", attr.name.c_str());
lua_pushnil(L);
}
else
{
LUT_LOG(ERROR, "%s: Invalid data format", attr.name.c_str());
lua_pushnil(L);
}
}
Tango::DeviceAttribute pack_attr_data(lua_State* L, int idx, AttrTypeDescription d, const char* attr_name)
{
switch(d.type)
{
case Tango::DEV_VOID: // 0 - void
LUT_LOG(ERROR, "%s: Void is not writeable type!", attr_name);
break;
case Tango::DEV_BOOLEAN: // 1 - bool
// Lua 5.1 is missing the luaL_checkboolean function
return pack_attr_value(attr_name, (bool)lua_toboolean(L, idx));
break;
case Tango::DEV_SHORT: // 2 - short
return pack_attr_value(attr_name, pop_number<short>(L, idx));
break;
case Tango::DEV_LONG: // 3 - long
return pack_attr_value(attr_name, pop_number<long>(L, idx));
break;
case Tango::DEV_FLOAT: // 4 - float
return pack_attr_value(attr_name, pop_number<float>(L, idx));
break;
case Tango::DEV_DOUBLE: // 5 - double
return pack_attr_value(attr_name, pop_number<double>(L, idx));
break;
case Tango::DEV_USHORT: // 6 - ushort
return pack_attr_value(attr_name, pop_number<unsigned short>(L, idx));
break;
case Tango::DEV_ULONG: // 7 - ulong
return pack_attr_value(attr_name, pop_number<unsigned long>(L, idx));
break;
case Tango::DEV_STRING: // 8 - string
case Tango::DEVVAR_CHARARRAY: // 9 - char[]
case Tango::CONST_DEV_STRING: // 20 - const string
return pack_attr_value(attr_name, luaL_checkstring(L, idx));
break;
case Tango::DEV_LONG64: // 23 - long64
return pack_attr_value(attr_name, pop_number<int64_t>(L, idx));
break;
case Tango::DEV_ULONG64: // 24 - ulong64
return pack_attr_value(attr_name, pop_number<uint64_t>(L, idx));
break;
case Tango::DEV_INT: // 27 - int
return pack_attr_value(attr_name, pop_number<int>(L, idx));
break;
case Tango::DEVVAR_SHORTARRAY: // 10 - short[]
case Tango::DEVVAR_LONGARRAY: // 11 - long[]
case Tango::DEVVAR_FLOATARRAY: // 12 - float[]
case Tango::DEVVAR_DOUBLEARRAY: // 13 - double[]
case Tango::DEVVAR_USHORTARRAY: // 14 - ushort[]
case Tango::DEVVAR_ULONGARRAY: // 15 - ulong[]
case Tango::DEVVAR_STRINGARRAY: // 16 - string[]
case Tango::DEVVAR_LONGSTRINGARRAY: // 17 - longstring[] ???
case Tango::DEVVAR_DOUBLESTRINGARRAY: // 18 - doublestring[] ???
case Tango::DEV_STATE: // 19 - DevState
case Tango::DEVVAR_BOOLEANARRAY: // 21 - bool[]
case Tango::DEV_UCHAR: // 22 - uchar
case Tango::DEVVAR_LONG64ARRAY: // 25 - long64[]
case Tango::DEVVAR_ULONG64ARRAY: // 26 - ulong64[]
case Tango::DEV_ENCODED: // 28 - DevEncoded
case Tango::DEV_ENUM: // 29 - DevEnum
case Tango::DEV_PIPE_BLOB: // 30 - DevPipeBlob
case Tango::DEVVAR_STATEARRAY: // 31 - DevState[]
LUT_LOG(WARNING, "%s: Attribute type not implemented for writing yet: %d", attr_name, d.type);
break;
case Tango::DATA_TYPE_UNKNOWN: // 32 - unknown
default:
LUT_LOG(ERROR, "%s: Attribute reports unknown type: %d", attr_name, d.type);
}
}
template<class T>
Tango::DeviceAttribute pack_attr_value(const char* name, T value)
{
Tango::DeviceAttribute v(name, value);
return v;
}

50
src/core/tango/attrdata.h
View File

@ -1,50 +0,0 @@
//-----------------------------------------------------------------------------
//
// luTango - Lua binding for Tango
//
// Copyright (C) 2023 Grzegorz Kowalski
// See LICENSE for legal information
//
// file: attrdata.h
//
// Attribute data handling, type conversions
//
//-----------------------------------------------------------------------------
#ifndef __ATTRDATA_H__
# define __ATTRDATA_H__
#include <string>
#include <vector>
#include <map>
#include <inttypes.h>
#include <core/lua.h>
#include <core/tango.h>
#include <core/logging/log.h>
#include <core/lua/stack.h>
#include <core/tango/DevState/lut_DevState.h>
typedef struct
{
int type;
Tango::AttrDataFormat format;
} AttrTypeDescription;
typedef std::map<const char*, AttrTypeDescription> AttrTypeMap;
// READ ATTRIBUTE -------------------------------------------------------------
void unpack_attr_data(lua_State* L, Tango::DeviceAttribute attr);
template<class T>
void push_attr_number(lua_State* L, Tango::DeviceAttribute attr);
void push_attr_bool(lua_State* L, Tango::DeviceAttribute attr);
void push_attr_string(lua_State* L, Tango::DeviceAttribute attr);
// WRITE ATTRIBUTE ------------------------------------------------------------
Tango::DeviceAttribute pack_attr_data(lua_State* L, int idx, AttrTypeDescription d, const char* attr_name);
template<class T>
Tango::DeviceAttribute pack_attr_value(const char* name, T value);
#endif /* __ATTRDATA_H__ */

41
src/core/tango/cmddata.h
View File

@ -1,41 +0,0 @@
//-----------------------------------------------------------------------------
//
// luTango - Lua binding for Tango
//
// Copyright (C) 2023 Grzegorz Kowalski
// See LICENSE for legal information
//
// file: cmddata.h
//
// Command data handling, type conversions
//
//-----------------------------------------------------------------------------
#ifndef __CMDDATA_H__
# define __CMDDATA_H__
#include <string>
#include <vector>
#include <map>
#include <inttypes.h>
#include <core/lua.h>
#include <core/tango.h>
#include <core/logging/log.h>
#include <core/lua/stack.h>
#include <core/tango/DevState/lut_DevState.h>
typedef std::map<const char*, Tango::CommandInfo> CmdInfoMap;
// DATA OUT -------------------------------------------------------------------
void unpack_cmd_data(lua_State* L, Tango::DeviceData data, long type);
// DATA IN --------------------------------------------------------------------
template<class T>
void push_cmd_number(lua_State* L, Tango::DeviceData data);
void push_cmd_bool(lua_State* L, Tango::DeviceData data);
void push_cmd_string(lua_State* L, Tango::DeviceData data);
Tango::DeviceData pack_cmd_data(lua_State* L, int idx, long type);
#endif /* __CMDDATA_H__ */

161
src/core/tango/cmddata.cpp → src/core/tango/types.cpp
View File

@ -5,15 +5,19 @@
// Copyright (C) 2023 Grzegorz Kowalski
// See LICENSE for legal information
//
// file: cmddata.cpp
// file: types.cpp
//
// Command data handling, type conversions
// Tango type conversions
//
//-----------------------------------------------------------------------------
#include "cmddata.h"
#include "types.h"
void unpack_cmd_data(lua_State* L, Tango::DeviceData data, long type)
template void lut_fromTangoType(lua_State* L, Tango::DeviceAttribute data, long type, Tango::AttrDataFormat format);
template void lut_fromTangoType(lua_State* L, Tango::DeviceData data, long type, Tango::AttrDataFormat format);
template<class T>
void lut_fromTangoType(lua_State* L, T data, long type, Tango::AttrDataFormat format)
{
switch(type)
{
@ -22,37 +26,37 @@ void unpack_cmd_data(lua_State* L, Tango::DeviceData data, long type)
break;
case Tango::DEV_BOOLEAN: // 1 - bool
push_cmd_bool(L, data);
extract_bool(L, data, format);
break;
case Tango::DEV_SHORT: // 2 - short
push_cmd_number<short>(L, data);
extract_number<short>(L, data, format);
break;
case Tango::DEV_LONG: // 3 - long
push_cmd_number<long>(L, data);
extract_number<long>(L, data, format);
break;
case Tango::DEV_FLOAT: // 4 - float
push_cmd_number<float>(L, data);
extract_number<float>(L, data, format);
break;
case Tango::DEV_DOUBLE: // 5 - double
push_cmd_number<double>(L, data);
extract_number<double>(L, data, format);
break;
case Tango::DEV_USHORT: // 6 - ushort
push_cmd_number<unsigned short>(L, data);
extract_number<unsigned short>(L, data, format);
break;
case Tango::DEV_ULONG: // 7 - ulong
push_cmd_number<unsigned long>(L, data);
extract_number<unsigned long>(L, data, format);
break;
case Tango::DEV_STRING: // 8 - string
case Tango::DEVVAR_CHARARRAY: // 9 - char[]
case Tango::CONST_DEV_STRING: // 20 - const string
push_cmd_string(L, data);
extract_string(L, data, format);
break;
case Tango::DEVVAR_SHORTARRAY: // 10 - short[]
@ -128,11 +132,11 @@ void unpack_cmd_data(lua_State* L, Tango::DeviceData data, long type)
}
case Tango::DEV_LONG64: // 23 - long64
push_cmd_number<int64_t>(L, data);
extract_number<int64_t>(L, data, format);
break;
case Tango::DEV_ULONG64: // 24 - ulong64
push_cmd_number<uint64_t>(L, data);
extract_number<uint64_t>(L, data, format);
break;
case Tango::DEVVAR_LONG64ARRAY: // 25 - long64[]
@ -152,12 +156,12 @@ void unpack_cmd_data(lua_State* L, Tango::DeviceData data, long type)
}
case Tango::DEV_INT: // 27 - int
push_cmd_number<int>(L, data);
extract_number<int>(L, data, format);
break;
case Tango::DEVVAR_LONGSTRINGARRAY: // 17 - longstring[] ???
case Tango::DEVVAR_DOUBLESTRINGARRAY: // 18 - doublestring[] ???
case Tango::DEVVAR_BOOLEANARRAY: // 21 - bool[] - cannot insert std::vector<bool(or DevBoolean)> to DeviceData
case Tango::DEVVAR_BOOLEANARRAY: // 21 - bool[]
case Tango::DEV_ENCODED: // 28 - DevEncoded
case Tango::DEV_ENUM: // 29 - DevEnum
case Tango::DEV_PIPE_BLOB: // 30 - DevPipeBlob
@ -170,36 +174,17 @@ void unpack_cmd_data(lua_State* L, Tango::DeviceData data, long type)
default:
LUT_LOG(ERROR, "Unknown type: %d", type);
lua_pushnil(L);
//return luaL_error(L, "Device returned type %d, that is unknown or unsupported.", attr.get_type());
break;
}
}
template Tango::DeviceAttribute lut_toTangoType(lua_State* L, int idx, long type, Tango::AttrDataFormat format);
template Tango::DeviceData lut_toTangoType(lua_State* L, int idx, long type, Tango::AttrDataFormat format);
template<class T>
void push_cmd_number(lua_State* L, Tango::DeviceData data)
T lut_toTangoType(lua_State* L, int idx, long type, Tango::AttrDataFormat format)
{
T v;
data >> v;
lua_pushnumber(L, v);
}
void push_cmd_bool(lua_State* L, Tango::DeviceData data)
{
bool v;
data >> v;
lua_pushboolean(L, v);
}
void push_cmd_string(lua_State* L, Tango::DeviceData data)
{
std::string v;
data >> v;
lua_pushstring(L, v.c_str());
}
Tango::DeviceData pack_cmd_data(lua_State* L, int idx, long type)
{
Tango::DeviceData data;
T data = T();
switch(type)
{
case Tango::DEV_VOID: // 0 - void
@ -350,18 +335,106 @@ Tango::DeviceData pack_cmd_data(lua_State* L, int idx, long type)
case Tango::DEVVAR_LONGSTRINGARRAY: // 17 - longstring[] ???
case Tango::DEVVAR_DOUBLESTRINGARRAY: // 18 - doublestring[] ???
case Tango::DEV_STATE: // 19 - DevState
case Tango::DEVVAR_BOOLEANARRAY: // 21 - bool[] - cannot insert std::vector<bool(or DevBoolean)> to DeviceData
case Tango::DEVVAR_BOOLEANARRAY: // 21 - bool[]
case Tango::DEV_UCHAR: // 22 - uchar
case Tango::DEV_ENCODED: // 28 - DevEncoded
case Tango::DEV_ENUM: // 29 - DevEnum
case Tango::DEV_PIPE_BLOB: // 30 - DevPipeBlob
case Tango::DEVVAR_STATEARRAY: // 31 - DevState[]
LUT_LOG(WARNING, "Command input argument type not implemented yet: %d", type);
LUT_LOG(WARNING, "Conversion to Tango type not implemented yet: %d", type);
break;
case Tango::DATA_TYPE_UNKNOWN: // 32 - unknown
default:
LUT_LOG(ERROR, "Command input argument type is unknown: %d", type);
LUT_LOG(ERROR, "Tango type is unknown: %d", type);
break;
}
return data;
}
template<class dT, class T>
void extract_number(lua_State* L, T data, Tango::AttrDataFormat format)
{
if(format == Tango::SCALAR)
{
dT v;
data >> v;
lua_pushnumber(L, v);
}
else if(format == Tango::SPECTRUM)
{
std::vector<dT> v;
data >> v;
push_number_table(L, v);
}
else if(format == Tango::IMAGE)
{
// std::vector<std::vector<T>> v;
// //attr >> v;
// // push_number_2d(L, v);
LUT_LOG(WARNING, "IMAGE data format is not supported yet");
lua_pushnil(L);
}
else
{
LUT_LOG(ERROR, "Invalid data format");
lua_pushnil(L);
}
}
template<class T>
void extract_bool(lua_State* L, T data, Tango::AttrDataFormat format)
{
if(format == Tango::SCALAR)
{
bool v;
data >> v;
lua_pushboolean(L, v);
}
else if(format == Tango::SPECTRUM)
{
// TODO: cannot insert std::vector<bool(or DevBoolean)> to DeviceData
// std::vector<bool> v;
// data >> v;
// push_bool_table(L, v);
lua_pushnil(L);
}
else if(format == Tango::IMAGE)
{
LUT_LOG(WARNING, "IMAGE data format is not supported yet");
lua_pushnil(L);
}
else
{
LUT_LOG(ERROR, "Invalid data format");
lua_pushnil(L);
}
}
template<class T>
void extract_string(lua_State* L, T data, Tango::AttrDataFormat format)
{
if(format == Tango::SCALAR)
{
std::string v;
data >> v;
lua_pushstring(L, v.c_str());
}
else if(format == Tango::SPECTRUM)
{
std::vector<std::string> v;
data >> v;
push_string_table(L, v);
}
else if(format == Tango::IMAGE)
{
LUT_LOG(WARNING, "IMAGE data format is not supported yet");
lua_pushnil(L);
}
else
{
LUT_LOG(ERROR, "Invalid data format");
lua_pushnil(L);
}
}

52
src/core/tango/types.h Normal file
View File

@ -0,0 +1,52 @@
//-----------------------------------------------------------------------------
//
// luTango - Lua binding for Tango
//
// Copyright (C) 2023 Grzegorz Kowalski
// See LICENSE for legal information
//
// file: types.h
//
// Tango type conversions
//
//-----------------------------------------------------------------------------
#ifndef __TYPES_H__
# define __TYPES_H__
#include <string>
#include <vector>
#include <map>
#include <inttypes.h>
#include <core/lua.h>
#include <core/tango.h>
#include <core/logging/log.h>
#include <core/lua/stack.h>
#include <core/tango/DevState/lut_DevState.h>
typedef struct
{
long type;
Tango::AttrDataFormat format;
} AttrTypeDescription;
typedef std::map<const char*, AttrTypeDescription> AttrTypeMap;
typedef std::map<const char*, Tango::CommandInfo> CmdInfoMap;
template<class T>
void lut_fromTangoType(lua_State* L, T data, long type, Tango::AttrDataFormat format=Tango::SCALAR);
template<class T>
T lut_toTangoType(lua_State* L, int idx, long type, Tango::AttrDataFormat format=Tango::SCALAR);
template<class dT, class T>
void extract_number(lua_State* L, T data, Tango::AttrDataFormat format);
template<class T>
void extract_bool(lua_State* L, T data, Tango::AttrDataFormat format);
template<class T>
void extract_string(lua_State* L, T data, Tango::AttrDataFormat format);
#endif /* __TYPES_H__ */