WSF
WsfPProxyNode.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// Updated by Infoscitex, a DCS Company.
13// ****************************************************************************
14
15#ifndef WSFPPROXYNODE_HPP
16#define WSFPPROXYNODE_HPP
17
18#include "UtCompilerAttributes.hpp"
19#include "UtTextDocument.hpp"
20#include "WsfPProxy.hpp"
21#include "WsfPProxyPath.hpp"
22#include "WsfPProxyValue.hpp"
23
24class WsfPProxyIndexNode;
25
26/*
27Undo for IDE
28------------
29Can't use the standard proxy undo class because it won't emit notifications for changed items on undo
30 -need to emit notifications for proxy changes made while doing undo
31 -need to propagate type information when doing the undo
32plan:
33 Make an undo construct at the proxy node level
34 -notifications are available
35 -path info is available
36 Any time a change is made, go through these methods:
37 void WsfPProxyNode::assign(const BasicType& aValue);
38 void WsfPProxyNode::AssignAttribute(const std::string& aName, const BasicType& aValue);
39 void WsfPM_ObjectMap::remove()
40 void WsfPM_ObjectMap::add()
41 void WsfPM_List::pushBack(WsfPProxyValue)
42 void WsfPM_List::popBack();
43
44 Each of which will do this:
45 if can do operation:
46 call WsfPProxy::beforeModify()
47 (application handles to save undo data)
48 apply changes to proxy
49 call WsfPProxy::modify...()
50
51
52*/
53
54// Represents a position in the proxy.
55// This is a combination of a proxy root and a proxy path.
56// Keeps reference to the value currently pointed to by the proxy path.
57// Users of this class need to call invalidate() if it is possible the value no
58// longer exists in the proxy.
59class WSF_PARSER_EXPORT WsfPProxyNode
60{
61public:
62 void MoveTo(WsfPProxy* aProxy, const WsfPProxyPath& aPath, size_t aSubPathLength);
63
64 WsfPProxyNode();
65 WsfPProxyNode(WsfPProxy* aProxy, const WsfPProxyPath& aPath);
66 WsfPProxyNode(WsfPProxy* aProxy, const WsfPProxyPath& aPath, size_t aSubPathLength);
67 WsfPProxyNode(WsfPProxy* aProxy, const WsfPProxyPath& aPath, WsfPProxyValue aValue);
68 WsfPProxyNode(const WsfPProxyNode& aSrc);
69
70 static WsfPProxyNode FromProxy(WsfPProxy* aProxy);
71
72 WsfPProxyNode Root() const;
73 WsfPProxy* GetProxy() const { return mProxy; }
74 WsfPProxyValue GetRoot() const;
75 WsfPProxyValue GetValue() const;
76 WsfPProxyNode GetParent() const;
77 WsfPProxyNode GetInherited() const;
78 const WsfPProxyPath& GetPath() const;
79 std::string GetPathString() const;
80 WsfPProxyPath GetStablePath() const;
81 WsfPProxyPath GetInheritedPath() const;
82 const WsfPProxyPath* GetTypePath() const;
83 const WsfPProxyPath* GetBasePath() const;
84 std::string GetName() const;
85 std::string GetAttrName() const;
86 std::string GetInheritedName() const;
87 std::string GetTypeName() const;
88 std::vector<std::string> GetInheritedTypeNames() const;
99 /*CPP14_DEPRECATED*/ UtTextDocumentRange GetSourceDocumentRange() const;
102 UtTextDocumentRange GetFirstDocumentRange() const noexcept;
106 UtTextDocumentRange GetLastDocumentRange() const noexcept;
107 std::string GetSourceText() const;
108
109 WsfPProxyIndexNode* FindIndexNode() const;
110
111 const std::set<WsfPProxyPath>* GetInheritedValuePaths() const;
112
114
115
128 bool IsOfBasicType() const noexcept;
129
136 bool IsA_BasicType() const noexcept;
139 bool IsA_StructType() const noexcept;
142 bool IsA_ListType() const noexcept;
145 bool IsA_MapType() const noexcept;
146
150 bool IsOfBasicType(const std::string& aTypeName) const noexcept;
154 bool IsA_PredefinedStructTypeOf(const std::string& aTypeName) const noexcept;
158 bool IsOfUserType(const std::string& aTypeName) const noexcept;
162 bool IsA_StructTypeOf(const std::string& aTypeName) const noexcept;
166 bool IsA_ListTypeOf(const std::string& aTypeName) const noexcept;
170 bool IsA_MapTypeOf(const std::string& aTypeName) const noexcept;
174 bool IsOfType(const std::string& aTypeName) const noexcept;
175
177
178 bool IsInherited() const;
179 bool IsInheritedFromParent() const;
180
181 void Invalidate();
182
189
190
194 bool SwitchToBasicTypes();
198 bool SwitchToUserTypes();
199
201
202 bool UpdateParentPath(const WsfPProxyPath& oldParentPath, const WsfPProxyPath& newParentPath);
203 void ResetToInheritedValue();
204
205 // Is the node pointing to a valid value
206 operator bool() const { return GetValue(); }
207 operator bool() { return GetValue(); }
208 bool IsValid() const { return GetValue(); }
209 bool IsNull() const { return !(bool)GetValue(); }
210
211 bool operator==(const WsfPProxyNode& aRhs) const { return mPath == aRhs.mPath; }
212 bool operator!=(const WsfPProxyNode& aRhs) const { return mPath != aRhs.mPath; }
213
214 // Navigation methods
215 // These methods access child proxy nodes
216 WsfPProxyNode& operator+=(size_t aIndex);
217 WsfPProxyNode& operator+=(const std::string& aStr);
218 WsfPProxyNode& operator+=(const WsfPProxyPath& aSuffixPath);
219 WsfPProxyNode& operator+=(const WsfPProxyKey& aEntry);
220 WsfPProxyNode& operator+=(const WsfParseTypePath& aParseTypePath);
221 WsfPProxyNode operator+(const WsfPProxyPath& aSuffixPath) const { return WsfPProxyNode(*this) += aSuffixPath; }
222 WsfPProxyNode operator+(const WsfPProxyKey& aEntry) const;
223 WsfPProxyNode operator+(size_t aEntryIndex) const;
224 WsfPProxyNode operator+(const std::string& aEntry) const;
225 WsfPProxyNode operator+(const char* aEntry) const;
226 WsfPProxyNode operator+(const WsfParseTypePath& aParseTypePath) const;
227
228 WsfPProxyNode& ToParent()
229 {
230 mIsCurrent = false;
231 mPath.Pop();
232 return *this;
233 }
234 WsfPProxyNode& TrimPath(size_t aPathLength)
235 {
236 if (mPath.size() > aPathLength)
237 {
238 mPath.Trim(aPathLength);
239 mIsCurrent = false;
240 }
241 return *this;
242 }
243 // Comparison operator for ordering by path
244 bool operator<(const WsfPProxyNode& aRhs) const;
245
246 void SetBasePath(const WsfPProxyPath& aNewPath);
247
248 void NotifyValueChanged() const;
249
250 void NotifyValueAdded() const;
251 void NotifyValueRemoved() const;
252 void NotifyValueMoved(const std::string& aOldName) const;
253 void NotifyAttributeChanged(const char* aAttributeName) const;
254
255 void NotifyBeforeValueChanged() const;
256 void NotifyBeforeAttributeChanged(const char* aAttributeName) const;
257
258 template<typename T>
259 void ChangeAttribute(const char* aAttributeName, const T& aValue)
260 {
261 ChangeAttributeP(aAttributeName, GetValue().GetAttr(aAttributeName), (void*)&aValue, T::cPROXY_TYPE_ID);
262 }
263 bool Assign(const WsfPProxyValue& aValue) const;
264 bool Assign(const std::string& aValue) const;
265 bool Assign(int aIntValue) const;
266 bool Assign(double aDoubleVal) const;
267 bool Assign(bool aBoolVal) const;
268 bool ClearUnset() const;
269 bool Unset() const;
270 bool UnsetAttribute(const std::string& aAttrName) const;
271
272 bool AssignAttribute(const std::string& aAttrName, const std::string& aValue) const;
273 bool AssignAttribute(const std::string& aAttrName, int aIntValue) const;
274 bool AssignAttribute(const std::string& aAttrName, double aDoubleVal) const;
275 bool AssignAttribute(const std::string& aAttrName, bool aBoolVal) const;
276 /* Attribute assignment
277 * Assigns a value to a child attribute. Invokes notification callbacks if available.
278 * returns 'false' if the attribute remains unchanged (due to invalid type or assignment to same value)
279 */
280 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::String& aValue) const;
281 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Double& aValue) const;
282 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Int& aValue) const;
283 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Latitude& aValue) const;
284 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Longitude& aValue) const;
285 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Length& aValue) const;
286 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Length2& aValue) const;
287 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Time& aValue) const;
288 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Speed& aValue) const;
289 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::DataSize& aValue) const;
290 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Power& aValue) const;
291 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::PowerDB& aValue) const;
292 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::SolidAngle& aValue) const;
293 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Mass& aValue) const;
294 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Force& aValue) const;
295 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Torque& aValue) const;
296 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Area& aValue) const;
297 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::AreaDB& aValue) const;
298 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Volume& aValue) const;
299 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Time2& aValue) const;
300 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Acceleration& aValue) const;
301 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Frequency& aValue) const;
302 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Angle& aValue) const;
303 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::AngularRate& aValue) const;
304 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::AngularAcceleration& aValue) const;
305 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::DataRate& aValue) const;
306 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::MassDensity& aValue) const;
307 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::MassTransfer& aValue) const;
308 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Energy& aValue) const;
309 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Fluence& aValue) const;
310 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Irradiance& aValue) const;
311 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Ratio& aValue) const;
312 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::NoisePressure& aValue) const;
313 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Pressure& aValue) const;
314 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Temperature& aValue) const;
315 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::SpecificRange& aValue) const;
316 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::AngularInertia& aValue) const;
317 bool AssignAttribute(const std::string& aAttrName, const WsfProxy::Position& aValue) const;
318
319 /* assignment
320 * Assigns a basic value to a node. Invokes notification callbacks if available.
321 * returns 'false' if the value remains unchanged (due to invalid type or assignment to same value)
322 */
323 bool Assign(const WsfProxy::String& aValue) const;
324 bool Assign(const WsfProxy::Double& aValue) const;
325 bool Assign(const WsfProxy::Int& aValue) const;
326 bool Assign(const WsfProxy::Latitude& aValue) const;
327 bool Assign(const WsfProxy::Longitude& aValue) const;
328 bool Assign(const WsfProxy::Length& aValue) const;
329 bool Assign(const WsfProxy::Length2& aValue) const;
330 bool Assign(const WsfProxy::Time& aValue) const;
331 bool Assign(const WsfProxy::Speed& aValue) const;
332 bool Assign(const WsfProxy::DataSize& aValue) const;
333 bool Assign(const WsfProxy::Power& aValue) const;
334 bool Assign(const WsfProxy::PowerDB& aValue) const;
335 bool Assign(const WsfProxy::SolidAngle& aValue) const;
336 bool Assign(const WsfProxy::Mass& aValue) const;
337 bool Assign(const WsfProxy::Force& aValue) const;
338 bool Assign(const WsfProxy::Torque& aValue) const;
339 bool Assign(const WsfProxy::Area& aValue) const;
340 bool Assign(const WsfProxy::AreaDB& aValue) const;
341 bool Assign(const WsfProxy::Volume& aValue) const;
342 bool Assign(const WsfProxy::Time2& aValue) const;
343 bool Assign(const WsfProxy::Acceleration& aValue) const;
344 bool Assign(const WsfProxy::Frequency& aValue) const;
345 bool Assign(const WsfProxy::Angle& aValue) const;
346 bool Assign(const WsfProxy::AngularRate& aValue) const;
347 bool Assign(const WsfProxy::AngularAcceleration& aValue) const;
348 bool Assign(const WsfProxy::DataRate& aValue) const;
349 bool Assign(const WsfProxy::MassDensity& aValue) const;
350 bool Assign(const WsfProxy::MassTransfer& aValue) const;
351 bool Assign(const WsfProxy::Energy& aValue) const;
352 bool Assign(const WsfProxy::Fluence& aValue) const;
353 bool Assign(const WsfProxy::Irradiance& aValue) const;
354 bool Assign(const WsfProxy::Ratio& aValue) const;
355 bool Assign(const WsfProxy::NoisePressure& aValue) const;
356 bool Assign(const WsfProxy::Pressure& aValue) const;
357 bool Assign(const WsfProxy::Temperature& aValue) const;
358 bool Assign(const WsfProxy::SpecificRange& aValue) const;
359 bool Assign(const WsfProxy::AngularInertia& aValue) const;
360 bool Assign(const WsfProxy::Position& aValue) const;
361
362 // see JSON_OutputOptions
363 std::string ToJSON(int aOutputFlags = 0) const;
364
365protected:
366 template<typename T>
367 T GetAttributeT(const std::string& aName) const
368 {
369 T* attrPtr = GetValue().GetAttr(aName);
370 if (attrPtr)
371 {
372 return *attrPtr;
373 }
374 return T();
375 }
376
377private:
378 // assign an attribute
379 template<typename T>
380 bool AssignAttributeT(const std::string& aAttrName, const T& aValue) const
381 {
382 // we could just navigate to attribute node and call assignT(), but this
383 // avoids making a new node instance if the value isn't changing
384 bool modified = false;
385 WsfPProxyValue val = GetValue().GetAttr(aAttrName);
386 const WsfPProxyType* typePtr = val.GetType();
387 if (typePtr && typePtr->mTypeStoredKind == T::cPROXY_TYPE_ID)
388 {
389 T& thisValue = *(T*)val.GetDataPtr();
390 if (!(thisValue == aValue))
391 {
392 WsfPProxyNode attrNode = *this + aAttrName;
393 attrNode.NotifyBeforeValueChanged();
394 thisValue = aValue;
395 attrNode.NotifyValueChanged();
396 modified = true;
397 }
398 }
399 return modified;
400 }
401
402 template<typename T>
403 bool AssignT(const T& aValue) const
404 {
405 bool modified = false;
406 WsfPProxyValue val = GetValue();
407 const WsfPProxyType* typePtr = val.GetType();
408 if (typePtr && typePtr->mTypeStoredKind == T::cPROXY_TYPE_ID)
409 {
410 T& thisValue = *(T*)val.GetDataPtr();
411 if (!(thisValue == aValue))
412 {
413 NotifyBeforeValueChanged();
414 thisValue = aValue;
415 NotifyValueChanged();
416 modified = true;
417 }
418 }
419 return modified;
420 }
421
422 template<typename NUMBER_TYPE>
423 bool AssignNumericP(NUMBER_TYPE aValue) const
424 {
425 WsfPProxyValue value = GetValue();
426 const WsfPProxyType* typePtr = value.GetType();
427 bool modified = false;
428 if (typePtr)
429 {
430 switch (typePtr->mTypeStoredKind)
431 {
432 case WsfProxy::cINT_VALUE:
433 {
434 WsfProxy::Int& val = *((WsfProxy::Int*)value.GetDataPtr());
435 if (val.GetValue() != static_cast<int>(aValue))
436 {
437 NotifyBeforeValueChanged();
438 val.SetValue(static_cast<int>(aValue));
439 NotifyValueChanged();
440 modified = true;
441 }
442 break;
443 }
444 case WsfProxy::cDOUBLE_VALUE:
445 {
446 WsfProxy::Double& val = *((WsfProxy::Double*)value.GetDataPtr());
447 if (val.GetValue() != static_cast<double>(aValue))
448 {
449 NotifyBeforeValueChanged();
450 val.SetValue(static_cast<double>(aValue));
451 NotifyValueChanged();
452 modified = true;
453 }
454 break;
455 }
456 }
457 }
458 return modified;
459 }
460
461 void ChangeAttributeP(const char* aAttrName, const WsfPProxyValue& aAttribute, void* aNewValuePtr, int aNewValueType) const;
462
463 // true if mValue points to the correct value
464 mutable bool mIsCurrent;
465 // true if mValue points to a value in the 'basic root'
466 mutable bool mIsOfBasicType;
467 // A number which should match the sequence number in mProxy
468 // A number mismatch indicates the proxy has been refreshed with new data
469 // and mValue should be looked up again
470 mutable short mProxySequenceNumber;
471
472protected:
473 WsfPProxyPath mPath;
474
475private:
476 // Access to all proxy data
477 WsfPProxy* mProxy;
478 // The value pointed to by this node, when it's current
479 mutable WsfPProxyValue mValue;
480};
481
482
483#endif
WsfParseTypePath
std::vector< UtStringRef > WsfParseTypePath
Definition WsfParseTypePath.hpp:21
WsfPProxyIndexNode
Definition WsfPProxyIndex.hpp:38
WsfPProxyKey
Definition WsfPProxyKey.hpp:24
WsfPProxyNode
Definition WsfPProxyNode.hpp:60
WsfPProxyNode::MoveTo
void MoveTo(WsfPProxy *aProxy, const WsfPProxyPath &aPath, size_t aSubPathLength)
Definition WsfPProxyNode.cpp:1253
WsfPProxyNode::IsNull
bool IsNull() const
Definition WsfPProxyNode.hpp:209
WsfPProxyNode::operator==
bool operator==(const WsfPProxyNode &aRhs) const
Definition WsfPProxyNode.hpp:211
WsfPProxyNode::GetValue
WsfPProxyValue GetValue() const
Definition WsfPProxyNode.cpp:79
WsfPProxyNode::GetProxy
WsfPProxy * GetProxy() const
Definition WsfPProxyNode.hpp:73
WsfPProxyNode::IsValid
bool IsValid() const
Definition WsfPProxyNode.hpp:208
WsfPProxyNode::ChangeAttribute
void ChangeAttribute(const char *aAttributeName, const T &aValue)
Definition WsfPProxyNode.hpp:259
WsfPProxyNode::operator!=
bool operator!=(const WsfPProxyNode &aRhs) const
Definition WsfPProxyNode.hpp:212
WsfPProxyNode::ToParent
WsfPProxyNode & ToParent()
Definition WsfPProxyNode.hpp:228
WsfPProxyNode::NotifyBeforeValueChanged
void NotifyBeforeValueChanged() const
Definition WsfPProxyNode.cpp:768
WsfPProxyNode::FromProxy
static WsfPProxyNode FromProxy(WsfPProxy *aProxy)
Definition WsfPProxyNode.cpp:69
WsfPProxyNode::Root
WsfPProxyNode Root() const
Definition WsfPProxyNode.cpp:738
WsfPProxyNode::WsfPProxyNode
WsfPProxyNode()
Definition WsfPProxyNode.cpp:24
WsfPProxyNode::operator+
WsfPProxyNode operator+(const WsfPProxyPath &aSuffixPath) const
Definition WsfPProxyNode.hpp:221
WsfPProxyNode::GetAttributeT
T GetAttributeT(const std::string &aName) const
Definition WsfPProxyNode.hpp:367
WsfPProxyNode::mPath
WsfPProxyPath mPath
Definition WsfPProxyNode.hpp:473
WsfPProxyNode::NotifyValueChanged
void NotifyValueChanged() const
Definition WsfPProxyNode.cpp:762
WsfPProxyNode::TrimPath
WsfPProxyNode & TrimPath(size_t aPathLength)
Definition WsfPProxyNode.hpp:234
WsfPProxyPath
Represents a path or unique key to a value in the proxy.
Definition WsfPProxyPath.hpp:64
WsfPProxyType
Definition WsfPProxyType.hpp:37
WsfPProxyType::mTypeStoredKind
int mTypeStoredKind
Definition WsfPProxyType.hpp:57
WsfPProxyValue
Definition WsfPProxyValue.hpp:33
WsfPProxyValue::GetType
const WsfPProxyType * GetType() const
Definition WsfPProxyValue.hpp:61
WsfPProxyValue::GetAttr
WsfPProxyValue GetAttr(const WsfPProxyKey &aEntry) const
Definition WsfPProxyValue.hpp:62
WsfPProxyValue::GetDataPtr
void * GetDataPtr() const
Definition WsfPProxyValue.hpp:60
WsfPProxy
Definition WsfPProxy.hpp:32
WsfProxy::BasicValueT::GetValue
T & GetValue()
Definition WsfPProxyBasicValues.hpp:347
WsfProxy::BasicValueT::SetValue
void SetValue(const T &aValue)
Definition WsfPProxyBasicValues.hpp:349
WsfProxy::Length2
Definition WsfPProxyBasicValues.hpp:167
WsfProxy::Position
Definition WsfPProxyBasicValues.hpp:89
WsfProxy::String
Definition WsfPProxyBasicValues.hpp:478
WsfProxy::Time
NumericUnitaryValueT< UtTimeValue, WsfProxy::cTIME_VALUE > Time
Definition WsfPProxyBasicValues.hpp:415
WsfProxy::Time2
NumericUnitaryValueT< UtTime2Value, WsfProxy::cTIME2_VALUE > Time2
Definition WsfPProxyBasicValues.hpp:439
WsfProxy::Torque
NumericUnitaryValueT< UtTorqueValue, WsfProxy::cTORQUE_VALUE > Torque
Definition WsfPProxyBasicValues.hpp:431
WsfProxy::Ratio
NumericUnitaryValueT< UtRatioValue, WsfProxy::cRATIO_VALUE > Ratio
Definition WsfPProxyBasicValues.hpp:463
WsfProxy::Longitude
NumericValueT< UtLonPos, WsfProxy::cLONGITUDE_VALUE > Longitude
Definition WsfPProxyBasicValues.hpp:411
WsfProxy::Length
NumericUnitaryValueT< UtLengthValue, WsfProxy::cLENGTH_VALUE > Length
Definition WsfPProxyBasicValues.hpp:413
WsfProxy::AngularInertia
NumericUnitaryValueT< UtAngularInertiaValue, WsfProxy::cANGULARINERTIA_VALUE > AngularInertia
Definition WsfPProxyBasicValues.hpp:473
WsfProxy::DataRate
NumericUnitaryValueT< UtDataRateValue, WsfProxy::cDATARATE_VALUE > DataRate
Definition WsfPProxyBasicValues.hpp:451
WsfProxy::AreaDB
NumericUnitaryValueT< UtAreaDBValue, WsfProxy::cAREADB_VALUE > AreaDB
Definition WsfPProxyBasicValues.hpp:435
WsfProxy::SpecificRange
NumericUnitaryValueT< UtSpecificRangeValue, WsfProxy::cSPECIFICRANGE_VALUE > SpecificRange
Definition WsfPProxyBasicValues.hpp:471
WsfProxy::Frequency
NumericUnitaryValueT< UtFrequencyValue, WsfProxy::cFREQUENCY_VALUE > Frequency
Definition WsfPProxyBasicValues.hpp:443
WsfProxy::Area
NumericUnitaryValueT< UtAreaValue, WsfProxy::cAREA_VALUE > Area
Definition WsfPProxyBasicValues.hpp:433
WsfProxy::Volume
NumericUnitaryValueT< UtVolumeValue, WsfProxy::cVOLUME_VALUE > Volume
Definition WsfPProxyBasicValues.hpp:437
WsfProxy::Fluence
NumericUnitaryValueT< UtFluenceValue, WsfProxy::cFLUENCE_VALUE > Fluence
Definition WsfPProxyBasicValues.hpp:459
WsfProxy::Speed
NumericUnitaryValueT< UtSpeedValue, WsfProxy::cSPEED_VALUE > Speed
Definition WsfPProxyBasicValues.hpp:417
WsfProxy::cDOUBLE_VALUE
@ cDOUBLE_VALUE
Definition WsfPProxyCommon.hpp:48
WsfProxy::cINT_VALUE
@ cINT_VALUE
Definition WsfPProxyCommon.hpp:46
WsfProxy::Latitude
NumericValueT< UtLatPos, WsfProxy::cLATITUDE_VALUE > Latitude
Definition WsfPProxyBasicValues.hpp:409
WsfProxy::PowerDB
NumericUnitaryValueT< UtPowerDBValue, WsfProxy::cPOWERDB_VALUE > PowerDB
Definition WsfPProxyBasicValues.hpp:423
WsfProxy::Int
NumericValueT< int, WsfProxy::cINT_VALUE > Int
Definition WsfPProxyBasicValues.hpp:407
WsfProxy::AngularAcceleration
NumericUnitaryValueT< UtAngularAccelerationValue, WsfProxy::cANGULARACCELERATION_VALUE > AngularAcceleration
Definition WsfPProxyBasicValues.hpp:449
WsfProxy::Irradiance
NumericUnitaryValueT< UtIrradianceValue, WsfProxy::cIRRADIANCE_VALUE > Irradiance
Definition WsfPProxyBasicValues.hpp:461
WsfProxy::Power
NumericUnitaryValueT< UtPowerValue, WsfProxy::cPOWER_VALUE > Power
Definition WsfPProxyBasicValues.hpp:421
WsfProxy::DataSize
NumericUnitaryValueT< UtDataSizeValue, WsfProxy::cDATASIZE_VALUE > DataSize
Definition WsfPProxyBasicValues.hpp:419
WsfProxy::MassTransfer
NumericUnitaryValueT< UtMassTransferValue, WsfProxy::cMASSTRANSFER_VALUE > MassTransfer
Definition WsfPProxyBasicValues.hpp:455
WsfProxy::MassDensity
NumericUnitaryValueT< UtMassDensityValue, WsfProxy::cMASSDENSITY_VALUE > MassDensity
Definition WsfPProxyBasicValues.hpp:453
WsfProxy::SolidAngle
NumericUnitaryValueT< UtSolidAngleValue, WsfProxy::cSOLIDANGLE_VALUE > SolidAngle
Definition WsfPProxyBasicValues.hpp:425
WsfProxy::Angle
NumericUnitaryValueT< UtAngleValue, WsfProxy::cANGLE_VALUE > Angle
Definition WsfPProxyBasicValues.hpp:445
WsfProxy::Force
NumericUnitaryValueT< UtForceValue, WsfProxy::cFORCE_VALUE > Force
Definition WsfPProxyBasicValues.hpp:429
WsfProxy::Acceleration
NumericUnitaryValueT< UtAccelerationValue, WsfProxy::cACCELERATION_VALUE > Acceleration
Definition WsfPProxyBasicValues.hpp:441
WsfProxy::Energy
NumericUnitaryValueT< UtEnergyValue, WsfProxy::cENERGY_VALUE > Energy
Definition WsfPProxyBasicValues.hpp:457
WsfProxy::AngularRate
NumericUnitaryValueT< UtAngularRateValue, WsfProxy::cANGULARRATE_VALUE > AngularRate
Definition WsfPProxyBasicValues.hpp:447
WsfProxy::Temperature
NumericUnitaryValueT< UtTemperatureValue, WsfProxy::cTEMPERATURE_VALUE > Temperature
Definition WsfPProxyBasicValues.hpp:469
WsfProxy::Mass
NumericUnitaryValueT< UtMassValue, WsfProxy::cMASS_VALUE > Mass
Definition WsfPProxyBasicValues.hpp:427
WsfProxy::NoisePressure
NumericUnitaryValueT< UtNoisePressureValue, WsfProxy::cNOISEPRESSURE_VALUE > NoisePressure
Definition WsfPProxyBasicValues.hpp:465
WsfProxy::Pressure
NumericUnitaryValueT< UtPressureValue, WsfProxy::cPRESSURE_VALUE > Pressure
Definition WsfPProxyBasicValues.hpp:467
WsfProxy::Double
NumericValueT< double, WsfProxy::cDOUBLE_VALUE > Double
Definition WsfPProxyBasicValues.hpp:405
std
Template specialization for wsf::comm::Address. Allows usage of Address in std::unordered_map/set.
Definition WsfCommAddress.hpp:185
Copyrights Multiple, All Rights Reserved