/// <summary>
///
/// </summary>
/// <returns></returns>
public byte[] ToBytes()
{
Xdgk.Communi.BytesConverterManager bcMan = XD221ModbusConfigObject.BytesConverterManager;
// TODO: get ci
//
XD221ConfigDefine ci = null; // this.XD221ConfigItem;
IBytesConverter ibc = bcMan.CreateBytesConverter(ci.Converter, null);
if (ibc == null)
{
string s = string.Format("Create converter fail, converter type '{0}'", ci.Converter);
throw new Exception(s);
}
byte[] inDataBs = ibc.ConvertToBytes(this.Value);
// TODO: convert to modbus bs
//
byte[] beginBs = GetModbusWordBytes(ci.Offset);
byte[] wordCountBs = GetModbusWordBytes(inDataBs.Length / 2);
byte[] byteCountBs = new byte[] { (byte)inDataBs.Length };
MemoryStream ms = new MemoryStream();
AppendBytes(ms, beginBs, wordCountBs, byteCountBs, inDataBs);
return(ms.ToArray());
}
//}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void okButton_Click(object sender, EventArgs e)
{
IComparable value;
bool r = ParseParameterValue(out value);
if (!r)
{
return;
}
// TODO: 2010-07-29 convert param value to byte[]
//
// 1. get converter name
// 2. get bytes converter
// 3. bc.ConvertToBytes( paramvalue ) save to data byte array
//
ParameterDefine pd = this.GetSelectedParameterDefine();
string converterName = pd.ConverterName;
IBytesConverter ibc = GetBytesConverter(converterName);
if (ibc == null)
{
string exmsg = string.Format("cannot get bytesconverter '{0}'", converterName);
throw new InvalidOperationException(exmsg);
}
byte[] bs = ibc.ConvertToBytes(value);
this._datas = bs;
this.DialogResult = DialogResult.OK;
Close();
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
private void Register(string path)
{
try
{
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = Path.GetFileNameWithoutExtension(path);
assemblyName.CodeBase = path;
Assembly assembly = Assembly.Load(assemblyName);
log.Debug("Loaded " + Path.GetFileName(path));
this._assemblyList.Add(assembly);
foreach (Type type in assembly.GetExportedTypes())
{
if (type.IsClass && typeof(IBytesConverter).IsAssignableFrom(type))
{
IBytesConverter ibc = (IBytesConverter)Activator.CreateInstance(type);
this._bytesConverterCollection.Add(ibc);
//log.Error("Addin {0} was already registered", addin.Name);
//else
//{
// addinRegistry.Register(addin);
log.Debug("Registered addin: {0}", ibc.GetType());
//}
}
}
}
catch (Exception ex)
{
// NOTE: Since the gui isn't loaded at this point,
// the trace output will only show up in Visual Studio
log.Error("Failed to load" + path, ex);
}
}
static private IBytesConverter GetBytesConverter(BytesConverterConfig cfg)
{
BytesConverterManager bcm = BytesConverterManager.Default;
IBytesConverter bc = bcm.CreateBytesConverter(cfg);
return(bc);
}
/// <summary>
///
/// </summary>
/// <param name="bc"></param>
/// <returns></returns>
private ListViewItem CreateListViewItem(IBytesConverter bc)
{
string assemblyInfo = GetAssemblyInfo(bc);
//string[] items = new string[] {bc.GetType().FullName , "-", assemblyInfo };
string[] items = new string[] { bc.GetType().FullName };
ListViewItem lvi = new ListViewItem(items);
return lvi;
}
/// <summary>
///
/// </summary>
/// <param name="beginPosition"></param>
/// <param name="dataLength"></param>
public DataField(string name, int beginPosition, int dataLength, IBytesConverter bytesConverter, DataFieldOption option)
{
this.Name = name.Trim();
this.BeginPosition = beginPosition;
this.DataLength = dataLength;
this.DataFieldOption = option;
this.BytesConverter = bytesConverter;
}
/// <summary>
///
/// </summary>
/// <param name="convertName"></param>
/// <returns></returns>
static private IBytesConverter GetBytesConvert(string converterName, object[] args)
{
BytesConverterManager bcm = BytesConverterManager.Default;
IBytesConverter bc = bcm.CreateBytesConverter(converterName, args);
if (bc == null)
{
log.Error("not find BytesConvert: " + converterName);
throw new ArgumentException("not find BytesConvert: " + converterName);
}
else
{
}
return(bc);
}
public HyperLogLog(HashAlgorithm hashAlgorithm, IBytesConverter bytesConverter, int b = 10)
{
if (b < 4 || b > 16)
{
throw new ArgumentOutOfRangeException("b", string.Format("HyperLogLog accuracy of {0} is not supported. Please use a B value between 4 and 16.", b));
}
_hashAlgorithm = hashAlgorithm;
_bytesConverter = bytesConverter;
B = b;
M = (int)Math.Pow(2, b);
Alpha = ComputeAlpha();
_registers = new byte[M];
}
public HyperLogLog DeserializeTo(Stream stream, HashAlgorithm hashAlgorithm, IBytesConverter bytesConverter)
{
using (var br = new BinaryReader(stream))
{
var b = br.ReadByte();
var result = new HyperLogLog(hashAlgorithm, bytesConverter, b);
for (int i =0; i < result.M; i++)
{
result._registers[i] = br.ReadByte();
}
return result;
}
}
public HyperLogLog(HashAlgorithm hashAlgorithm, IBytesConverter bytesConverter, int b = 10)
{
if (b < 4 || b > 16)
throw new ArgumentOutOfRangeException("b", string.Format("HyperLogLog accuracy of {0} is not supported. Please use a B value between 4 and 16.", b));
_hashAlgorithm = hashAlgorithm;
_bytesConverter = bytesConverter;
B = b;
M = (int)Math.Pow(2, b);
Alpha = ComputeAlpha();
_registers = new byte[M];
}
public HyperLogLog DeserializeTo(Stream stream, HashAlgorithm hashAlgorithm, IBytesConverter bytesConverter)
{
using (var br = new BinaryReader(stream))
{
var b = br.ReadByte();
var result = new HyperLogLog(hashAlgorithm, bytesConverter, b);
for (int i = 0; i < result.M; i++)
{
result._registers[i] = br.ReadByte();
}
return(result);
}
}
/// <summary>
///
/// </summary>
/// <param name="convertName"></param>
/// <returns></returns>
static private IBytesConverter GetBytesConvert(string converterName, object[] args)
{
BytesConverterManager bcm = CommuniSoft.Default.BytesConverterManager;
//IBytesConverter bc = bcm.GetBytesConverter(convertName);
IBytesConverter bc = bcm.CreateBytesConverter(converterName, args);
if (bc == null)
{
//bc = new OriginalConverter();
log.Error("not find BytesConvert: " + converterName);
throw new ArgumentException("not find BytesConvert: " + converterName);
}
else
{
}
return(bc);
}
/// <summary>
///
/// </summary>
/// <param name="bs"></param>
/// <returns></returns>
static public XD221ModbusConfigObject Parse(byte[] bs)
{
if (bs.Length == 7)
{
int begin = GetModbusWord(bs, 0);
int wordCount = GetModbusWord(bs, 2);
int byteCount = bs[4];
// TODO: wordindex converter
//
XD221ConfigDefine ci = XD221ConfigDefineCollection.Find(begin + 1);
// TODO: ci == null
//
IBytesConverter ibc = BytesConverterManager.CreateBytesConverter(ci.Converter, null);
object obj = ibc.ConvertToObject(bs);
XD221ModbusConfigObject mpo = new XD221ModbusConfigObject(ci.Name, obj);
return(mpo);
}
return(null);
}
/// <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>
/// 由beginPosition起始，长度为dataLength，数据为values的域
/// </summary>
/// <param name="beginPosition"></param>
/// <param name="dataLength"></param>
/// <param name="values"></param>
public BytesDataField(string name, int beginPosition, int dataLength, IBytesConverter bytesConverter, DataFieldOption dataFieldOption)
: base(name, beginPosition, dataLength, bytesConverter, dataFieldOption)
{
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="beginPosition"></param>
/// <param name="dataLength"></param>
public DataField(string name, int beginPosition, int dataLength, IBytesConverter bytesConverter)
: this(name, beginPosition, dataLength, bytesConverter, DataFieldOption.BytesVolatile | DataFieldOption.ValueVolatile)
{
}
/// <summary>
/// 由beginPosition起始，长度为dataLength，数据为values的域
/// </summary>
/// <param name="beginPosition"></param>
/// <param name="dataLength"></param>
/// <param name="values"></param>
public BytesDataField( string name, int beginPosition, int dataLength, IBytesConverter bytesConverter, DataFieldOption dataFieldOption )
: base(name, beginPosition, dataLength, bytesConverter, dataFieldOption)
{
}
/// <summary>
///
/// </summary>
/// <param name="beginPosition"></param>
/// <param name="dataLength"></param>
public DataField(string name, int beginPosition, int dataLength, IBytesConverter bytesConverter, DataFieldOption option )
{
this.Name = name.Trim();
this.BeginPosition = beginPosition;
this.DataLength = dataLength;
this.DataFieldOption = option;
this.BytesConverter = bytesConverter;
}
public HyperLogLog DeserializeTo(Stream stream, IBytesConverter bytesConverter)
{
return(DeserializeTo(stream, MD5.Create(), bytesConverter));
}
/// <summary>
///
/// </summary>
/// <param name="bc"></param>
/// <returns></returns>
private string GetAssemblyInfo(IBytesConverter bc)
{
return bc.GetType().Assembly.FullName;
}
public HyperLogLog DeserializeTo(Stream stream, IBytesConverter bytesConverter)
{
return DeserializeTo(stream, MD5.Create(), bytesConverter);
}
/// <summary>
///
/// </summary>
/// <param name="datafieldnode"></param>
/// <returns></returns>
static private 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;
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);
str = GetAttribute(el, DeviceDefineNodeNames.Converter, true);
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);
}
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;
return(df);
}
/// <summary>
///
/// </summary>
/// <param name="bc"></param>
/// <returns></returns>
private string GetAssemblyInfo(IBytesConverter bc)
{
return(bc.GetType().Assembly.FullName);
}
//public const int UNSURENESS = -1;
#region Constructor
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="beginPosition"></param>
/// <param name="dataLength"></param>
public DataField(string name, int beginPosition, int dataLength, IBytesConverter bytesConverter)
: this(name, beginPosition, dataLength, bytesConverter, DataFieldOption.BytesVolatile | DataFieldOption.ValueVolatile)
{
}
public HyperLogLog(IBytesConverter bytesConverter, int b = 10)
: this(MD5.Create(), bytesConverter, b)
{
}
public OperatingParameters(string[] args)
{
//параметры коммандной строки
//парсер считает обязательными compress/decompress [имя исходного файла]
//при неуказании имени результирующего файла, он его создаст добавив расширение, соответствующее
//наименованию архиватора к исходному файлу
//реализованные архиваторы
coderArray = new List <IBytesConverter>()
{
new GzipCompressorAsync(), new GzipDecompressorAsync(),
new GzipCompressor(), new GzipDecompressor()
};
if (args.Count() < 2)
{
Console.WriteLine(GetInstructions4User());
return;
}
defaultCoderName = coderArray[0].coderName;
//считываем compress/decompress
string methodName = args[0].ToLower();
eCoderMethod coderMethod = eCoderMethod.Compress;
switch (methodName)
{
case "compress": coderMethod = eCoderMethod.Compress; break;
case "decompress": coderMethod = eCoderMethod.Decompress; break;
default:
{
coderEngine = null;
Console.WriteLine(GetInstructions4User());
return;
}
}
//считываем наименование исходного файла
srcFile = args[1];
//если аргументов всего 2, выставляем архиватор по умолчанию GzipCompressorAsync/GzipDecompressorAsync
if (args.Count() == 2)
{
if ((coderEngine = (from cdr in coderArray
where cdr.coderName == defaultCoderName && cdr.coderMethod == coderMethod
select cdr).FirstOrDefault()) == null)
{
Console.WriteLine("Не удалось найти архиватор по умолчанию");
return;
}
//т.к. параметров 2, то результирующий файл не указан - пытаемся придумать
dscFile = GetDestFileName();
return;
}
//параметров 3
//проверяем, может быть 3м параметром указан не результирующий файл, а наименование кодера
string coderName = TryParseCoderName(args[2]);
if (String.IsNullOrWhiteSpace(coderName))
{
//значит, файл
dscFile = args[2];
//может кодер указан 4м параметром?
coderName = args.Count() > 3 ? TryParseCoderName(args[3]) : defaultCoderName;
}
//получаем объект по названию кодера и функционалу (compress/decompress)
coderEngine = (from cdr in coderArray
where cdr.coderName == coderName && cdr.coderMethod == coderMethod
select cdr).FirstOrDefault();
if (coderEngine == null)
{
Console.WriteLine(GetInstructions4User());
return;
}
dscFile = String.IsNullOrWhiteSpace(dscFile) ? GetDestFileName() : dscFile;
}
public HyperLogLog(IBytesConverter bytesConverter, int b = 10)
: this(MD5.Create(), bytesConverter, b)
{ }
