WSF
WsfScriptAuxDataUtil.hpp
Go to the documentation of this file.
1// ****************************************************************************
2// CUI
3//
4// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
5//
6// Copyright 2003-2015 The Boeing Company. All rights reserved.
7//
8// The use, dissemination or disclosure of data in this file is subject to
9// limitation or restriction. See accompanying README and LICENSE for details.
10// ****************************************************************************
11
12#ifndef WSFSCRIPTAUXDATAUTIL_HPP
13#define WSFSCRIPTAUXDATAUTIL_HPP
14
15#include <string>
16
17#include "UtException.hpp"
18#include "UtMemory.hpp"
19#include "UtScriptBasicTypes.hpp" // TODO remove this include
20#include "UtScriptClassDefine.hpp"
21#include "UtScriptDataPack.hpp" // TODO remove this include
22#include "WsfAuxDataEnabled.hpp"
23
24namespace WsfScriptAuxDataUtil
25{
26template<typename OBJECT_TYPE, typename T>
27void GetAuxData(OBJECT_TYPE* aObjectPtr,
28 UtScriptMethodArgs aVarArgs,
29 UtScriptData& aReturnVal,
30 UtScriptClass* aReturnClassPtr,
31 UtScriptClass::InterfaceMethod* aInterfaceMethodPtr)
32{
33 static_assert(std::is_base_of<WsfAuxDataEnabled, OBJECT_TYPE>::value,
34 "Template type of GetAuxData must derive from WsfAuxDataEnabled");
35
36 if (!aObjectPtr->HasAuxData())
37 {
38 aReturnVal = UtScriptData(T{});
39 return;
40 }
41
42 UtAttributeBase* attribute = aObjectPtr->GetAuxDataConst().FindAttribute(aVarArgs[0].GetString());
43
44 if (attribute == nullptr)
45 {
46 aReturnVal = UtScriptData(T{});
47 return;
48 }
49
50 T value = T();
51 auto attributeType = attribute->GetTypeId();
52 ut::script::Data::Type valueType = UtScriptData(value).GetType();
53 if (attributeType == UtAttribute<bool>::GetClassTypeId())
54 {
55 if (valueType == ut::script::Data::Type::cBOOL)
56 {
57 attribute->Get(value);
58 }
59 else
60 {
61 bool returnValueBool;
62 attribute->Get(returnValueBool);
63 value = UtScriptData(returnValueBool);
64 }
65 }
66 else if (attributeType == UtAttribute<int>::GetClassTypeId())
67 {
68 if (valueType == ut::script::Data::Type::cINT)
69 {
70 attribute->Get(value);
71 }
72 else
73 {
74 int returnValueInt;
75 attribute->Get(returnValueInt);
76 value = UtScriptData(returnValueInt);
77 }
78 }
79 else if (attributeType == UtAttribute<double>::GetClassTypeId())
80 {
81 if (valueType == ut::script::Data::Type::cDOUBLE)
82 {
83 attribute->Get(value);
84 }
85 else
86 {
87 double returnValueDouble;
88 attribute->Get(returnValueDouble);
89 value = UtScriptData(returnValueDouble);
90 }
91 }
92 else if (attributeType == UtAttribute<std::string>::GetClassTypeId())
93 {
94 if (valueType == ut::script::Data::Type::cSTRING)
95 {
96 attribute->Get(value);
97 }
98 else
99 {
100 std::string returnValueStr;
101 attribute->Get(returnValueStr);
102 value = UtScriptData(returnValueStr);
103 }
104 }
105 else
106 {
107 attribute->Get(value);
108 }
109 aReturnVal = UtScriptData(value);
110}
111
112template<typename OBJECT_TYPE>
113void SetAuxData(OBJECT_TYPE* aObjectPtr,
114 UtScriptMethodArgs aVarArgs,
115 UtScriptData& aReturnVal,
116 UtScriptClass* aReturnClassPtr,
117 UtScriptClass::InterfaceMethod* aInterfaceMethodPtr,
118 bool aSilentFailure = false)
119{
120 static_assert(std::is_base_of<WsfAuxDataEnabled, OBJECT_TYPE>::value,
121 "Template type of SetAuxData must derive from WsfAuxDataEnabled");
122
123 const std::string& attributeName = aVarArgs[0].GetString();
124 const UtScriptData& value = aVarArgs[1];
125 try
126 {
127 switch (value.GetType())
128 {
129 case ut::script::Data::Type::cBOOL:
130 aObjectPtr->GetAuxData().Assign(attributeName, value.GetBool());
131 break;
132 case ut::script::Data::Type::cINT:
133 aObjectPtr->GetAuxData().Assign(attributeName, value.GetInt());
134 break;
135 case ut::script::Data::Type::cDOUBLE:
136 aObjectPtr->GetAuxData().Assign(attributeName, value.GetDouble());
137 break;
138 case ut::script::Data::Type::cSTRING:
139 aObjectPtr->GetAuxData().Assign(attributeName, value.GetString());
140 break;
141 default:
142 aObjectPtr->GetAuxData().Assign(attributeName, value);
143 break;
144 }
145 }
146 catch (UtException&)
147 {
148 if (!aSilentFailure)
149 {
150 UT_SCRIPT_ABORT("AuxData exists, but is not correct type.");
151 }
152 }
153}
154
155template<typename OBJECT_TYPE>
156void GetAllAuxDataTypes(OBJECT_TYPE* aObjectPtr, UtScriptData& aReturnVal, UtScriptClass* aReturnClassPtr)
157{
158 static_assert(std::is_base_of<WsfAuxDataEnabled, OBJECT_TYPE>::value,
159 "Template type of GetAllAuxDataTypes must derive from WsfAuxDataEnabled");
160
161 auto retAuxMapPtr = ut::make_unique<UtScriptMap::Map>();
162 const UtAttributeContainer::AttributeMap& attributes = aObjectPtr->GetAuxDataConst().GetAttributeMap();
163 for (const auto& aux : attributes)
164 {
165 retAuxMapPtr->emplace(UtScriptData{aux.first}, UtScriptData{aux.second->GetType()});
166 }
167
168 auto* mapRefPtr = new UtScriptRef(retAuxMapPtr.release(), aReturnClassPtr, UtScriptRef::cMANAGE);
169 aReturnVal.SetPointer(mapRefPtr);
170}
171
172template<class SCRIPT_CLASS>
173void AddAuxDataScriptMethods(SCRIPT_CLASS& aScriptClass)
174{
175 static_assert(std::is_base_of<UtScriptClass, SCRIPT_CLASS>::value,
176 "Template type of AddAuxDataScriptMethods must derive from UtScriptClass");
177
178 // Add each of the aux data method objects to the class.
179 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::SetAuxData>());
180 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::AuxDataBool>());
181 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::AuxDataInt>());
182 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::AuxDataDouble>());
183 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::AuxDataString>());
184 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::AuxDataObject>());
185 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::AuxDataExists>());
186 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::AuxDataExists>("CheckAuxData"));
187 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::DeleteAuxData>());
188 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::HasAuxData>());
189 aScriptClass.AddMethod(ut::make_unique<typename SCRIPT_CLASS::GetAllAuxDataTypes>());
190}
191} // namespace WsfScriptAuxDataUtil
192
193// Macro for declaring standard aux-data methods on a script class
194#define UT_DECLARE_AUX_DATA_SCRIPT_METHODS() \
195 UT_DECLARE_SCRIPT_METHOD(SetAuxData); \
196 UT_DECLARE_SCRIPT_METHOD(AuxDataBool); \
197 UT_DECLARE_SCRIPT_METHOD(AuxDataInt); \
198 UT_DECLARE_SCRIPT_METHOD(AuxDataDouble); \
199 UT_DECLARE_SCRIPT_METHOD(AuxDataString); \
200 UT_DECLARE_SCRIPT_METHOD(AuxDataObject); \
201 UT_DECLARE_SCRIPT_METHOD(AuxDataExists); \
202 UT_DECLARE_SCRIPT_METHOD(CheckAuxData); \
203 UT_DECLARE_SCRIPT_METHOD(DeleteAuxData); \
204 UT_DECLARE_SCRIPT_METHOD(HasAuxData); \
205 UT_DECLARE_SCRIPT_METHOD(GetAllAuxDataTypes);
206
207// Macro for defining aux-data methods on a script class
208#define UT_DEFINE_AUX_DATA_SCRIPT_METHODS(CLASS, OBJ_TYPE) \
209 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, SetAuxData, 2, "void", "string, Object") \
210 { \
211 WsfScriptAuxDataUtil::SetAuxData<OBJ_TYPE>(aObjectPtr, aVarArgs, aReturnVal, aReturnClassPtr, aInterfaceMethodPtr); \
212 } \
213 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, AuxDataBool, 1, "bool", "string") \
214 { \
215 WsfScriptAuxDataUtil::GetAuxData<OBJ_TYPE, bool>(aObjectPtr, aVarArgs, aReturnVal, aReturnClassPtr, aInterfaceMethodPtr); \
216 } \
217 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, AuxDataInt, 1, "int", "string") \
218 { \
219 WsfScriptAuxDataUtil::GetAuxData<OBJ_TYPE, int>(aObjectPtr, aVarArgs, aReturnVal, aReturnClassPtr, aInterfaceMethodPtr); \
220 } \
221 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, AuxDataDouble, 1, "double", "string") \
222 { \
223 WsfScriptAuxDataUtil::GetAuxData<OBJ_TYPE, double>(aObjectPtr, aVarArgs, aReturnVal, aReturnClassPtr, aInterfaceMethodPtr); \
224 } \
225 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, AuxDataString, 1, "string", "string") \
226 { \
227 WsfScriptAuxDataUtil::GetAuxData<OBJ_TYPE, std::string>(aObjectPtr, \
228 aVarArgs, \
229 aReturnVal, \
230 aReturnClassPtr, \
231 aInterfaceMethodPtr); \
232 } \
233 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, AuxDataObject, 1, "Object", "string") \
234 { \
235 WsfScriptAuxDataUtil::GetAuxData<OBJ_TYPE, UtScriptData>(aObjectPtr, \
236 aVarArgs, \
237 aReturnVal, \
238 aReturnClassPtr, \
239 aInterfaceMethodPtr); \
240 } \
241 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, AuxDataExists, 1, "bool", "string") \
242 { \
243 aReturnVal.SetBool(aObjectPtr->GetAuxDataConst().AttributeExists(aVarArgs[0].GetString())); \
244 } \
245 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, DeleteAuxData, 1, "bool", "string") \
246 { \
247 aReturnVal.SetBool(aObjectPtr->GetAuxData().Delete(aVarArgs[0].GetString())); \
248 } \
249 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, HasAuxData, 0, "bool", "") \
250 { \
251 aReturnVal.SetBool(aObjectPtr->HasAuxData()); \
252 } \
253 UT_DEFINE_SCRIPT_METHOD(CLASS, OBJ_TYPE, GetAllAuxDataTypes, 0, "Map<string,string>", "") \
254 { \
255 WsfScriptAuxDataUtil::GetAllAuxDataTypes<OBJ_TYPE>(aObjectPtr, aReturnVal, aReturnClassPtr); \
256 }
257
258#endif
UtScriptData
ut::script::Data UtScriptData
Definition WsfScriptContext.hpp:47
WsfScriptAuxDataUtil
Definition WsfScriptAuxDataUtil.hpp:25
WsfScriptAuxDataUtil::GetAllAuxDataTypes
void GetAllAuxDataTypes(OBJECT_TYPE *aObjectPtr, UtScriptData &aReturnVal, UtScriptClass *aReturnClassPtr)
Definition WsfScriptAuxDataUtil.hpp:156
WsfScriptAuxDataUtil::AddAuxDataScriptMethods
void AddAuxDataScriptMethods(SCRIPT_CLASS &aScriptClass)
Definition WsfScriptAuxDataUtil.hpp:173
WsfScriptAuxDataUtil::SetAuxData
void SetAuxData(OBJECT_TYPE *aObjectPtr, UtScriptMethodArgs aVarArgs, UtScriptData &aReturnVal, UtScriptClass *aReturnClassPtr, UtScriptClass::InterfaceMethod *aInterfaceMethodPtr, bool aSilentFailure=false)
Definition WsfScriptAuxDataUtil.hpp:113
WsfScriptAuxDataUtil::GetAuxData
void GetAuxData(OBJECT_TYPE *aObjectPtr, UtScriptMethodArgs aVarArgs, UtScriptData &aReturnVal, UtScriptClass *aReturnClassPtr, UtScriptClass::InterfaceMethod *aInterfaceMethodPtr)
Definition WsfScriptAuxDataUtil.hpp:27
Copyrights Multiple, All Rights Reserved