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");
}
}
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 LoadBlacklistTable(GXXmlReader reader)
{
BlacklistTable.Clear();
if (reader.IsStartElement("BlacklistTable", true))
{
while (reader.IsStartElement("Item", false))
{
ushort k = (ushort)reader.ReadElementContentAsInt("Key");
ushort v = (ushort)reader.ReadElementContentAsInt("Value");
BlacklistTable.Add(new GXKeyValuePair <ushort, ushort>(k, v));
}
reader.ReadEndElement("BlacklistTable");
}
}
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");
}
}
private void LoadGroupTable(GXXmlReader reader)
{
List <ushort> list = new List <ushort>();
if (reader.IsStartElement("GroupTable", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add((ushort)reader.ReadElementContentAsInt("Value"));
}
reader.ReadEndElement("GroupTable");
}
GroupTable = 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 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));
}
reader.ReadEndElement("PrefixTable");
}
PrefixTable = 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)
{
ClientSAP = (byte)reader.ReadElementContentAsInt("ClientSAP");
ServerSAP = (byte)reader.ReadElementContentAsInt("ServerSAP");
if (reader.IsStartElement("ApplicationContextName", true))
{
ApplicationContextName.JointIsoCtt = (byte)reader.ReadElementContentAsInt("JointIsoCtt");
ApplicationContextName.Country = (byte)reader.ReadElementContentAsInt("Country");
ApplicationContextName.CountryName = (UInt16)reader.ReadElementContentAsInt("CountryName");
ApplicationContextName.IdentifiedOrganization = (byte)reader.ReadElementContentAsInt("IdentifiedOrganization");
ApplicationContextName.DlmsUA = (byte)reader.ReadElementContentAsInt("DlmsUA");
ApplicationContextName.ApplicationContext = (byte)reader.ReadElementContentAsInt("ApplicationContext");
ApplicationContextName.ContextId = (byte)reader.ReadElementContentAsInt("ContextId");
reader.ReadEndElement("ApplicationContextName");
}
if (reader.IsStartElement("XDLMSContextInfo", true))
{
XDLMSContextInfo.Conformance = (Conformance)reader.ReadElementContentAsInt("Conformance");
XDLMSContextInfo.MaxReceivePduSize = (UInt16)reader.ReadElementContentAsInt("MaxReceivePduSize");
XDLMSContextInfo.MaxSendPduSize = (UInt16)reader.ReadElementContentAsInt("MaxSendPduSize");
XDLMSContextInfo.DlmsVersionNumber = (byte)reader.ReadElementContentAsInt("DlmsVersionNumber");
XDLMSContextInfo.QualityOfService = (sbyte)reader.ReadElementContentAsInt("QualityOfService");
XDLMSContextInfo.CypheringInfo = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("CypheringInfo"));
reader.ReadEndElement("XDLMSContextInfo");
}
if (reader.IsStartElement("XDLMSContextInfo", true))
{
AuthenticationMechanismName.JointIsoCtt = (byte)reader.ReadElementContentAsInt("JointIsoCtt");
AuthenticationMechanismName.Country = (byte)reader.ReadElementContentAsInt("Country");
AuthenticationMechanismName.CountryName = (UInt16)reader.ReadElementContentAsInt("CountryName");
AuthenticationMechanismName.IdentifiedOrganization = (byte)reader.ReadElementContentAsInt("IdentifiedOrganization");
AuthenticationMechanismName.DlmsUA = (byte)reader.ReadElementContentAsInt("DlmsUA");
AuthenticationMechanismName.AuthenticationMechanismName = (byte)reader.ReadElementContentAsInt("AuthenticationMechanismName");
AuthenticationMechanismName.MechanismId = (Authentication)reader.ReadElementContentAsInt("MechanismId");
reader.ReadEndElement("XDLMSContextInfo");
}
string str = reader.ReadElementContentAsString("Secret");
if (str == null)
{
Secret = null;
}
else
{
Secret = GXDLMSTranslator.HexToBytes(str);
}
AssociationStatus = (AssociationStatus)reader.ReadElementContentAsInt("AssociationStatus");
SecuritySetupReference = reader.ReadElementContentAsString("SecuritySetupReference");
}
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";
}
}
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");
}
}
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 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");
}
}
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);
}
/// <summary>
/// Load COSEM objects from the file.
/// </summary>
/// <param name="stream">Stream.</param>
/// <returns>Collection of serialized COSEM objects.</returns>
public static GXDLMSObjectCollection Load(Stream stream)
{
GXDLMSObject obj = null;
String target;
ObjectType type;
using (GXXmlReader reader = new GXXmlReader(stream))
{
while (!reader.EOF)
{
if (reader.IsStartElement())
{
target = reader.Name;
if (string.Compare("Objects", target, true) == 0)
{
//Skip.
reader.Read();
}
else if (string.Compare("Object", target, true) == 0)
{
int r = 0;
string str = reader.GetAttribute(0);
if (int.TryParse(str, out r))
{
type = (ObjectType)r;
}
else
{
type = (ObjectType)Enum.Parse(typeof(ObjectType), str);
}
reader.Read();
obj = GXDLMSClient.CreateObject(type);
reader.Objects.Add(obj);
}
else if (string.Compare("SN", target, true) == 0)
{
obj.ShortName = (UInt16)reader.ReadElementContentAsInt("SN");
}
else if (string.Compare("LN", target, true) == 0)
{
obj.LogicalName = reader.ReadElementContentAsString("LN");
}
else if (string.Compare("Description", target, true) == 0)
{
obj.Description = reader.ReadElementContentAsString("Description");
}
else
{
(obj as IGXDLMSBase).Load(reader);
obj = null;
}
}
else
{
reader.Read();
}
}
return(reader.Objects);
}
}
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)
{
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)
{
ChangedParameter = new GXDLMSTarget();
if (reader.IsStartElement("ChangedParameter", true))
{
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("Type");
string ln = reader.ReadElementContentAsString("LN");
ChangedParameter.Target = reader.Objects.FindByLN(ot, ln);
if (ChangedParameter.Target == null)
{
ChangedParameter.Target = GXDLMSClient.CreateObject(ot);
ChangedParameter.Target.LogicalName = ln;
}
ChangedParameter.AttributeIndex = (byte)reader.ReadElementContentAsInt("Index");
ChangedParameter.Value = reader.ReadElementContentAsObject("Value", null);
reader.ReadEndElement("ChangedParameter");
}
if (string.Compare("Time", reader.Name, true) == 0)
{
CaptureTime = new GXDateTime(reader.ReadElementContentAsString("Time"), CultureInfo.InvariantCulture);
}
else
{
CaptureTime = DateTime.MinValue;
}
Parameters.Clear();
if (reader.IsStartElement("Parameters", true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSTarget obj = new GXDLMSTarget();
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("Type");
string ln = reader.ReadElementContentAsString("LN");
obj.Target = reader.Objects.FindByLN(ot, ln);
if (obj.Target == null)
{
obj.Target = GXDLMSClient.CreateObject(ot);
obj.Target.LogicalName = ln;
}
obj.AttributeIndex = (byte)reader.ReadElementContentAsInt("Index");
Parameters.Add(obj);
}
reader.ReadEndElement("Parameters");
}
}
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());
}
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");
}
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)
{
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");
}
}
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");
}
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)
{
List <object> thresholds = new List <object>();
if (reader.IsStartElement("Thresholds", true))
{
while (reader.IsStartElement("Value", false))
{
object it = reader.ReadElementContentAsObject("Value", null);
thresholds.Add(it);
}
reader.ReadEndElement("Thresholds");
}
Thresholds = thresholds.ToArray();
if (reader.IsStartElement("MonitoredValue", true))
{
MonitoredValue.ObjectType = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
MonitoredValue.LogicalName = reader.ReadElementContentAsString("LN");
MonitoredValue.AttributeIndex = reader.ReadElementContentAsInt("Index");
reader.ReadEndElement("MonitoredValue");
}
List <GXDLMSActionSet> list = new List <GXDLMSActionSet>();
if (reader.IsStartElement("Actions", true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSActionSet it = new GXDLMSActionSet();
list.Add(it);
if (reader.IsStartElement("Up", true))
{
it.ActionUp.LogicalName = reader.ReadElementContentAsString("LN", null);
if (it.ActionUp.LogicalName == "")
{
it.ActionUp.LogicalName = "0.0.0.0.0.0";
}
it.ActionUp.ScriptSelector = (UInt16)reader.ReadElementContentAsInt("Selector");
reader.ReadEndElement("Up");
}
if (reader.IsStartElement("Down", true))
{
it.ActionDown.LogicalName = reader.ReadElementContentAsString("LN", null);
if (it.ActionDown.LogicalName == "")
{
it.ActionDown.LogicalName = "0.0.0.0.0.0";
}
it.ActionDown.ScriptSelector = (UInt16)reader.ReadElementContentAsInt("Selector");
reader.ReadEndElement("Down");
}
}
reader.ReadEndElement("Actions");
}
Actions = 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");
}
