private unsafe int GetEnumerated(PIActionReference reference, uint *type, uint *enumValue)
{
if (enumValue == null)
{
return(PSError.kSPBadParameterError);
}
ActionReferenceContainer container;
if (actionReferences.TryGetValue(reference, out container))
{
ActionReferenceItem item = container.GetReference();
if (item != null)
{
EnumeratedValue enumerated = (EnumeratedValue)item.Value;
if (type != null)
{
*type = enumerated.Type;
}
*enumValue = enumerated.Value;
return(PSError.kSPNoError);
}
}
return(PSError.kSPBadParameterError);
}
public void GivenOperationDataWithSpatialRecordDataWithEnumeratedValueWhenProcessOperationDataThenRowsAreAdded()
{
var meter = new EnumeratedWorkingData {
Representation = RepresentationInstanceList.dtRecordingStatus.ToModelRepresentation()
};
_workingDatas.Add(meter);
_deviceElementUses.Add(0, new List <DeviceElementUse>
{
new DeviceElementUse
{
Depth = 0,
GetWorkingDatas = () => _workingDatas,
}
});
var spatialRecord = new SpatialRecord();
var enumeratedValue = new EnumeratedValue {
Value = DefinedTypeEnumerationInstanceList.dtiRecordingStatusOn.ToModelEnumMember()
};
spatialRecord.SetMeterValue(meter, enumeratedValue);
_spatialRecords.Add(spatialRecord);
var dataTable = _operationDataProcessor.ProcessOperationData(_operationData, _spatialRecords);
Assert.AreEqual(1, dataTable.Rows.Count);
Assert.AreEqual(enumeratedValue.Value.Value, dataTable.Rows[0][4]);
}
public EnumeratedValue ImportCodedComment(ISOCodedComment comment)
{
EnumeratedValue value = new EnumeratedValue();
value.Designator = comment.CodedCommentDesignator;
value.Representation = new EnumeratedRepresentation();
value.Representation.EnumeratedMembers = _listMapper.ImportCodedCommentListValues(comment.CodedCommentListValues).ToList();
return(value);
}
public ISOCodedComment ExportCodedComment(EnumeratedValue value)
{
ISOCodedComment comment = new ISOCodedComment();
comment.CodedCommentID = GenerateId();
comment.CodedCommentDesignator = value.Representation.Description;
comment.CodedCommentListValues = _listMapper.ExportCodedCommentList(value.Representation.EnumeratedMembers).ToList();
ExportedComments.Add(comment);
return(comment);
}
private static EnumeratedValue ParseEnumerated(BinaryReverseReader reader)
{
EnumeratedValue value = new EnumeratedValue()
{
type = ParseKey(reader),
value = ParseKey(reader)
};
return(value);
}
public void GivenIsoSpatialRowsWithoutEnumeratedMeterOnSecondWhenMapThenSecondValueIsInterpolator()
{
var spatialValue = new SpatialValue
{
Id = 0,
Value = 1
};
_isoSpatialRow.SpatialValues = new List <SpatialValue> {
spatialValue
};
var isoSpatialRow2 = new ISOSpatialRow {
SpatialValues = new List <SpatialValue>()
};
_isoSpatialRows = new List <ISOSpatialRow> {
_isoSpatialRow, isoSpatialRow2
};
var meter = new ISOEnumeratedMeter
{
Representation = RepresentationInstanceList.dtSectionControlMasterState.ToModelRepresentation(),
ValueCodes = new List <int> {
1, 2, 3
},
DeviceElementUseId = 1,
GetEnumeratedValue = (sv, im) => new EnumeratedValue {
Value = new AgGateway.ADAPT.ApplicationDataModel.Representations.EnumerationMember {
Code = 3
}
}
};
var uniqueId = new UniqueId
{
IdType = IdTypeEnum.String,
Id = "DLV0"
};
meter.Id.UniqueIds.Add(uniqueId);
_meters.Add(meter);
var enumeratedRepresentation = new EnumeratedValue {
Value = new AgGateway.ADAPT.ApplicationDataModel.Representations.EnumerationMember {
Code = 3
}
};
_spatialValueInterpolator.Setup(s => s.Interpolate(meter)).Returns(enumeratedRepresentation);
var result = Map().ToList();
Assert.AreEqual(enumeratedRepresentation, result[1].GetMeterValue(meter) as EnumeratedValue);
}
private static void CompareWorkState(EnumeratedValue adaptEnumeratedValue, SpatialValue isoValue)
{
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiRecordingStatusOff.ToModelEnumMember().Code)
{
Assert.AreEqual(0, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiRecordingStatusOn.ToModelEnumMember().Code)
{
Assert.AreEqual(1, isoValue.Value);
}
}
private static void CompareNetWeightState(EnumeratedValue adaptEnumeratedValue, SpatialValue isoValue)
{
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiWeightUnStable.ToModelEnumMember().Code)
{
Assert.AreEqual(0, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiWeightStable.ToModelEnumMember().Code)
{
Assert.AreEqual(1, isoValue.Value);
}
}
private static void CompareCondensedSectionOverrideState(EnumeratedValue adaptEnumeratedValue, SpatialValue isoValue)
{
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiPrescriptionUsed.ToModelEnumMember().Code)
{
Assert.AreEqual(0, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiPrescriptionOverridden.ToModelEnumMember().Code)
{
Assert.AreEqual(1, isoValue.Value);
}
}
public IEnumerable <EnumeratedValue> ImportCodedComments(IEnumerable <ISOCodedComment> isoComments)
{
List <EnumeratedValue> enumerations = new List <EnumeratedValue>();
foreach (ISOCodedComment isoComment in isoComments)
{
EnumeratedValue enumeration = ImportCodedComment(isoComment);
enumerations.Add(enumeration);
}
return(enumerations);
}
private int PutEnumerated(PIActionList list, uint type, uint data)
{
try
{
EnumeratedValue item = new EnumeratedValue(type, data);
actionLists[list].Add(new ActionListItem(DescriptorTypes.Enumerated, item));
}
catch (OutOfMemoryException)
{
return(PSError.kSPOutOfMemoryError);
}
return(PSError.kSPNoError);
}
private static double GetActiveWidthFt(SpatialRecord spatialRecord, List <RowConfiguration> rows)
{
double activeWidthIn = 0;
foreach (RowConfiguration row in rows)
{
EnumeratedValue rowStatus = spatialRecord.GetMeterValue(row.statusMeter) as EnumeratedValue;
if (rowStatus.Value.Value == "On")
{
activeWidthIn += row.widthIn;
}
}
return(activeWidthIn / 12.0);
}
private static void ComparePrescriptionControl(EnumeratedValue adaptEnumeratedValue, SpatialValue isoValue)
{
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiPrscMasterManualOff.ToModelEnumMember().Code)
{
Assert.AreEqual(0, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiPrscMasterAutoOn.ToModelEnumMember().Code)
{
Assert.AreEqual(1, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiPrscMasterError.ToModelEnumMember().Code)
{
Assert.AreEqual(2, isoValue.Value);
}
}
public IEnumerable <DeviceElement> ImportDeviceElements(ISODevice isoDevice)
{
EnumeratedValue deviceClassification = DecodeMachineInfo(isoDevice.ClientNAME);
ISODeviceElement rootDeviceElement = isoDevice.DeviceElements.SingleOrDefault(det => det.DeviceElementType == ISODeviceElementType.Device);
if (rootDeviceElement == null)
{
//Short circuit on invalid TaskData
TaskDataMapper.AddError("Missing root DeviceElement. Device will not be imported.", isoDevice.DeviceId.ToString(), "DeviceElementMapper");
return(null);
}
DeviceElementHierarchy rootDeviceElementHierarchy = TaskDataMapper.DeviceElementHierarchies.Items[isoDevice.DeviceId];
//Import device elements
List <DeviceElement> adaptDeviceElements = new List <DeviceElement>();
//Import down the hierarchy to ensure integrity of parent references
for (int i = 0; i <= rootDeviceElementHierarchy.GetMaxDepth(); i++)
{
IEnumerable <ISODeviceElement> isoDeviceElements = rootDeviceElementHierarchy.GetElementsAtDepth(i).Select(h => h.DeviceElement);
foreach (ISODeviceElement isoDeviceElement in isoDeviceElements)
{
if (isoDeviceElement.DeviceElementType != ISODeviceElementType.Connector)
{
DeviceElement adaptDeviceElement = ImportDeviceElement(isoDeviceElement, deviceClassification, rootDeviceElementHierarchy);
if (isoDeviceElement.DeviceElementType == ISODeviceElementType.Device)
{
//Setting the Device serial number on the root Device Element only
adaptDeviceElement.SerialNumber = isoDevice.DeviceSerialNumber;
}
adaptDeviceElements.Add(adaptDeviceElement);
DataModel.Catalog.DeviceElements.Add(adaptDeviceElement);
}
else
{
//Connectors are not represented as DeviceElements in ADAPT
AddConnector(rootDeviceElementHierarchy, isoDeviceElement);
}
}
}
return(adaptDeviceElements);
}
private int PutEnumerated(IntPtr descriptor, uint key, uint type, uint data)
{
#if DEBUG
DebugUtils.Ping(DebugFlags.DescriptorParameters, string.Format("key: 0x{0:X4}({1})", key, DebugUtils.PropToString(key)));
#endif
try
{
EnumeratedValue item = new EnumeratedValue(type, data);
actionDescriptors[descriptor].Add(key, new AETEValue(DescriptorTypes.Enumerated, GetAETEParamFlags(key), 0, item));
}
catch (OutOfMemoryException)
{
return(PSError.memFullErr);
}
return(PSError.kSPNoError);
}
public void GivenEnumeratedRepresentationValueWhenInterpolateThenRepresentationValue()
{
var previousEnumeratedValue = new EnumeratedValue
{
Representation = RepresentationInstanceList.dtSkyCondition.ToModelRepresentation()
};
var enumMember = DefinedTypeEnumerationInstanceList.dtiSunny.ToModelEnumMember();
previousEnumeratedValue.Value = enumMember;
previousEnumeratedValue.Code = enumMember.Code;
_interpolator.SetMostRecentMeterValue(_enumeratedMeter, previousEnumeratedValue);
var result = _interpolator.Interpolate(_enumeratedMeter);
Assert.IsInstanceOf <EnumeratedValue>(result);
}
private static void CompareActualLoadingSystemStatus(EnumeratedValue adaptEnumeratedValue, SpatialValue isoValue)
{
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiUnloadingAugerStateDisabled.ToModelEnumMember().Code)
{
Assert.AreEqual(0, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiUnloadingAugerStateEnabled.ToModelEnumMember().Code)
{
Assert.AreEqual(1, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiUnloadingAugerStateError.ToModelEnumMember().Code)
{
Assert.AreEqual(2, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiUnloadingAugerStateNotAvailable.ToModelEnumMember().Code)
{
Assert.AreEqual(3, isoValue.Value);
}
}
private static void CompareSkyConditions(EnumeratedValue adaptEnumeratedValue, SpatialValue isoValue)
{
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiClear.ToModelEnumMember().Code)
{
Assert.AreEqual(0x20524C43, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiSunny.ToModelEnumMember().Code)
{
Assert.AreEqual(0x2043534E, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiPartlyCloudy.ToModelEnumMember().Code)
{
Assert.AreEqual(0x20544353, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiCloudy.ToModelEnumMember().Code)
{
Assert.AreEqual(0x2043564F, isoValue.Value);
}
}
private static void CompareConnectorType(EnumeratedValue adaptEnumeratedValue, SpatialValue isoValue)
{
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiDrawbar.ToModelEnumMember().Code)
{
Assert.AreEqual(1, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiRearTwoPoint.ToModelEnumMember().Code)
{
Assert.AreEqual(2, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiThreePoint.ToModelEnumMember().Code)
{
Assert.AreEqual(3, isoValue.Value);
}
if (adaptEnumeratedValue.Value.Code == DefinedTypeEnumerationInstanceList.dtiRearPivotWagonHitch.ToModelEnumMember().Code)
{
Assert.AreEqual(7, isoValue.Value);
}
}
private int GetEnumerated(IntPtr reference, ref uint type, ref uint enumValue)
{
ActionReferenceContainer container;
if (actionReferences.TryGetValue(reference, out container))
{
ActionReferenceItem item = container.GetReference();
if (item != null)
{
EnumeratedValue enumerated = (EnumeratedValue)item.Value;
type = enumerated.Type;
enumValue = enumerated.Value;
return(PSError.kSPNoError);
}
}
return(PSError.kSPBadParameterError);
}
private void WriteListValues(XmlWriter writer, EnumeratedValue value)
{
if (value == null)
{
return;
}
if (value.Representation != null &&
value.Representation.EnumeratedMembers != null)
{
_listWriter.Write(writer, value.Representation.EnumeratedMembers);
}
else if (value.Value != null)
{
_listWriter.Write(writer, new List <EnumerationMember> {
value.Value
});
}
}
public RepresentationValue Interpolate(WorkingData meter)
{
if (!_meterToPreviousValue.ContainsKey(meter))
{
return(null);
}
var previousValue = _meterToPreviousValue[meter];
var numericRepresentationValue = previousValue as NumericRepresentationValue;
if (numericRepresentationValue != null)
{
var newNumericRepresentationValue = numericRepresentationValue.Copy();
if (numericRepresentationValue.Representation != null && _numericRepresentationTotals.Contains(numericRepresentationValue.Representation.Code))
{
newNumericRepresentationValue.Value.Value = 0;
}
return(newNumericRepresentationValue);
}
var enumeratedValue = previousValue as EnumeratedValue;
if (enumeratedValue != null)
{
var newEnumeratedValue = new EnumeratedValue
{
Code = enumeratedValue.Code,
Value = new EnumerationMember
{
Code = enumeratedValue.Value.Code,
Value = enumeratedValue.Value.Value
},
Representation = enumeratedValue.Representation
};
return(newEnumeratedValue);
}
return(null);
}
public void GivenEnumeratedValueWhenInterpolateThenValueIsSameAsPrevious()
{
var previousEnumeratedValue = new EnumeratedValue
{
Representation = RepresentationInstanceList.dtSkyCondition.ToModelRepresentation()
};
var enumMember = DefinedTypeEnumerationInstanceList.dtiSunny.ToModelEnumMember();
previousEnumeratedValue.Value = enumMember;
previousEnumeratedValue.Code = enumMember.Code;
_interpolator.SetMostRecentMeterValue(_enumeratedMeter, previousEnumeratedValue);
var result = _interpolator.Interpolate(_enumeratedMeter);
var enumeratedRepresentation = result as EnumeratedValue;
Assert.AreEqual(previousEnumeratedValue.Representation, enumeratedRepresentation.Representation);
Assert.AreEqual(previousEnumeratedValue.Code, enumeratedRepresentation.Code);
}
private int ConvertToIsoValue(EnumeratedValue value)
{
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiUnloadingAugerStateDisabled.ToModelEnumMember().Code)
{
return(0);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiUnloadingAugerStateEnabled.ToModelEnumMember().Code)
{
return(1);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiUnloadingAugerStateError.ToModelEnumMember().Code)
{
return(2);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiUnloadingAugerStateNotAvailable.ToModelEnumMember().Code)
{
return(3);
}
return(3);
}
public UInt32 GetMetersValue(List <WorkingData> meters, SpatialRecord spatialRecord)
{
// Martin Sperlich: I've got a GS3_2630 data set here for which meters.FirstOrDefault()
// does return an AgGateway.ADAPT.ApplicationDataModel.LoggedData.EnumeratedWorkingData object.
// The direct cast to AgGateway.ADAPT.ApplicationDataModel.LoggedData.EnumeratedWorkingData
// does throw an invalid typecast exception.
// var meter = (ISOEnumeratedMeter) meters.FirstOrDefault();
ISOEnumeratedMeter meter = meters.FirstOrDefault() as ISOEnumeratedMeter;
if (meter == null)
{
return(0);
}
// var value = (EnumeratedValue) spatialRecord.GetMeterValue(meter);
EnumeratedValue value = spatialRecord.GetMeterValue(meter) as EnumeratedValue;
if (value == null)
{
return(0);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiClear.ToModelEnumMember().Code)
{
return(0x20524C43);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiSunny.ToModelEnumMember().Code)
{
return(0x2043534E);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiPartlyCloudy.ToModelEnumMember().Code)
{
return(0x20544353);
}
if (value.Value.Code == DefinedTypeEnumerationInstanceList.dtiCloudy.ToModelEnumMember().Code)
{
return(0x2043564F);
}
return(0);
}
private int GetEnumerated(IntPtr list, uint index, ref uint type, ref uint data)
{
ActionListItemCollection items = actionLists[list];
if (index < items.Count)
{
EnumeratedValue enumerated = (EnumeratedValue)items[(int)index].Value;
try
{
type = enumerated.Type;
}
catch (NullReferenceException)
{
}
data = enumerated.Value;
return(PSError.kSPNoError);
}
return(PSError.kSPBadParameterError);
}
/// <summary>
/// Convert enumerated value to design parameter
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
private static Parameter ToParameter(this EnumeratedValue value)
{
if (value == null)
{
return(null);
}
var parameter = new Parameter {
Name = value.Name,
Description = value.Documentation.ToLocalizedText()
};
if (value.ValueSpecified)
{
parameter.Identifier = value.Value;
parameter.IdentifierSpecified = true;
}
if (!string.IsNullOrEmpty(value.BitMask))
{
parameter.BitMask = value.BitMask;
parameter.IdentifierSpecified = false;
}
return(parameter);
}
private unsafe int GetEnumerated(PIActionList list, uint index, uint *type, uint *data)
{
if (data == null)
{
return(PSError.kSPBadParameterError);
}
ActionListItemCollection items = actionLists[list];
if (index < items.Count)
{
EnumeratedValue enumerated = (EnumeratedValue)items[(int)index].Value;
if (type != null)
{
*type = enumerated.Type;
}
*data = enumerated.Value;
return(PSError.kSPNoError);
}
return(PSError.kSPBadParameterError);
}
private int GetEnumerated(IntPtr descriptor, uint key, ref uint type, ref uint data)
{
#if DEBUG
DebugUtils.Ping(DebugFlags.DescriptorParameters, string.Format("key: 0x{0:X4}({1})", key, DebugUtils.PropToString(key)));
#endif
AETEValue item;
if (actionDescriptors[descriptor].TryGetValue(key, out item))
{
EnumeratedValue enumerated = (EnumeratedValue)item.Value;
try
{
type = enumerated.Type;
}
catch (NullReferenceException)
{
}
data = enumerated.Value;
return(PSError.kSPNoError);
}
return(PSError.errMissingParameter);
}
public SCCEnumeratedValue(EnumeratedValue o, ITree antlr)
: base(o, antlr)
{
}
public DeviceElement ImportDeviceElement(ISODeviceElement isoDeviceElement, EnumeratedValue deviceClassification, DeviceElementHierarchy rootDeviceHierarchy)
{
DeviceElement deviceElement = new DeviceElement();
//ID
ImportIDs(deviceElement.Id, isoDeviceElement.DeviceElementId);
//Device ID
int?deviceModelId = TaskDataMapper.InstanceIDMap.GetADAPTID(isoDeviceElement.Device.DeviceId);
if (deviceModelId.HasValue)
{
deviceElement.DeviceModelId = deviceModelId.Value;
}
//Description
deviceElement.Description = isoDeviceElement.DeviceElementDesignator;
//Classification
deviceElement.DeviceClassification = deviceClassification;
//Parent ID
if (isoDeviceElement.Parent != null)
{
int?parentDeviceId = null;
if (isoDeviceElement.ParentObjectId == isoDeviceElement.DeviceElementObjectId)
{
//Element has listed itself as its own parent. Do not include a parent on the adapt element as it will invalidate logic in the hierarchy creation.
}
else if (isoDeviceElement.Parent is ISODeviceElement parentElement)
{
parentDeviceId = TaskDataMapper.InstanceIDMap.GetADAPTID(parentElement.DeviceElementId);
}
else if (isoDeviceElement.Parent is ISODevice parentDevice)
{
parentDeviceId = TaskDataMapper.InstanceIDMap.GetADAPTID(parentDevice.DeviceId);
}
if (parentDeviceId.HasValue)
{
deviceElement.ParentDeviceId = parentDeviceId.Value;
}
}
DeviceElementHierarchy deviceElementHierarchy = TaskDataMapper.DeviceElementHierarchies.GetRelevantHierarchy(isoDeviceElement.DeviceElementId);
//Device Element Type
switch (isoDeviceElement.DeviceElementType)
{
case ISODeviceElementType.Device: //This is the root device element
if (deviceClassification != null &&
deviceClassification.Value != null &&
TaskDataMapper.DeviceOperationTypes.First(d => d.MachineEnumerationMember.DomainTag == deviceClassification.Value.Code).HasMachineConfiguration)
{
//Device is a machine
deviceElement.DeviceElementType = DeviceElementTypeEnum.Machine;
}
else if (deviceElementHierarchy.Children != null &&
deviceElementHierarchy.Children.Any(d => d?.DeviceElement.DeviceElementType == ISODeviceElementType.Navigation) && //The Nav element should be a direct descendant of the root
(!deviceElementHierarchy.Children.Any(d => d?.DeviceElement.DeviceElementType == ISODeviceElementType.Section) && //If there are section or function elements, classify as an implement vs. a machine
!deviceElementHierarchy.Children.Any(d => d?.DeviceElement.DeviceElementType == ISODeviceElementType.Function)))
{
//Device is a machine
deviceElement.DeviceElementType = DeviceElementTypeEnum.Machine;
}
else
{
//Default: classify as an implement
deviceElement.DeviceElementType = DeviceElementTypeEnum.Implement;
}
break;
case ISODeviceElementType.Bin:
deviceElement.DeviceElementType = DeviceElementTypeEnum.Bin;
break;
case ISODeviceElementType.Function:
deviceElement.DeviceElementType = DeviceElementTypeEnum.Function;
break;
case ISODeviceElementType.Section:
deviceElement.DeviceElementType = DeviceElementTypeEnum.Section;
break;
case ISODeviceElementType.Unit:
deviceElement.DeviceElementType = DeviceElementTypeEnum.Unit;
break;
case ISODeviceElementType.Navigation:
deviceElement.DeviceElementType = DeviceElementTypeEnum.Function;
break;
}
if (HasGeometryInformation(deviceElementHierarchy))
{
//Geometry information is on DeviceProperty elements.
GetDeviceElementConfiguration(deviceElement, deviceElementHierarchy, DataModel.Catalog); //Add via the Get method to invoke business rules for configs
}
return(deviceElement);
}
public override EnumeratedValue CreateEnumeratedValue(EnumeratedValue o, Antlr.Runtime.Tree.ITree antlr)
{
return new SCCEnumeratedValue(o, antlr);
}