static private IBytesConverter GetBytesConverter(BytesConverterConfig cfg)
{
BytesConverterManager bcm = BytesConverterManager.Default;
IBytesConverter bc = bcm.CreateBytesConverter(cfg);
return(bc);
}
/// <summary>
///
/// </summary>
/// <param name="dataFieldNode"></param>
/// <returns></returns>
static private BytesConverterConfig CreateBytesConverterConfig(XmlNode bytesConverterNode)
{
BytesConverterConfig r = new BytesConverterConfig();
string name = GetAttribute((XmlElement)bytesConverterNode, DeviceDefineNodeNames.Name, false);
//
//
string str = GetAttribute((XmlElement)bytesConverterNode, DeviceDefineNodeNames.HasInner, true);
bool hasInner = false;
if (str != null && str.Length > 0)
{
hasInner = Convert.ToBoolean(str);
}
r.Name = name;
r.HasInner = hasInner;
r.Propertys = GetPropertys(bytesConverterNode);
if (hasInner)
{
XmlNode innerNode = bytesConverterNode.SelectSingleNode(DeviceDefineNodeNames.BytesConverter);
if (innerNode == null)
{
string s = string.Format("has not inner bytesConverter");
throw new InvalidOperationException(s);
}
r.InnerBytesConverterConfig = CreateBytesConverterConfig(innerNode);
}
return(r);
}
/// <summary>
///
/// </summary>
/// <param name="cfg"></param>
/// <returns></returns>
public IBytesConverter CreateBytesConverter(BytesConverterConfig cfg)
{
if (cfg == null)
{
throw new ArgumentNullException("cfg");
}
IBytesConverter bc = CreateBytesConverter(cfg.Name, null);
foreach (object key in cfg.Propertys.Keys)
{
string value = cfg.Propertys[key].ToString();
SetValue(bc, key.ToString(), value);
}
if (cfg.HasInner)
{
IBytesConverter innerBc = CreateBytesConverter(cfg.InnerBytesConverterConfig);
bc.InnerBytesConverter = innerBc;
}
return(bc);
}
/// <summary>
///
/// </summary>
/// <param name="datafieldnode"></param>
/// <returns></returns>
static internal DataField CreateDataField(XmlNode datafieldnode)
{
string name = string.Empty;
string factor = string.Empty;
object[] convertArgs = null;
int begin = 0;
int length = 0;
IBytesConverter ibc = null;
bool iscrc = false;
bool isMatchCheck = false;
byte[] bytes = null;
bool littleEndian = true;
bool isLazy = false;
string str = string.Empty;
XmlElement el = datafieldnode as XmlElement;
name = GetAttribute(el, DeviceDefineNodeNames.DataFieldName);
str = GetAttribute(el, DeviceDefineNodeNames.Begin);
begin = int.Parse(str);
str = GetAttribute(el, DeviceDefineNodeNames.Length);
length = int.Parse(str);
if (HasBytesConverterChildNode(datafieldnode))
{
XmlNode bytesConverterNode = datafieldnode.SelectSingleNode(
DeviceDefineNodeNames.BytesConverter);
BytesConverterConfig cfg = CreateBytesConverterConfig(bytesConverterNode);
ibc = GetBytesConverter(cfg);
}
else
{
// converter
//
str = GetAttribute(el, DeviceDefineNodeNames.Converter, false);
//if (str == null || str.Length == 0)
//{
// str = "Xdgk.Communi.OriginalConverter";
//}
//
//
factor = GetAttribute(el, DeviceDefineNodeNames.Factor, true);
if (factor != null && factor.Length > 0)
{
try
{
float n = Convert.ToSingle(factor);
convertArgs = new object[] { n };
}
catch (FormatException formatEx)
{
string s = string.Format("Invalid Factor '{0}'", factor);
throw new ConfigException(s, formatEx);
}
}
ibc = GetBytesConvert(str, convertArgs);
}
//
//
str = GetAttribute(el, DeviceDefineNodeNames.LittleEndian, true);
if (str.Length > 0)
{
littleEndian = bool.Parse(str);
}
ibc.IsLittleEndian = littleEndian;
str = GetAttribute(el, DeviceDefineNodeNames.Bytes, true);
if (str != null && str.Length > 0)
{
bytes = HexStringConverter.Default.ConvertToBytes(str);
}
str = GetAttribute(el, DeviceDefineNodeNames.Crc, true);
if (str != null && str.Length > 0)
{
iscrc = bool.Parse(str);
}
str = GetAttribute(el, DeviceDefineNodeNames.MatchCheck, true);
if (str != null && str.Length > 0)
{
isMatchCheck = bool.Parse(str);
}
str = GetAttribute(el, DeviceDefineNodeNames.Lazy, true);
if (str != null && str.Length > 0)
{
isLazy = bool.Parse(str);
}
DataField df = new DataField(name, begin, length, (IBytesConverter)ibc);
df.IsMatchCheck = isMatchCheck;
if (bytes != null)
{
df.Bytes = bytes;
}
if (df.IsMatchCheck &&
(df.Bytes == null || df.Bytes.Length == 0))
{
throw new Exception("must set bytes while matchCheck == true");
}
df.IsCRC = iscrc;
df.IsLazy = isLazy;
return(df);
}
