private static GXDLMSSeasonProfile[] LoadSeasonProfile(GXXmlReader reader, string name)
{
List <GXDLMSSeasonProfile> list = new List <GXDLMSSeasonProfile>();
if (reader.IsStartElement(name, true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSSeasonProfile it = new GXDLMSSeasonProfile();
it.Name = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Name"));
it.Start = new GXDateTime(reader.ReadElementContentAsString("Start"), CultureInfo.InvariantCulture);
it.WeekName = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("WeekName"));
list.Add(it);
}
reader.ReadEndElement(name);
}
return(list.ToArray());
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Mode = (AutoConnectMode)reader.ReadElementContentAsInt("Mode");
Repetitions = reader.ReadElementContentAsInt("Repetitions");
RepetitionDelay = reader.ReadElementContentAsInt("RepetitionDelay");
CallingWindow.Clear();
if (reader.IsStartElement("CallingWindow", true))
{
while (reader.IsStartElement("Item", true))
{
GXDateTime start = new GXDateTime(reader.ReadElementContentAsString("Start"));
GXDateTime end = new GXDateTime(reader.ReadElementContentAsString("End"));
CallingWindow.Add(new KeyValuePair <DLMS.GXDateTime, DLMS.GXDateTime>(start, end));
}
reader.ReadEndElement("CallingWindow");
}
Destinations = reader.ReadElementContentAsString("Destinations", "").Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Mode = (AutoAnswerMode)reader.ReadElementContentAsInt("Mode");
ListeningWindow.Clear();
if (reader.IsStartElement("ListeningWindow", true))
{
while (reader.IsStartElement("Item", true))
{
GXDateTime start = new GXDateTime(reader.ReadElementContentAsString("Start"));
GXDateTime end = new GXDateTime(reader.ReadElementContentAsString("End"));
ListeningWindow.Add(new KeyValuePair <DLMS.GXDateTime, DLMS.GXDateTime>(start, end));
}
reader.ReadEndElement("ListeningWindow");
}
Status = (AutoAnswerStatus)reader.ReadElementContentAsInt("Status");
NumberOfCalls = reader.ReadElementContentAsInt("NumberOfCalls");
NumberOfRingsInListeningWindow = reader.ReadElementContentAsInt("NumberOfRingsInListeningWindow");
NumberOfRingsOutListeningWindow = reader.ReadElementContentAsInt("NumberOfRingsOutListeningWindow");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
PushObjectList.Clear();
if (reader.IsStartElement("ObjectList", true))
{
while (reader.IsStartElement("Item", true))
{
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
string ln = reader.ReadElementContentAsString("LN");
int ai = reader.ReadElementContentAsInt("AI");
int di = reader.ReadElementContentAsInt("DI");
reader.ReadEndElement("Item");
GXDLMSCaptureObject co = new GXDLMSCaptureObject(ai, di);
GXDLMSObject obj = reader.Objects.FindByLN(ot, ln);
if (obj == null)
{
obj = GXDLMSClient.CreateObject(ot);
obj.LogicalName = ln;
}
PushObjectList.Add(new KeyValuePair <Objects.GXDLMSObject, Objects.GXDLMSCaptureObject>(obj, co));
}
reader.ReadEndElement("ObjectList");
}
Service = (ServiceType)reader.ReadElementContentAsInt("Service");
Destination = reader.ReadElementContentAsString("Destination");
Message = (MessageType)reader.ReadElementContentAsInt("Message");
CommunicationWindow.Clear();
if (reader.IsStartElement("CommunicationWindow", true))
{
while (reader.IsStartElement("Item", true))
{
GXDateTime start = new GXDateTime(reader.ReadElementContentAsString("Start"), CultureInfo.InvariantCulture);
GXDateTime end = new GXDateTime(reader.ReadElementContentAsString("End"), CultureInfo.InvariantCulture);
CommunicationWindow.Add(new KeyValuePair <DLMS.GXDateTime, DLMS.GXDateTime>(start, end));
}
reader.ReadEndElement("CommunicationWindow");
}
RandomisationStartInterval = (ushort)reader.ReadElementContentAsInt("RandomisationStartInterval");
NumberOfRetries = (byte)reader.ReadElementContentAsInt("NumberOfRetries");
RepetitionDelay = (ushort)reader.ReadElementContentAsInt("RepetitionDelay");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
ReportingSystemList.Clear();
if (reader.IsStartElement("ReportingSystems", true))
{
while (reader.IsStartElement("Item", false))
{
ReportingSystemList.Add(GXCommon.HexToBytes(reader.ReadElementContentAsString("Item")));
}
}
}
private static void LoadReferences(GXXmlReader reader, string name, List <string> list)
{
list.Clear();
if (reader.IsStartElement(name, true))
{
while (reader.IsStartElement("Item", true))
{
list.Add(reader.ReadElementContentAsString("Name"));
}
reader.ReadEndElement(name);
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
DataLinkLayerReference = reader.ReadElementContentAsString("DataLinkLayerReference");
IPAddress = GetIpaddress(reader.ReadElementContentAsString("IPAddress"));
List <IPAddress> list = new List <IPAddress>();
if (reader.IsStartElement("MulticastIPAddress", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add(GetIpaddress(reader.ReadElementContentAsString("Value")));
}
reader.ReadEndElement("MulticastIPAddress");
}
MulticastIPAddress = list.ToArray();
List <GXDLMSIp4SetupIpOption> ipOptions = new List <GXDLMSIp4SetupIpOption>();
if (reader.IsStartElement("IPOptions", true))
{
while (reader.IsStartElement("IPOption", true))
{
GXDLMSIp4SetupIpOption it = new GXDLMSIp4SetupIpOption();
it.Type = (Ip4SetupIpOptionType)reader.ReadElementContentAsInt("Type");
it.Length = (byte)reader.ReadElementContentAsInt("Length");
it.Data = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Data"));
ipOptions.Add(it);
}
//OLD. This can remove in the future.
while (reader.IsStartElement("IPOptions", true))
{
GXDLMSIp4SetupIpOption it = new GXDLMSIp4SetupIpOption();
it.Type = (Ip4SetupIpOptionType)reader.ReadElementContentAsInt("Type");
it.Length = (byte)reader.ReadElementContentAsInt("Length");
it.Data = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Data"));
ipOptions.Add(it);
}
reader.ReadEndElement("IPOptions");
}
IPOptions = ipOptions.ToArray();
SubnetMask = GetIpaddress(reader.ReadElementContentAsString("SubnetMask"));
GatewayIPAddress = GetIpaddress(reader.ReadElementContentAsString("GatewayIPAddress"));
UseDHCP = reader.ReadElementContentAsInt("UseDHCP") != 0;
PrimaryDNSAddress = GetIpaddress(reader.ReadElementContentAsString("PrimaryDNSAddress"));
SecondaryDNSAddress = GetIpaddress(reader.ReadElementContentAsString("SecondaryDNSAddress"));
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Token = GXCommon.HexToBytes(reader.ReadElementContentAsString("Token"));
string tmp = reader.ReadElementContentAsString("Time");
if (tmp != null)
{
Time = new GXDateTime(tmp, System.Globalization.CultureInfo.InvariantCulture);
}
Descriptions.Clear();
if (reader.IsStartElement("Descriptions", true))
{
while (reader.IsStartElement("Item", true))
{
Descriptions.Add(reader.ReadElementContentAsString("Name"));
}
reader.ReadEndElement("Descriptions");
}
DeliveryMethod = (TokenDelivery)reader.ReadElementContentAsInt("DeliveryMethod");
StatusCode = (TokenStatusCode)reader.ReadElementContentAsInt("Status");
DataValue = reader.ReadElementContentAsString("Data");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Scripts.Clear();
if (reader.IsStartElement("Scripts", true))
{
while (reader.IsStartElement("Script", true))
{
GXDLMSScript it = new GXDLMSScript();
Scripts.Add(it);
it.Id = reader.ReadElementContentAsInt("ID");
if (reader.IsStartElement("Actions", true))
{
while (reader.IsStartElement("Action", true))
{
GXDLMSScriptAction a = new Objects.GXDLMSScriptAction();
a.Type = (ScriptActionType)reader.ReadElementContentAsInt("Type");
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
string ln = reader.ReadElementContentAsString("LN");
a.Index = reader.ReadElementContentAsInt("Index");
a.Target = reader.Objects.FindByLN(ot, ln);
if (a.Target == null)
{
a.Target = GXDLMSClient.CreateObject(ot);
a.Target.LogicalName = ln;
}
a.ParameterDataType = (DataType)reader.ReadElementContentAsInt("ParameterDataType");
a.Parameter = reader.ReadElementContentAsString("Parameter", null);
if (a.ParameterDataType != DataType.None)
{
a.Parameter = GXDLMSConverter.ChangeType(a.Parameter, a.ParameterDataType, CultureInfo.InvariantCulture);
}
it.Actions.Add(a);
}
reader.ReadEndElement("Actions");
}
}
reader.ReadEndElement("Scripts");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
DataLinkLayerReference = reader.ReadElementContentAsString("DataLinkLayerReference");
IPAddress = reader.ReadElementContentAsString("IPAddress");
List <string> list = new List <string>();
if (reader.IsStartElement("MulticastIPAddress", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add(reader.ReadElementContentAsString("Value"));
}
reader.ReadEndElement("MulticastIPAddress");
}
MulticastIPAddress = list.ToArray();
List <GXDLMSIp4SetupIpOption> ipOptions = new List <GXDLMSIp4SetupIpOption>();
if (reader.IsStartElement("IPOptions", true))
{
while (reader.IsStartElement("IPOptions", true))
{
GXDLMSIp4SetupIpOption it = new GXDLMSIp4SetupIpOption();
it.Type = (Ip4SetupIpOptionType)reader.ReadElementContentAsInt("Type");
it.Length = (byte)reader.ReadElementContentAsInt("Length");
it.Data = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Data"));
ipOptions.Add(it);
}
reader.ReadEndElement("IPOptions");
}
IPOptions = ipOptions.ToArray();
SubnetMask = reader.ReadElementContentAsString("SubnetMask");
GatewayIPAddress = reader.ReadElementContentAsString("GatewayIPAddress");
if (string.IsNullOrEmpty(GatewayIPAddress))
{
GatewayIPAddress = "0.0.0.0";
}
UseDHCP = reader.ReadElementContentAsInt("UseDHCP") != 0;
PrimaryDNSAddress = reader.ReadElementContentAsString("PrimaryDNSAddress");
if (string.IsNullOrEmpty(PrimaryDNSAddress))
{
PrimaryDNSAddress = "0.0.0.0";
}
SecondaryDNSAddress = reader.ReadElementContentAsString("SecondaryDNSAddress");
if (string.IsNullOrEmpty(SecondaryDNSAddress))
{
SecondaryDNSAddress = "0.0.0.0";
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
MBusPortReference = reader.ReadElementContentAsString("MBusPortReference");
CaptureDefinition.Clear();
if (reader.IsStartElement("CaptureDefinition", true))
{
while (reader.IsStartElement("Item", true))
{
string d = reader.ReadElementContentAsString("Data");
string v = reader.ReadElementContentAsString("Value");
CaptureDefinition.Add(new KeyValuePair <string, string>(d, v));
}
reader.ReadEndElement("CaptureDefinition");
}
CapturePeriod = (UInt16)reader.ReadElementContentAsInt("CapturePeriod");
PrimaryAddress = reader.ReadElementContentAsInt("PrimaryAddress");
IdentificationNumber = (UInt16)reader.ReadElementContentAsInt("IdentificationNumber");
ManufacturerID = (UInt16)reader.ReadElementContentAsInt("ManufacturerID");
DataHeaderVersion = reader.ReadElementContentAsInt("DataHeaderVersion");
DeviceType = reader.ReadElementContentAsInt("DeviceType");
AccessNumber = reader.ReadElementContentAsInt("AccessNumber");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
if (string.Compare("Time", reader.Name, true) == 0)
{
Time = new GXDateTime(reader.ReadElementContentAsString("Time"), CultureInfo.InvariantCulture);
}
TimeZone = reader.ReadElementContentAsInt("TimeZone");
Status = (ClockStatus)reader.ReadElementContentAsInt("Status");
string str = reader.ReadElementContentAsString("Begin");
if (str != null)
{
Begin = new GXDateTime(str, CultureInfo.InvariantCulture);
}
str = reader.ReadElementContentAsString("End");
if (str != null)
{
End = new GXDateTime(str, CultureInfo.InvariantCulture);
}
Deviation = reader.ReadElementContentAsInt("Deviation");
Enabled = reader.ReadElementContentAsInt("Enabled") != 0;
ClockBase = (ClockBase)reader.ReadElementContentAsInt("ClockBase");
}
private IPAddress[] LoadIPAddress(GXXmlReader reader, string name)
{
List <IPAddress> list = new List <IPAddress>();
if (reader.IsStartElement(name, true))
{
while (reader.IsStartElement("Value", false))
{
list.Add(IPAddress.Parse(reader.ReadElementContentAsString("Value")));
}
reader.ReadEndElement(name);
}
return(list.ToArray());
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
SapAssignmentList.Clear();
if (reader.IsStartElement("SapAssignmentList", true))
{
while (reader.IsStartElement("Item", true))
{
UInt16 sap = (UInt16)reader.ReadElementContentAsInt("SAP");
string ldn = reader.ReadElementContentAsString("LDN");
SapAssignmentList.Add(new KeyValuePair <UInt16, string>(sap, ldn));
}
reader.ReadEndElement("SapAssignmentList");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Entries.Clear();
if (reader.IsStartElement("Entries", true))
{
while (reader.IsStartElement("Item", true))
{
GXScheduleEntry it = new GXScheduleEntry();
it.Index = (byte)reader.ReadElementContentAsInt("Index");
it.Enable = reader.ReadElementContentAsInt("Enable") != 0;
it.LogicalName = reader.ReadElementContentAsString("LogicalName");
it.ScriptSelector = (byte)reader.ReadElementContentAsInt("ScriptSelector");
it.SwitchTime = (GXDateTime)reader.ReadElementContentAsObject("SwitchTime", new GXDateTime());
it.ValidityWindow = (byte)reader.ReadElementContentAsInt("ValidityWindow");
it.ExecWeekdays = reader.ReadElementContentAsString("ExecWeekdays");
it.ExecSpecDays = reader.ReadElementContentAsString("ExecSpecDays");
it.BeginDate = (GXDateTime)reader.ReadElementContentAsObject("BeginDate", new GXDateTime());
it.EndDate = (GXDateTime)reader.ReadElementContentAsObject("EndDate", new GXDateTime());
Entries.Add(it);
}
reader.ReadEndElement("Entries");
}
}
private void LoadKeyTable(GXXmlReader reader)
{
KeyTable.Clear();
if (reader.IsStartElement("KeyTable", true))
{
while (reader.IsStartElement("Item", true))
{
byte k = (byte)reader.ReadElementContentAsInt("Key");
byte[] d = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Data"));
KeyTable.Add(new GXKeyValuePair <byte, byte[]>(k, d));
}
reader.ReadEndElement("KeyTable");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
string str = reader.ReadElementContentAsString("Secret");
if (str == null)
{
Secret = null;
}
else
{
Secret = GXDLMSTranslator.HexToBytes(str);
}
str = reader.ReadElementContentAsString("HlsSecret");
if (str == null)
{
HlsSecret = null;
}
else
{
HlsSecret = GXDLMSTranslator.HexToBytes(str);
}
SecuritySetupReference = reader.ReadElementContentAsString("SecuritySetupReference");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
PHYReference = reader.ReadElementContentAsString("PHYReference");
List <GXDLMSPppSetupLcpOption> options = new List <GXDLMSPppSetupLcpOption>();
if (reader.IsStartElement("LCPOptions", true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSPppSetupLcpOption it = new GXDLMSPppSetupLcpOption();
it.Type = (PppSetupLcpOptionType)reader.ReadElementContentAsInt("Type");
it.Length = (byte)reader.ReadElementContentAsInt("Length");
it.Data = reader.ReadElementContentAsObject("Data", null);
}
reader.ReadEndElement("LCPOptions");
}
LCPOptions = options.ToArray();
List <GXDLMSPppSetupIPCPOption> list = new List <GXDLMSPppSetupIPCPOption>();
if (reader.IsStartElement("IPCPOptions", true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSPppSetupIPCPOption it = new GXDLMSPppSetupIPCPOption();
it.Type = (PppSetupIPCPOptionType)reader.ReadElementContentAsInt("Type");
it.Length = (byte)reader.ReadElementContentAsInt("Length");
it.Data = reader.ReadElementContentAsObject("Data", null);
}
reader.ReadEndElement("IPCPOptions");
}
IPCPOptions = list.ToArray();
UserName = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("UserName"));
Password = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Password"));
}
private static void LoadTokenGatewayConfigurations(GXXmlReader reader, List <GXTokenGatewayConfiguration> list)
{
list.Clear();
if (reader.IsStartElement("TokenGatewayConfigurations", true))
{
while (reader.IsStartElement("Item", true))
{
GXTokenGatewayConfiguration it = new GXTokenGatewayConfiguration();
it.CreditReference = reader.ReadElementContentAsString("Credit");
it.TokenProportion = (byte)reader.ReadElementContentAsInt("Token");
list.Add(it);
}
reader.ReadEndElement("TokenGatewayConfigurations");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
TotalAmountPaid = reader.ReadElementContentAsInt("TotalAmountPaid");
ChargeType = (ChargeType)reader.ReadElementContentAsInt("ChargeType");
Priority = (byte)reader.ReadElementContentAsInt("Priority");
LoadUnitChargeActive(reader, "UnitChargeActive", UnitChargeActive);
LoadUnitChargeActive(reader, "UnitChargePassive", UnitChargePassive);
string tmp = reader.ReadElementContentAsString("UnitChargeActivationTime");
if (tmp != null)
{
UnitChargeActivationTime = new GXDateTime(tmp, System.Globalization.CultureInfo.InvariantCulture);
}
Period = (UInt16)reader.ReadElementContentAsInt("Period");
ChargeConfiguration = (ChargeConfiguration)reader.ReadElementContentAsInt("ChargeConfiguration");
tmp = reader.ReadElementContentAsString("LastCollectionTime");
if (tmp != null)
{
LastCollectionTime = new GXDateTime(tmp, System.Globalization.CultureInfo.InvariantCulture);
}
LastCollectionAmount = reader.ReadElementContentAsInt("LastCollectionAmount");
TotalAmountRemaining = reader.ReadElementContentAsInt("TotalAmountRemaining");
Proportion = (UInt16)reader.ReadElementContentAsInt("Proportion");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
LnId = (short)reader.ReadElementContentAsInt("LnId");
LsId = (byte)reader.ReadElementContentAsInt("LsId");
SId = (byte)reader.ReadElementContentAsInt("SId");
Sna = GXCommon.HexToBytes(reader.ReadElementContentAsString("SNa"));
State = (MacState)reader.ReadElementContentAsInt("State");
ScpLength = (byte)reader.ReadElementContentAsInt("ScpLength");
NodeHierarchyLevel = (byte)reader.ReadElementContentAsInt("NodeHierarchyLevel");
BeaconSlotCount = (byte)reader.ReadElementContentAsInt("BeaconSlotCount");
BeaconRxSlot = (byte)reader.ReadElementContentAsInt("BeaconRxSlot");
BeaconTxSlot = (byte)reader.ReadElementContentAsInt("BeaconTxSlot");
BeaconRxFrequency = (byte)reader.ReadElementContentAsInt("BeaconRxFrequency");
BeaconTxFrequency = (byte)reader.ReadElementContentAsInt("BeaconTxFrequency");
Capabilities = (MacCapabilities)reader.ReadElementContentAsInt("Capabilities");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
CurrentCreditAmount = reader.ReadElementContentAsInt("CurrentCreditAmount");
Type = (CreditType)reader.ReadElementContentAsInt("Type");
Priority = (byte)reader.ReadElementContentAsInt("Priority");
WarningThreshold = reader.ReadElementContentAsInt("WarningThreshold");
Limit = reader.ReadElementContentAsInt("Limit");
CreditConfiguration = (CreditConfiguration)reader.ReadElementContentAsInt("CreditConfiguration");
Status = (CreditStatus)reader.ReadElementContentAsInt("Status");
PresetCreditAmount = reader.ReadElementContentAsInt("PresetCreditAmount");
CreditAvailableThreshold = reader.ReadElementContentAsInt("CreditAvailableThreshold");
string str = reader.ReadElementContentAsString("Period");
if (str != null)
{
Period = new GXDateTime(str, System.Globalization.CultureInfo.InvariantCulture);
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
List <GXDLMSSpecialDay> list = new List <GXDLMSSpecialDay>();
if (reader.IsStartElement("Entries", true))
{
while (reader.IsStartElement("Entry", true))
{
GXDLMSSpecialDay it = new GXDLMSSpecialDay();
it.Index = (UInt16)reader.ReadElementContentAsInt("Index");
it.Date = new GXDate(reader.ReadElementContentAsString("Date"), CultureInfo.InvariantCulture);
it.DayId = (byte)reader.ReadElementContentAsInt("DayId");
list.Add(it);
}
reader.ReadEndElement("Entries");
}
Entries = list.ToArray();
}
private GXMacAvailableSwitch[] LoadAvailableSwitches(GXXmlReader reader)
{
List <GXMacAvailableSwitch> list = new List <GXMacAvailableSwitch>();
if (reader.IsStartElement("AvailableSwitches", true))
{
while (reader.IsStartElement("Item", true))
{
GXMacAvailableSwitch it = new GXMacAvailableSwitch();
list.Add(it);
it.Sna = GXCommon.HexToBytes(reader.ReadElementContentAsString("Sna"));
it.LsId = (Int16)reader.ReadElementContentAsInt("LsId");
it.Level = (sbyte)reader.ReadElementContentAsInt("Level");
it.RxLevel = (sbyte)reader.ReadElementContentAsInt("RxLevel");
it.RxSnr = (sbyte)reader.ReadElementContentAsInt("RxSnr");
}
reader.ReadEndElement("AvailableSwitches");
}
return(list.ToArray());
}
private GXMacDirectTable[] LoadDirectTable(GXXmlReader reader)
{
List <GXMacDirectTable> list = new List <GXMacDirectTable>();
if (reader.IsStartElement("DirectTable", true))
{
while (reader.IsStartElement("Item", true))
{
GXMacDirectTable it = new GXMacDirectTable();
list.Add(it);
it.SourceSId = (Int16)reader.ReadElementContentAsInt("SourceSId");
it.SourceLnId = (Int16)reader.ReadElementContentAsInt("SourceLnId");
it.SourceLcId = (Int16)reader.ReadElementContentAsInt("SourceLcId");
it.DestinationSId = (Int16)reader.ReadElementContentAsInt("DestinationSId");
it.DestinationLnId = (Int16)reader.ReadElementContentAsInt("DestinationLnId");
it.DestinationLcId = (Int16)reader.ReadElementContentAsInt("DestinationLcId");
it.Did = GXCommon.HexToBytes(reader.ReadElementContentAsString("Did"));
}
reader.ReadEndElement("DirectTable");
}
return(list.ToArray());
}
private static GXDLMSWeekProfile[] LoadWeekProfileTable(GXXmlReader reader, string name)
{
List <GXDLMSWeekProfile> list = new List <GXDLMSWeekProfile>();
if (reader.IsStartElement(name, true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSWeekProfile it = new GXDLMSWeekProfile();
it.Name = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Name"));
it.Monday = reader.ReadElementContentAsInt("Monday");
it.Tuesday = reader.ReadElementContentAsInt("Tuesday");
it.Wednesday = reader.ReadElementContentAsInt("Wednesday");
it.Thursday = reader.ReadElementContentAsInt("Thursday");
it.Friday = reader.ReadElementContentAsInt("Friday");
it.Saturday = reader.ReadElementContentAsInt("Saturday");
it.Sunday = reader.ReadElementContentAsInt("Sunday");
list.Add(it);
}
reader.ReadEndElement(name);
}
return(list.ToArray());
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
APN = reader.ReadElementContentAsString("APN");
PINCode = (UInt16)reader.ReadElementContentAsInt("PINCode");
if (reader.IsStartElement("DefaultQualityOfService", true))
{
DefaultQualityOfService.Precedence = (byte)reader.ReadElementContentAsInt("Precedence");
DefaultQualityOfService.Delay = (byte)reader.ReadElementContentAsInt("Delay");
DefaultQualityOfService.Reliability = (byte)reader.ReadElementContentAsInt("Reliability");
DefaultQualityOfService.PeakThroughput = (byte)reader.ReadElementContentAsInt("PeakThroughput");
DefaultQualityOfService.MeanThroughput = (byte)reader.ReadElementContentAsInt("MeanThroughput");
reader.ReadEndElement("DefaultQualityOfService");
}
if (reader.IsStartElement("RequestedQualityOfService", true))
{
RequestedQualityOfService.Precedence = (byte)reader.ReadElementContentAsInt("Precedence");
RequestedQualityOfService.Delay = (byte)reader.ReadElementContentAsInt("Delay");
RequestedQualityOfService.Reliability = (byte)reader.ReadElementContentAsInt("Reliability");
RequestedQualityOfService.PeakThroughput = (byte)reader.ReadElementContentAsInt("PeakThroughput");
RequestedQualityOfService.MeanThroughput = (byte)reader.ReadElementContentAsInt("MeanThroughput");
reader.ReadEndElement("DefaultQualityOfService");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
ShortAddress = (ushort)reader.ReadElementContentAsInt("ShortAddress");
RcCoord = (ushort)reader.ReadElementContentAsInt("RcCoord");
PANId = (ushort)reader.ReadElementContentAsInt("PANId");
LoadKeyTable(reader);
FrameCounter = (ushort)reader.ReadElementContentAsInt("FrameCounter");
ToneMask = reader.ReadElementContentAsString("ToneMask");
TmrTtl = (byte)reader.ReadElementContentAsInt("TmrTtl");
MaxFrameRetries = (byte)reader.ReadElementContentAsInt("MaxFrameRetries");
NeighbourTableEntryTtl = (byte)reader.ReadElementContentAsInt("NeighbourTableEntryTtl");
LoadNeighbourTable(reader);
HighPriorityWindowSize = (byte)reader.ReadElementContentAsInt("HighPriorityWindowSize");
CscmFairnessLimit = (byte)reader.ReadElementContentAsInt("CscmFairnessLimit");
BeaconRandomizationWindowLength = (byte)reader.ReadElementContentAsInt("BeaconRandomizationWindowLength");
A = (byte)reader.ReadElementContentAsInt("A");
K = (byte)reader.ReadElementContentAsInt("K");
MinCwAttempts = (byte)reader.ReadElementContentAsInt("MinCwAttempts");
CenelecLegacyMode = (byte)reader.ReadElementContentAsInt("CenelecLegacyMode");
FccLegacyMode = (byte)reader.ReadElementContentAsInt("FccLegacyMode");
MaxBe = (byte)reader.ReadElementContentAsInt("MaxBe");
MaxCsmaBackoffs = (byte)reader.ReadElementContentAsInt("MaxCsmaBackoffs");
MinBe = (byte)reader.ReadElementContentAsInt("MinBe");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
PaymentMode = (PaymentMode)reader.ReadElementContentAsInt("PaymentMode");
AccountStatus = (AccountStatus)reader.ReadElementContentAsInt("AccountStatus");
CurrentCreditInUse = (byte)reader.ReadElementContentAsInt("CurrentCreditInUse");
CurrentCreditStatus = (AccountCreditStatus)reader.ReadElementContentAsInt("CurrentCreditStatus");
AvailableCredit = reader.ReadElementContentAsInt("AvailableCredit");
AmountToClear = reader.ReadElementContentAsInt("AmountToClear");
ClearanceThreshold = reader.ReadElementContentAsInt("ClearanceThreshold");
AggregatedDebt = reader.ReadElementContentAsInt("AggregatedDebt");
LoadReferences(reader, "CreditReferences", CreditReferences);
LoadReferences(reader, "ChargeReferences", ChargeReferences);
LoadCreditChargeConfigurations(reader, CreditChargeConfigurations);
LoadTokenGatewayConfigurations(reader, TokenGatewayConfigurations);
AccountActivationTime = reader.ReadElementContentAsDateTime("AccountActivationTime");
AccountClosureTime = reader.ReadElementContentAsDateTime("AccountClosureTime");
Currency.Name = reader.ReadElementContentAsString("CurrencyName");
Currency.Scale = (sbyte)reader.ReadElementContentAsInt("CurrencyScale");
Currency.Unit = (Currency)reader.ReadElementContentAsInt("CurrencyUnit");
LowCreditThreshold = reader.ReadElementContentAsInt("LowCreditThreshold");
NextCreditAvailableThreshold = reader.ReadElementContentAsInt("NextCreditAvailableThreshold");
MaxProvision = (UInt16)reader.ReadElementContentAsInt("MaxProvision");
MaxProvisionPeriod = reader.ReadElementContentAsInt("MaxProvisionPeriod");
}
private GXMacPhyCommunication[] LoadCommunications(GXXmlReader reader)
{
List <GXMacPhyCommunication> list = new List <GXMacPhyCommunication>();
if (reader.IsStartElement("Communications", true))
{
while (reader.IsStartElement("Item", true))
{
GXMacPhyCommunication it = new GXMacPhyCommunication();
list.Add(it);
it.Eui = GXCommon.HexToBytes(reader.ReadElementContentAsString("Eui"));
it.TxPower = (sbyte)reader.ReadElementContentAsInt("TxPower");
it.TxCoding = (sbyte)reader.ReadElementContentAsInt("TxCoding");
it.RxCoding = (sbyte)reader.ReadElementContentAsInt("RxCoding");
it.RxLvl = (sbyte)reader.ReadElementContentAsInt("RxLvl");
it.Snr = (sbyte)reader.ReadElementContentAsInt("Snr");
it.TxPowerModified = (sbyte)reader.ReadElementContentAsInt("TxPowerModified");
it.TxCodingModified = (sbyte)reader.ReadElementContentAsInt("TxCodingModified");
it.RxCodingModified = (sbyte)reader.ReadElementContentAsInt("RxCodingModified");
}
reader.ReadEndElement("Communications");
}
return(list.ToArray());
}
