public static IOCollection ToIOCollection(this IEnumerable <TECIOModule> modules)
{
IOCollection io = new IOCollection();
modules.ForEach(mod => io.Add(mod.IO));
return(io);
}
public static IOCollection operator +(IOCollection left, IOCollection right)
{
IOCollection newCollection = new IOCollection(left);
newCollection.Add(right.ToList());
return(newCollection);
}
public static IOCollection ToIOCollection(this IEnumerable <TECPoint> points)
{
IOCollection collection = new IOCollection();
foreach (TECPoint point in points)
{
TECIO toAdd = new TECIO(point.Type);
toAdd.Quantity = point.Quantity;
collection.Add(toAdd);
}
return(collection);
}
public bool CanChangeType(TECControllerType newType)
{
if (newType == null)
{
return(false);
}
TECProvidedController possibleController = new TECProvidedController(newType);
IOCollection necessaryIO = this.UsedIO;
IOCollection possibleIO = possibleController.getPotentialIO() + possibleController.AvailableIO;
return(possibleIO.Contains(necessaryIO));
}
/// <summary>
/// Gets nessessary modules from potential modules to handle io.
/// </summary>
/// <param name="io"></param>
/// <returns>Nessessary modules. Returns empty list if no collection of modules exists.</returns>
private List <TECIOModule> getModulesForIO(IOCollection io)
{
IOCollection nessessaryIO = new IOCollection(io);
IOCollection relevantAvailableIO = (io | base.AvailableIO);
if (!nessessaryIO.Remove(relevantAvailableIO))
{
throw new Exception("NessessaryIO collection is having trouble removing subset of itself.");
}
List <TECIOModule> potentialModules = getPotentialModules();
//Check that any singular module can cover the nessessary io
foreach (TECIOModule module in potentialModules)
{
if (module.IOCollection.Contains(io))
{
return new List <TECIOModule>()
{
module
}
}
;
}
//List of modules to return
List <TECIOModule> returnModules = new List <TECIOModule>();
foreach (TECIO type in io.ToList())
{
TECIO singularIO = new TECIO(type);
singularIO.Quantity = 1;
//Add the modules that contains the IOType we're checking
foreach (TECIOModule module in potentialModules)
{
if (module.IOCollection.Contains(singularIO))
{
returnModules.Add(module);
//If return modules satisfies our IO, return them
if (returnModules.ToIOCollection().Contains(io))
{
return(returnModules);
}
}
}
}
return(new List <TECIOModule>());
}
public bool Contains(IEnumerable <TECIO> io)
{
//Normalize collections
IOCollection thisCollection = new IOCollection(this);
IOCollection ioCollection = new IOCollection(io);
foreach (TECIO ioToCheck in ioCollection.ToList())
{
if (!thisCollection.Remove(ioToCheck))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Gives the intersection of the left and right IOCollections
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns>The intersection</returns>
public static IOCollection operator |(IOCollection left, IOCollection right)
{
IOCollection intersection = new IOCollection();
foreach (TECIO leftIO in left.ToList())
{
foreach (TECIO rightIO in right.ToList())
{
if (leftIO.Type == rightIO.Type && leftIO.Protocol == rightIO.Protocol)
{
intersection.Add(leftIO.Quantity < rightIO.Quantity ? leftIO : rightIO);
}
}
}
return(intersection);
}
private IOCollection getInitialIO()
{
IOCollection io = new IOCollection();
TECIO ui = new TECIO(IOType.UI);
ui.Quantity = 100;
io.Add(ui);
TECIO uo = new TECIO(IOType.UO);
uo.Quantity = 100;
io.Add(uo);
foreach (TECProtocol prot in this.catalogs.Protocols)
{
io.Add(prot);
}
return(io);
}
/// <summary>
/// Returns non actualized but potential IO. All IO compatible with the controller type that doesn't exist on this controller.
/// </summary>
private IOCollection getPotentialIO()
{
IOCollection potentialIO = new IOCollection();
foreach (TECIOModule module in this.Type.IOModules)
{
potentialIO.Add(module.IO);
}
foreach (TECIOModule module in this.IOModules)
{
if (!potentialIO.Remove(module.IO))
{
throw new Exception("Controller has incompatible IO with its controller type.");
}
}
return(potentialIO);
}
public override IControllerConnection Connect(IConnectable connectable, IProtocol protocol)
{
IOCollection connectionIO = protocol is TECProtocol ? new IOCollection(protocol as TECProtocol) : new IOCollection(connectable.HardwiredIO);
if (this.ChildrenConnections.OfType <TECNetworkConnection>().Any(x => x.Protocol == protocol))
{
return(base.Connect(connectable, protocol));
}
else if (base.AvailableIO.Contains(connectionIO))
{
return(base.Connect(connectable, protocol));
}
else
{
var modulesToAdd = getModulesForIO(connectionIO);
if (modulesToAdd.Count == 0)
{
return(null);
}
modulesToAdd.ForEach(x => this.AddModule(x));
return(base.Connect(connectable, protocol));;
}
}
public bool Remove(IOCollection ioCollection)
{
return(this.Remove(ioCollection.ToList()));
}
public bool Contains(IOCollection io)
{
return(this.Contains(io.ToList()));
}
public IOCollection(IOCollection collection) : this()
{
Add(collection.ToList());
}
/// <summary>
/// Copy constructor for TECFBOController
/// </summary>
/// <param name="controllerSource"></param>
/// <param name="guidDictionary"></param>
public TECFBOController(TECFBOController controllerSource, Dictionary <Guid, Guid> guidDictionary = null) : base(controllerSource, guidDictionary)
{
this.catalogs = controllerSource.catalogs;
this.IO = getInitialIO();
this.Points.CollectionChanged += pointsCollectionChanged;
}
/// <summary>
/// General constructor for TECFBOController.
/// </summary>
/// <param name="guid"></param>
public TECFBOController(Guid guid, TECCatalogs catalogs) : base(guid)
{
this.catalogs = catalogs;
this.IO = getInitialIO();
this.Points.CollectionChanged += pointsCollectionChanged;
}