private void RaizeVariableClassChanged(string name, LDVarClass oldClass, LDVarClass newClass)
{
if (VariableClassChanged != null)
{
VariableClassChanged(this, new VarClassChangedArgs(name, oldClass, newClass));
}
}
/// <summary>
/// Builder (sets type's default value)
/// </summary>
/// <param name="dataType">Variable type</param>
public LDIVariable(Type dataType, LDVarClass type)
: this(dataType, type, 1, null)
{
//get default value for the given type
Value = (dataType.IsValueType) ? Activator.CreateInstance(dataType) : null;
Locked = false;
}
private void RaizeVariableAdded(string name, LDVarClass varClass)
{
if (VariableAdded != null)
{
VariableAdded(this, new VarAddedArgs(name, varClass));
}
}
/// <summary>
/// Set variable class by index
/// </summary>
/// <param name="index">Variable index</param>
/// <param name="value">Value to be set</param>
public LadderDataTable SetVarClass(int index, LDVarClass value)
{
if (index < 0 || index >= Table.Count)
{
throw new ArgumentOutOfRangeException("Index is not inside table limits");
}
if (Table.Values[index].NumRefs > 1 && Table.Values[index].Class != value)
{
throw new InvalidOperationException("Can't change variable LD Class");
}
if (Table.Values[index].Class != value)
{
Trace.WriteLine("Class at [" + index + "] (" + Table.Keys[index] + "): changed to " + value, "Ladder Data Table");
LDVarClass oldClass = Table.Values[index].Class;
Table.Values[index].Class = value;
RaizeVariableClassChanged(Table.Keys[index], oldClass, value);
}
else
{
Trace.WriteLine("Class change at [" + index + "] (" + Table.Keys[index] + ") ignored", "Ladder Data Table");
}
return(this);
}
/// <summary>
/// Set variable class by name
/// </summary>
/// <param name="name">Variable name</param>
/// <param name="value">Value to be set</param>
public LadderDataTable SetVarClass(string name, LDVarClass value)
{
int index = Table.IndexOfKey(name);
if (index != -1)
{
if (Table.Values[index].NumRefs > 1 && Table.Values[index].Class != value)
{
throw new InvalidOperationException("Can't change variable LD Class");
}
if (Table.Values[index].Class != value)
{
Trace.WriteLine("Class of " + name + " changed to " + value, "Ladder Data Table");
LDVarClass oldClass = Table.Values[index].Class;
Table.Values[index].Class = value;
RaizeVariableClassChanged(name, oldClass, value);
}
else
{
Trace.WriteLine("Class change of " + name + " ignored", "Ladder Data Table");
}
return(this);
}
else
{
throw new ArgumentException("Variable not found", "name");
}
}
/// <summary>
/// Manage memory allocation.
/// In case of an existing variable it only increase its reference counter
/// </summary>
/// <param name="name">Variable name</param>
/// <param name="dataType">Variable data type</param>
/// <param name="varClass">Variable type</param>
public LadderDataTable Add(string name, Type dataType, LDVarClass varClass = LDVarClass.Data)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("Variable name must be provided", "name");
}
if (dataType == null)
{
throw new ArgumentNullException("Variable type must be provided", "dataType");
}
int index = Table.IndexOfKey(name);
if (index != -1)
{
if (dataType != Table.Values[index].DataType)
{
throw new ArgumentException("Name already used", "name", new FormatException("Value Type Mismatch"));
}
Table.Values[index].NumRefs++;
Trace.WriteLine("New reference to variable " + name + ", total number of references: " + Table.Values[index].NumRefs, "Ladder Data Table");
}
else
{
Table.Add(name, new LDIVariable(dataType, varClass));
RaizeVariableAdded(name, varClass);
Trace.WriteLine("New Variable inserted: " + name + ", Type: " + dataType, "Ladder Data Table");
}
return(this);
}
/// <summary>
/// Master builder
/// </summary>
/// <param name="dataType">Variable data type</param>
/// <param name="type">Variable type</param>
/// <param name="numRefs">Number of references to this variable</param>
/// <param name="value">Variable initial value</param>
public LDIVariable(Type dataType, LDVarClass type, int numRefs, object value)
{
Value = value;
NumRefs = numRefs;
DataType = dataType;
Class = type;
Locked = false;
}
public static PinType ToPin(this LDVarClass varClass)
{
return((PinType)((char)varClass));
}
public static bool IsPin(this LDVarClass varClass)
{
return((varClass == Data.LDVarClass.Analog) || (varClass == Data.LDVarClass.Input) || (varClass == Data.LDVarClass.Output) || (varClass == Data.LDVarClass.PWM));
}
public VarAddedArgs(string name, LDVarClass varClass)
{
Name = name;
VarClass = varClass;
}
public VarClassChangedArgs(string name, LDVarClass oldClass, LDVarClass newClass)
{
Name = name;
OldClass = oldClass;
NewClass = newClass;
}
/// <summary>
/// Builder
/// </summary>
/// <param name="dataType">Variable type</param>
/// <param name="value">Variable initial value</param>
public LDIVariable(Type dataType, LDVarClass type, object value)
: this(dataType, type, 1, value)
{
}
