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");
}
}
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)
{
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");
}
}
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());
}
private void LoadPrefixTable(GXXmlReader reader)
{
List <object> list = new List <object>();
if (reader.IsStartElement("PrefixTable", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add(reader.ReadElementContentAsObject("Value", null, null, 0));
}
reader.ReadEndElement("PrefixTable");
}
PrefixTable = list.ToArray();
}
private Int16[] LoadSwitchTable(GXXmlReader reader)
{
List <Int16> list = new List <Int16>();
if (reader.IsStartElement("SwitchTable", true))
{
while (reader.IsStartElement("Item", false))
{
list.Add((Int16)reader.ReadElementContentAsInt("Item"));
}
reader.ReadEndElement("SwitchTable");
}
return(list.ToArray());
}
private void LoadGroupTable(GXXmlReader reader)
{
List <UInt16> list = new List <UInt16>();
if (reader.IsStartElement("GroupTable", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add((UInt16)reader.ReadElementContentAsInt("Value"));
}
reader.ReadEndElement("GroupTable");
}
GroupTable = list.ToArray();
}
private void LoadBlacklistTable(GXXmlReader reader)
{
BlacklistTable.Clear();
if (reader.IsStartElement("BlacklistTable", true))
{
while (reader.IsStartElement("Item", false))
{
UInt16 k = (UInt16)reader.ReadElementContentAsInt("Key");
UInt16 v = (UInt16)reader.ReadElementContentAsInt("Value");
BlacklistTable.Add(new GXKeyValuePair <UInt16, UInt16>(k, v));
}
reader.ReadEndElement("BlacklistTable");
}
}
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("ObjectList");
GXDLMSCaptureObject co = new GXDLMSCaptureObject(ai, di);
GXDLMSObject obj = reader.Objects.FindByLN(ot, 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"));
GXDateTime end = new GXDateTime(reader.ReadElementContentAsString("End"));
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)
{
DataLinkLayerReference = reader.ReadElementContentAsString("DataLinkLayerReference");
IPAddress = reader.ReadElementContentAsString("IPAddress");
List <UInt32> list = new List <UInt32>();
if (reader.IsStartElement("MulticastIPAddress", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add((UInt32)reader.ReadElementContentAsInt("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.ReadElementContentAsULong("SubnetMask");
GatewayIPAddress = reader.ReadElementContentAsULong("GatewayIPAddress");
UseDHCP = reader.ReadElementContentAsInt("UseDHCP") != 0;
PrimaryDNSAddress = reader.ReadElementContentAsULong("PrimaryDNSAddress");
SecondaryDNSAddress = reader.ReadElementContentAsULong("SecondaryDNSAddress");
}
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)
{
CommunicationSpeed = (BaudRate)reader.ReadElementContentAsInt("CommunicationSpeed");
if (reader.IsStartElement("InitialisationStrings", true))
{
while (reader.IsStartElement("Initialisation", true))
{
GXDLMSModemInitialisation it = new GXDLMSModemInitialisation();
it.Request = reader.ReadElementContentAsString("Request");
it.Response = reader.ReadElementContentAsString("Response");
it.Delay = (UInt16)reader.ReadElementContentAsInt("Delay");
}
reader.ReadEndElement("InitialisationStrings");
}
ModemProfile = reader.ReadElementContentAsString("ModemProfile", "").Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
private void LoadBroadcastLogTable(GXXmlReader reader)
{
BroadcastLogTable.Clear();
if (reader.IsStartElement("BroadcastLogTable", true))
{
while (reader.IsStartElement("Item", false))
{
GXDLMSBroadcastLogTable it = new GXDLMSBroadcastLogTable();
BroadcastLogTable.Add(it);
it.SourceAddress = (UInt16)reader.ReadElementContentAsInt("SourceAddress");
it.SequenceNumber = (byte)reader.ReadElementContentAsInt("SequenceNumber");
it.ValidTime = (UInt16)reader.ReadElementContentAsInt("ValidTime");
}
reader.ReadEndElement("BroadcastLogTable");
}
}
private static void LoadCreditChargeConfigurations(GXXmlReader reader, List <GXCreditChargeConfiguration> list)
{
list.Clear();
if (reader.IsStartElement("CreditChargeConfigurations", true))
{
while (reader.IsStartElement("Item", true))
{
GXCreditChargeConfiguration it = new GXCreditChargeConfiguration();
it.CreditReference = reader.ReadElementContentAsString("Credit");
it.ChargeReference = reader.ReadElementContentAsString("Charge");
it.CollectionConfiguration = (CreditCollectionConfiguration)reader.ReadElementContentAsInt("Configuration");
list.Add(it);
}
reader.ReadEndElement("CreditChargeConfigurations");
}
}
private GXMacMulticastEntry[] LoadMulticastEntries(GXXmlReader reader)
{
List <GXMacMulticastEntry> list = new List <GXMacMulticastEntry>();
if (reader.IsStartElement("MulticastEntries", true))
{
while (reader.IsStartElement("Item", true))
{
GXMacMulticastEntry it = new GXMacMulticastEntry();
list.Add(it);
it.Id = (sbyte)reader.ReadElementContentAsInt("Id");
it.Members = (Int16)reader.ReadElementContentAsInt("Members");
}
reader.ReadEndElement("MulticastEntries");
}
return(list.ToArray());
}
private void LoadContextInformationTable(GXXmlReader reader)
{
ContextInformationTable.Clear();
if (reader.IsStartElement("ContextInformationTable", true))
{
while (reader.IsStartElement("Item", false))
{
GXDLMSContextInformationTable it = new GXDLMSContextInformationTable();
ContextInformationTable.Add(it);
it.CID = reader.ReadElementContentAsString("CID");
it.Context = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Context"));
it.Compression = reader.ReadElementContentAsInt("Compression") != 0;
it.ValidLifetime = (UInt16)reader.ReadElementContentAsInt("ValidLifetime");
}
reader.ReadEndElement("ContextInformationTable");
}
}
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();
}
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"), CultureInfo.InvariantCulture);
GXDateTime end = new GXDateTime(reader.ReadElementContentAsString("End"), CultureInfo.InvariantCulture);
CallingWindow.Add(new KeyValuePair <DLMS.GXDateTime, DLMS.GXDateTime>(start, end));
}
reader.ReadEndElement("CallingWindow");
}
Destinations = reader.ReadElementContentAsString("Destinations", "").Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
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());
}
private GXNeighborDiscoverySetup[] LoadNeighborDiscoverySetup(GXXmlReader reader, string name)
{
List <GXNeighborDiscoverySetup> list = new List <GXNeighborDiscoverySetup>();
if (reader.IsStartElement(name, true))
{
while (reader.IsStartElement("Item", true))
{
GXNeighborDiscoverySetup it = new GXNeighborDiscoverySetup();
list.Add(it);
it.MaxRetry = (byte)reader.ReadElementContentAsInt("MaxRetry");
it.RetryWaitTime = (UInt16)reader.ReadElementContentAsInt("RetryWaitTime");
it.SendPeriod = (UInt32)reader.ReadElementContentAsInt("SendPeriod");
}
reader.ReadEndElement(name);
}
return(list.ToArray());
}
private void LoadRoutingTable(GXXmlReader reader)
{
RoutingTable.Clear();
if (reader.IsStartElement("RoutingTable", true))
{
while (reader.IsStartElement("Item", false))
{
GXDLMSRoutingTable it = new GXDLMSRoutingTable();
RoutingTable.Add(it);
it.DestinationAddress = (UInt16)reader.ReadElementContentAsInt("DestinationAddress");
it.NextHopAddress = (UInt16)reader.ReadElementContentAsInt("NextHopAddress");
it.RouteCost = (UInt16)reader.ReadElementContentAsInt("RouteCost");
it.HopCount = (byte)reader.ReadElementContentAsInt("HopCount");
it.WeakLinkCount = (byte)reader.ReadElementContentAsInt("WeakLinkCount");
it.ValidTime = (UInt16)reader.ReadElementContentAsInt("ValidTime");
}
reader.ReadEndElement("RoutingTable");
}
}
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)
{
SecurityPolicy = (SecurityPolicy)reader.ReadElementContentAsInt("SecurityPolicy");
//This is old functionality.It can be removed in some point.
reader.ReadElementContentAsInt("SecurityPolicy0");
SecuritySuite = (SecuritySuite)reader.ReadElementContentAsInt("SecuritySuite");
string str = reader.ReadElementContentAsString("ClientSystemTitle");
if (str == null)
{
ClientSystemTitle = null;
}
else
{
ClientSystemTitle = GXDLMSTranslator.HexToBytes(str);
}
str = reader.ReadElementContentAsString("ServerSystemTitle");
if (str == null)
{
ServerSystemTitle = null;
}
else
{
ServerSystemTitle = GXDLMSTranslator.HexToBytes(str);
}
Certificates.Clear();
if (reader.IsStartElement("Certificates", true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSCertificateInfo it = new GXDLMSCertificateInfo();
Certificates.Add(it);
it.Entity = (CertificateEntity)reader.ReadElementContentAsInt("Entity");
it.Type = (CertificateType)reader.ReadElementContentAsInt("Type");
it.SerialNumber = BigInteger.Parse(reader.ReadElementContentAsString("SerialNumber"));
it.Issuer = reader.ReadElementContentAsString("Issuer");
it.Subject = reader.ReadElementContentAsString("Subject");
it.SubjectAltName = reader.ReadElementContentAsString("SubjectAltName");
}
reader.ReadEndElement("Certificates");
}
}
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());
}
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");
}
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());
}
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)
{
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 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());
}
