public bool Apply(Playerstatistic playerstatistic)
{
var result = (DataFreshness == 0 || (DateTime.Now - playerstatistic.Time).Days <= DataFreshness) &&
(TableTypes == null || !TableTypes.Any() || TableTypes.Contains(playerstatistic.MaxPlayers));
return(result);
}
public MazeTableViewModel(double[][] arrayValues, int numberOfStates, TableTypes tableType)
{
_tableType = tableType;
_arrayValues = arrayValues;
_numberOfStates = numberOfStates;
DetailsViewTitle = tableType.ToString() + " Details";
}
internal static TomlTable CreateFromComplexObject <T>(ITomlRoot root, T obj, TableTypes tableType)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
TomlTable tt = new TomlTable(root, tableType);
var props = root.Settings.GetSerializationProperties(obj.GetType());
var allObjects = new List <Tuple <string, TomlObject> >();
foreach (var p in props)
{
object val = p.GetValue(obj, null);
if (val != null)
{
TomlObject to = TomlObject.CreateFrom(root, val, p);
AddComments(to, p);
tt.AddRow(new TomlKey(p.Name), to);
}
}
return(tt);
}
protected void HandleCellRendererComboEdited(object o, EditedArgs args)
{
TreeIter iter;
if (!treeModel.GetIter(out iter, new TreePath(args.Path)))
{
return;
}
TableType ttNew;
if (!TableTypes.TryParse(args.NewText, out ttNew))
{
return;
}
int colNr = CursorColNr;
// so far there's only ComboBox for TableType column
var ttOld = (TableType)treeModel.GetValue(iter, colNr);
if (ttOld != ttNew)
{
treeModel.SetValue(iter, colNr, (int)ttNew);
OnTableTypeChanged(iter, ttNew);
// follow it in case this column is being sorted
ScrollTo(iter);
}
}
public static DataTable MakeTable(TableTypes TableType)
{
DataTable Result = null;
switch (TableType)
{
case TableTypes.OpenList:
Result = MakeDataTable(WPL_ARR_ROW);
break;
case TableTypes.ExportList:
Result = MakeDataTable(BASIC_ARR_ROW);
break;
case TableTypes.ErrorList:
Result = MakeDataTable(FILE_ROW);
break;
case TableTypes.Default:
default:
Result = MakeDataTable(BASIC_ARR_ROW);
break;
}
return(Result);
}
static void ParseValues(XElement el, out int?address, out string unit, out TableType?tableType)
{
address = null;
unit = null;
tableType = null;
XAttribute attr = el.Attribute(X_address);
if (attr != null)
{
address = ParseHexInt((string)attr, attr);
}
attr = el.Attribute(X_tableType);
if (attr != null)
{
TableType parsedType;
if (TableTypes.TryParse((string)attr, out parsedType))
{
tableType = parsedType;
}
}
unit = (string)el.Attribute(X_unit);
}
public static string TableAndColumnBracket(
string tableName, TableTypes tableType, string columnBracket)
{
var tableBracket = string.Empty;
if (!tableName.IsNullOrEmpty() && columnBracket.StartsWith("["))
{
switch (tableType)
{
case TableTypes.Normal:
tableBracket = "[" + tableName + "].";
break;
case TableTypes.History:
tableBracket = "[" + tableName + "_History].";
break;
case TableTypes.Deleted:
tableBracket = "[" + tableName + "_Deleted].";
break;
}
}
return(columnBracket.StartsWith("(")
? columnBracket.Replace("$[", tableBracket + "[")
: tableBracket + columnBracket);
}
internal static TomlTable CreateFromComplexObject <T>(ITomlRoot root, T obj, TableTypes tableType)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
TomlTable tt = new TomlTable(root, tableType);
var members = root.Settings.GetSerializationMembers(obj.GetType());
var allObjects = new List <Tuple <string, TomlObject> >();
foreach (var m in members)
{
object val = m.GetValue(obj);
if (val != null)
{
TomlObject to = TomlObject.CreateFrom(root, val);
to.AddComments(root.Settings.GetComments(obj.GetType(), m.Member));
tt.AddRow(m.Key, to);
}
}
return(tt);
}
static DataViewBaseGtk()
{
// populate strings to be shown in ComboBox
foreach (string item in TableTypes.GetStrings())
{
tableTypesModel.AppendValues(item);
}
}
private async void AddTableType(object obj)
{
TableRepo.UndoChanges(Tables.ToList());
TableTypeRepo.UndoChanges(TableTypes.ToList());
TableTypeRepo.Add(TableType);
UpdateTableTypeList();
await DialogOperations.DisplayInformationMessage("Masa Tipi Eklendi", "TableDialog");
}
private void SelectDefaultTableType()
{
var tableTypeToSelect = TableTypes.FirstOrDefault(x => x.Item.MaxPlayers == (int)hudLayout.TableType);
if (tableTypeToSelect != null)
{
tableTypeToSelect.IsSelected = true;
}
}
/// <summary>
/// Resets form
/// </summary>
private void Reset()
{
Name = string.Empty;
Description = string.Empty;
Cost = 0;
GameVariants.ForEach(x => x.IsSelected = false);
GameTypes.ForEach(x => x.IsSelected = false);
TableTypes.ForEach(x => x.IsSelected = false);
Images.Clear();
}
public HudLayoutFilter Clone()
{
var clone = new HudLayoutFilter
{
DataFreshness = DataFreshness,
TableTypes = TableTypes.ToArray()
};
return(clone);
}
public Table(short numplayers, string name = "Nombre de Mesa no Asignado", TableTypes tabletype = TableTypes.Zoom, List <Player> listaJugadores = null)
{
// TODO: Para mesas Heads Up, el dealer y la SB son el mismo jugador, hay que manejar esto en el futuro de otra forma
if (numplayers < 3)
{
throw new NotImplementedException();
}
NumPlayers = numplayers;
Name = name;
TableType = tabletype;
Players = listaJugadores;
}
private async void AddTable(object obj)
{
TableRepo.UndoChanges(Tables.ToList());
TableTypeRepo.UndoChanges(TableTypes.ToList());
SelectedTable = TableRepo.Add(new Masa()
{
Ad = SelectedTable.Ad,
MasaTipiKod = SelectedTable.MasaTipiKod,
AcikKapali = false
});
UpdateTableList();
await DialogOperations.DisplayInformationMessage("Masa Eklendi", "TableDialog");
}
// FALSE if the row matches, TRUE otherwise !!!
protected static bool EqualFuncTableType(string key, TableType content)
{
TableType parsed;
if (TableTypes.TryParse(key, out parsed))
{
return(parsed != content);
}
else
{
return(true);
}
}
/// <summary>
/// Конструктор
/// </summary>
public DataUnit(TableTypes tableType)
{
Name = "";
TableType = tableType;
Address = 0;
FuncCode = 0;
ExcFuncCode = 0;
ReqPDU = null;
RespPduLen = 0;
ReqADU = null;
ReqStr = "";
RespByteCnt = 0;
}
/// <summary>
/// Encodes a token
/// </summary>
/// <param name="token">The token</param>
/// <param name="codedToken">Coded token</param>
/// <returns><c>true</c> if successful</returns>
public bool Encode(uint token, out uint codedToken)
{
int index = TableTypes.IndexOf(MDToken.ToTable(token));
if (index < 0)
{
codedToken = uint.MaxValue;
return(false);
}
// This shift can never overflow a uint since bits < 8 (it's at most 5), and
// ToRid() returns an integer <= 0x00FFFFFF.
codedToken = (MDToken.ToRID(token) << Bits) | (uint)index;
return(true);
}
/// <summary>
/// Конструктор
/// </summary>
public ElemGroup(TableTypes tableType)
: base(tableType)
{
reqDescr = "";
Active = true;
Elems = new List <Elem>();
ElemVals = null;
TotalElemLength = -1;
StartKPTagInd = -1;
StartSignal = 0;
// определение кодов функций
UpdateFuncCode();
ExcFuncCode = (byte)(FuncCode | 0x80);
}
/// <summary>
/// Получить наименование типа таблицы данных
/// </summary>
public static string GetTableTypeName(TableTypes tableType)
{
switch (tableType)
{
case TableTypes.DiscreteInputs:
return("Discrete Inputs");
case TableTypes.Coils:
return("Coils");
case TableTypes.InputRegisters:
return("Input Registers");
default: // TableTypes.HoldingRegisters
return("Holding Registers");
}
}
public static void PopulateTable(TableTypes TableType, ref DataTable Table, List <XmlNode> NodeList)
{
switch (TableType)
{
case TableTypes.OpenList:
foreach (XmlNode song in NodeList) //Populate the table
{
Table.LoadDataRow(new object[]
{
FilterFileNameNumbers(song.Attributes.GetNamedItem(XML_STR_SRC).Value, false),
//song.Attributes.GetNamedItem("trackTitle").Value,
song.Attributes.GetNamedItem("albumTitle").Value,
song.Attributes.GetNamedItem("albumArtist").Value,
song.Attributes.GetNamedItem("trackArtist").Value,
song.Attributes.GetNamedItem(XML_STR_FILE_TYPE).Value,
song.Attributes.GetNamedItem(XML_STR_DATE_MODIFIED).Value,
}, true);
}
break;
case TableTypes.ErrorList:
foreach (XmlNode song in NodeList)
{
Table.LoadDataRow(new object[]
{
song.Attributes.GetNamedItem(XML_STR_SRC).Value
}, true);
}
break;
case TableTypes.ExportList:
case TableTypes.Default:
default:
foreach (XmlNode song in NodeList)
{
Table.LoadDataRow(new object[]
{
FilterFileNameNumbers(song.Attributes.GetNamedItem(XML_STR_SRC).Value, false),
song.Attributes.GetNamedItem(XML_STR_FILE_TYPE).Value,
song.Attributes.GetNamedItem(XML_STR_DATE_MODIFIED).Value,
}, true);
}
break;
}
}
public override int GetHashCode()
{
unchecked
{
var hashcode = 23;
hashcode += hashcode * 31 + DataFreshness.GetHashCode();
if (TableTypes != null && TableTypes.Any())
{
TableTypes.Distinct().ForEach(x =>
{
hashcode += hashcode * 31 + x.GetHashCode();
});
}
return(hashcode);
}
}
public MazeTableViewModel(int[][] arrayValues, int numberOfStates, TableTypes tableType)
{
_tableType = tableType;
_numberOfStates = numberOfStates;
_arrayValues = new double[arrayValues.Length][];
for (int i = 0; i < arrayValues.Length; ++i)
{
_arrayValues[i] = new double[arrayValues[i].Length];
for (int j = 0; j < arrayValues[i].Length; ++j)
{
_arrayValues[i][j] = arrayValues[i][j];
}
}
DetailsViewTitle = tableType.ToString() + " Details";
}
//public T GetInterface<T>() where T : IHardwareType
//{
// Console.WriteLine( " [GetInterface] Start" );
// BaseInfo ht;
// for( int i = 0; i < HardwareList.Count; i++ )
// {
// ht = HardwareList[ i ];
// if( ht is T )
// return (T)((object)ht);
// }
// Console.WriteLine( " [GetInterface] End" );
// throw new Exception( "Interface not found" );
//}
//public List<IHardwareType> GetHardwareDescriptorByType( byte Type )
//{
// return TypeBasedList[ Type ];
//}
//public IHardwareType GetHardwareDescriptorByHandle( ushort Handle )
//{
// return HandleBasedList[ Handle ];
//}
public List <BaseInfo> GetHardwareDescriptorByType(TableTypes Type)
{
//Console.WriteLine( " [GetHardwareDescriptorByType] Start" );
List <BaseInfo> tmp = new List <BaseInfo>();
BaseInfo ht;
for (int i = 0; i < HardwareList.Count; i++)
{
ht = HardwareList[i];
if (ht.HardwareType == (byte)Type)
{
tmp.Add(ht);
}
}
//Console.WriteLine( " [GetHardwareDescriptorByType] End" );
return(tmp);
}
private void cbGrTableType_SelectedIndexChanged(object sender, EventArgs e)
{
// изменение типа таблицы данных группы элементов
if (elemGroup != null)
{
TableTypes tableType = (TableTypes)cbGrTableType.SelectedIndex;
int maxElemCnt = DataUnit.GetMaxElemCnt(tableType);
bool cancel = elemGroup.Elems.Count > maxElemCnt &&
MessageBox.Show(string.Format(KpPhrases.ElemRemoveWarning, maxElemCnt),
CommonPhrases.QuestionCaption, MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Question) != DialogResult.Yes;
if (cancel)
{
cbGrTableType.SelectedIndexChanged -= cbGrTableType_SelectedIndexChanged;
cbGrTableType.SelectedIndex = (int)elemGroup.TableType;
cbGrTableType.SelectedIndexChanged += cbGrTableType_SelectedIndexChanged;
}
else
{
// ограничение макс. количества элементов в группе
if (numGrElemCnt.Value > maxElemCnt)
{
numGrElemCnt.Value = maxElemCnt;
}
numGrElemCnt.Maximum = maxElemCnt;
// установка типа таблицы данных
elemGroup.TableType = tableType;
elemGroup.UpdateFuncCode();
ShowFuncCode(elemGroup);
// установка типа элементов группы по умолчанию
ElemTypes elemType = elemGroup.DefElemType;
foreach (Elem elem in elemGroup.Elems)
{
elem.ElemType = elemType;
}
OnObjectChanged(TreeUpdateTypes.CurrentNode | TreeUpdateTypes.ChildNodes);
}
}
}
/// <summary>
/// This method returns the ETL loading 'direction' based on the source and target mapping.
/// </summary>
/// <param name="sourceDataObjectName"></param>
/// <param name="targetDataObjectName"></param>
/// <param name="teamConfiguration"></param>
/// <returns></returns>
public static string GetDataObjectMappingLoadVector(string sourceDataObjectName, string targetDataObjectName, TeamConfiguration teamConfiguration)
{
// This is used to evaluate the correct connection for the generated ETL processes.
TableTypes evaluatedSource = GetDataObjectType(sourceDataObjectName, "", teamConfiguration);
TableTypes evaluatedTarget = GetDataObjectType(targetDataObjectName, "", teamConfiguration);
string loadVector = "";
if (evaluatedSource == TableTypes.StagingArea && evaluatedTarget == TableTypes.PersistentStagingArea)
{
loadVector = "Landing to Persistent Staging Area";
}
// If the source is not a DWH table, but the target is a DWH table then it's a base ('Raw') Data Warehouse ETL (load vector). - 'Staging Layer to Raw Data Warehouse'.
else if (!new[] { TableTypes.CoreBusinessConcept, TableTypes.Context, TableTypes.NaturalBusinessRelationship, TableTypes.NaturalBusinessRelationshipContext, TableTypes.Derived }.Contains(evaluatedSource) && new[] { TableTypes.CoreBusinessConcept, TableTypes.Context, TableTypes.NaturalBusinessRelationship, TableTypes.NaturalBusinessRelationshipContext }.Contains(evaluatedTarget))
{
loadVector = "Staging Layer to Raw Data Warehouse";
}
// If the source is a DWH or Derived table, and the target is a DWH table then it's a Derived ('Business') DWH ETL - 'Raw Data Warehouse to Interpreted'.
else if (new[] { TableTypes.CoreBusinessConcept, TableTypes.Context, TableTypes.NaturalBusinessRelationship, TableTypes.NaturalBusinessRelationshipContext, TableTypes.Derived }.Contains(evaluatedSource) && new[] { TableTypes.CoreBusinessConcept, TableTypes.Context, TableTypes.NaturalBusinessRelationship, TableTypes.NaturalBusinessRelationshipContext }.Contains(evaluatedTarget))
{
loadVector = "Raw Data Warehouse to Interpreted";
}
// If the source is a DWH table, but target is not a DWH table then it's a Presentation Layer ETL. - 'Data Warehouse to Presentation Layer'.
else if
(new[] { TableTypes.CoreBusinessConcept, TableTypes.Context, TableTypes.NaturalBusinessRelationship, TableTypes.NaturalBusinessRelationshipContext }.Contains(evaluatedSource)
&&
new[] { TableTypes.Presentation }.Contains(evaluatedTarget)
)
{
loadVector = "Data Warehouse to Presentation Layer";
}
else if (evaluatedSource == TableTypes.Source && new[] { TableTypes.StagingArea, TableTypes.PersistentStagingArea }.Contains(evaluatedTarget))
{
loadVector = "Source to Staging Layer";
}
else // Return error
{
loadVector = "'" + evaluatedSource + "' to '" + evaluatedTarget + "'";
}
return(loadVector);
}
public ReturnCode ConnectToDatabase(string PathToDatabase = "")
{
if (PathToDatabase == string.Empty)
{
PathToDatabase = Path.Combine(Path.Combine(Application.StartupPath, DefaultFolder), DefaultFileName);
}
//MessageBox.Show(PathToDatabase);
SetPathToDatabase(PathToDatabase);
ReturnCode code;
try
{
code = CheckDatabaseStructure();
}
catch
{
return(ReturnCodeFactory.Error("The file you specified is not a SQLite database."));
}
if (code.Error)
{
return(code);
}
if (TableTypes != null)
{
TableTypes.Clear();
}
try
{
TableTypes = GetTable(DbManager.TnTypes);
RootFolderName = GetRootFolderName();
}
catch (Exception ex)
{
RootFolderName = string.Empty;
return(ReturnCodeFactory.Error("Could not read data from the database file.", ex.Message));
}
return(ReturnCodeFactory.Success());
}
/// <summary>
/// Конструктор
/// </summary>
public ModbusCmd(TableTypes tableType, bool multiple = false, int elemCnt = 1)
: base(tableType)
{
if (!(tableType == TableTypes.Coils || tableType == TableTypes.HoldingRegisters))
{
throw new InvalidOperationException(ModbusPhrases.IllegalDataTable);
}
reqDescr = "";
Multiple = multiple;
ElemType = DefElemType;
ElemCnt = elemCnt;
ByteOrder = null;
ByteOrderStr = "";
CmdNum = 1;
Value = 0;
Data = null;
// определение кодов функций
UpdateFuncCode();
ExcFuncCode = (byte)(FuncCode | 0x80);
}
//public T GetInterface<T>() where T : IHardwareType
//{
// Console.WriteLine( " [GetInterface] Start" );
// BaseInfo ht;
// for( int i = 0; i < HardwareList.Count; i++ )
// {
// ht = HardwareList[ i ];
// if( ht is T )
// return (T)((object)ht);
// }
// Console.WriteLine( " [GetInterface] End" );
// throw new Exception( "Interface not found" );
//}
//public List<IHardwareType> GetHardwareDescriptorByType( byte Type )
//{
// return TypeBasedList[ Type ];
//}
//public IHardwareType GetHardwareDescriptorByHandle( ushort Handle )
//{
// return HandleBasedList[ Handle ];
//}
public List<BaseInfo> GetHardwareDescriptorByType( TableTypes Type )
{
//Console.WriteLine( " [GetHardwareDescriptorByType] Start" );
List<BaseInfo> tmp = new List<BaseInfo>();
BaseInfo ht;
for( int i = 0; i < HardwareList.Count; i++ )
{
ht = HardwareList[ i ];
if( ht.HardwareType == (byte)Type )
tmp.Add( ht );
}
//Console.WriteLine( " [GetHardwareDescriptorByType] End" );
return tmp;
}
internal static TomlTable CreateFromDictionary(ITomlRoot root, IDictionary dict, TableTypes tableType)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
if (dict == null)
{
throw new ArgumentNullException(nameof(dict));
}
var tomlTable = new TomlTable(root, tableType);
foreach (DictionaryEntry r in dict)
{
var obj = TomlObject.CreateFrom(root, r.Value);
tomlTable.AddRow(new TomlKey((string)r.Key), obj);
}
return(tomlTable);
}
internal TomlTable(ITomlRoot root, TableTypes tableType = TableTypes.Default)
: base(root)
{
this.TableType = tableType;
}
private CInstruction detectAndBuildInstruction(string Target, string Location, string Path, object CellValue, TableTypes typeOfTable)
{
CInstruction Instruction;
string CellValueStr = Convert.ToString(CellValue);
List<char> detectedChars = extractSpecialProperties(ref Target, ref CellValueStr);
if(detectedChars.Count > 0) logger.Debug(String.Format("Found {0} special properties.", detectedChars.Count));
if (typeOfTable == TableTypes.TABLE_ACTIONS)
{
if (CellValueStr.Equals("U"))
{
Instruction = new CInstrUnforce();
logger.Debug(String.Format("Detected Unforce step."));
Instruction.data = VariableParser.parseAsVariable(Target, Location, Path, null);
}
else if (String.Compare(Target, "@POPUP@") == 0)
{
Instruction = new CInstrPopup();
logger.Debug(String.Format("Detected Popup."));
Instruction.data = CellValueStr;
}
else
{
Instruction = new CInstrForce();
logger.Debug(String.Format("Detected Force step."));
Instruction.data = VariableParser.parseAsVariable(Target, Location, Path, CellValueStr);
}
}
else if (typeOfTable == TableTypes.TABLE_CHECKS)
{
if (String.Compare(Target, "@POPUP@") == 0)
{
Instruction = new CInstrPopup();
logger.Debug(String.Format("Detected Popup."));
Instruction.data = CellValueStr;
}
else
{
Instruction = new CInstrTest();
logger.Debug(String.Format("Detected Test step."));
Instruction.data = VariableParser.parseAsVariable(Target, Location, Path, CellValueStr);
}
}
else
{
throw new NotImplementedException("This step is not recognized as a correct step");
}
Instruction.ForceFailed = detectedChars.Contains('F');
Instruction.ForcePassed = detectedChars.Contains('P');
Instruction.Skipped = detectedChars.Contains('S');
return Instruction;
}
private void fillWithActions(CStep o_step, TableTypes typeOfTable, Excel.ListObject tableRef, object[,] table, int ColumnIndex)
{
logger.Debug(String.Format("Found {0} Excel lines to process.", table.GetLength(0)));
for (int line = 0; line < table.GetLength(0); line++)
{
object CellValue = table[line, ColumnIndex];
if(!(CellValue is ExcelDna.Integration.ExcelEmpty))
{
string Target = "";
if (table[line, tableStructure.TargetColumnIndex] is string) Target = (string)table[line, tableStructure.TargetColumnIndex];
string Path = "";
if (table[line, tableStructure.PathColumnIndex] is string) Path = (string)table[line, tableStructure.PathColumnIndex];
string Location = "";
if (table[line, tableStructure.LocationColumnIndex] is string) Location = (string)table[line, tableStructure.LocationColumnIndex];
logger.Debug(String.Format("Found item [Target={0}, Location={1}, Path={2}, Value={3}].", Target, Location, Path, CellValue));
try
{
logger.Debug(String.Format("Analysing current item."));
CInstruction o_instruction = detectAndBuildInstruction(Target, Location, Path, CellValue, typeOfTable);
if (typeOfTable == TableTypes.TABLE_ACTIONS)
{
logger.Debug("Adding item to list of actions to perform");
o_step.actions.Add(o_instruction);
}
else if (typeOfTable == TableTypes.TABLE_CHECKS)
{
logger.Debug("Adding item to list of checks to perform");
o_step.checks.Add(o_instruction);
}
else
throw new NotImplementedException(String.Format("This type of table ({0}) is not currently implemented", typeOfTable));
}
catch(InvalidCastException ex)
{
logger.Error("Problem when trying to find an equivalence for item.", ex);
report.add(new MessageReport("Invalid value in cell", tableRef.Range[line + 2, ColumnIndex + 1], ex.Message, Criticity.Error));
}
catch (Exception ex)
{
logger.Error("Invalid item processed.", ex);
report.add(new MessageReport("Cell problem", tableRef.Range[line + 2, ColumnIndex + 1], ex.Message, Criticity.Error));
}
}
}
}
/// <summary>
/// Конструктор
/// </summary>
public Cmd(TableTypes tableType, bool multiple = false, int elemCnt = 1)
: base(tableType)
{
if (tableType == TableTypes.DiscreteInputs || tableType == TableTypes.InputRegisters)
throw new Exception(Phrases.IllegalDataTable);
reqDescr = "";
Multiple = multiple;
ElemCnt = elemCnt;
Value = 0;
Data = null;
CmdNum = 1;
// определение кода функции запроса
if (tableType == TableTypes.Coils)
FuncCode = multiple ? FuncCodes.WriteMultipleCoils : FuncCodes.WriteSingleCoil;
else
FuncCode = multiple ? FuncCodes.WriteMultipleRegisters : FuncCodes.WriteSingleRegister;
// определение кода функции, обозначающего исключение
ExcFuncCode = (byte)(FuncCode | 0x80);
}
/// <summary>
/// Получить тип элементов группы по умолчанию в зависимости от типа таблицы данных
/// </summary>
public static ElemTypes GetDefElemType(TableTypes tableType)
{
return tableType == TableTypes.DiscreteInputs || tableType == TableTypes.Coils ?
ElemTypes.Bool : ElemTypes.UShort;
}
/// <summary>
/// Получить максимально допустимое количество элементов в группе
/// </summary>
public static int GetMaxElemCnt(TableTypes tableType)
{
return tableType == TableTypes.DiscreteInputs || tableType == TableTypes.Coils ? 2000 : 125;
}
/// <summary>
/// Конструктор
/// </summary>
public ElemGroup(TableTypes tableType)
: base(tableType)
{
reqDescr = "";
Elems = new List<Elem>();
ElemVals = null;
TotalElemLength = -1;
StartKPTagInd = -1;
StartSignal = 0;
// определение кода функции запроса
switch (tableType)
{
case TableTypes.DiscreteInputs:
FuncCode = FuncCodes.ReadDiscreteInputs;
break;
case TableTypes.Coils:
FuncCode = FuncCodes.ReadCoils;
break;
case TableTypes.InputRegisters:
FuncCode = FuncCodes.ReadInputRegisters;
break;
default: // TableTypes.HoldingRegisters:
FuncCode = FuncCodes.ReadHoldingRegisters;
break;
}
// определение кода функции, обозначающего исключение
ExcFuncCode = (byte)(FuncCode | 0x80);
}
/// <summary>
/// Конструктор
/// </summary>
public DataUnit(TableTypes tableType)
{
Name = "";
TableType = tableType;
Address = 0;
FuncCode = 0;
ExcFuncCode = 0;
ReqPDU = null;
RespPduLen = 0;
ReqADU = null;
ReqStr = "";
RespByteCnt = 0;
}
/// <summary>
/// Получить наименование типа таблицы данных
/// </summary>
public static string GetTableTypeName(TableTypes tableType)
{
switch (tableType)
{
case TableTypes.DiscreteInputs:
return "Discrete Inputs";
case TableTypes.Coils:
return "Coils";
case TableTypes.InputRegisters:
return "Input Registers";
default: // TableTypes.HoldingRegisters
return "Holding Registers";
}
}
