| public static buildDevice ( Device, device ) : Device, | ||
| device | Device, | |
| return | Device, | |
public override AddingResult askAddDevice(Device device, bool reportToRedMetrics = false)
{
if (device == null)
{
Logger.Log("Equipment::askAddDevice device == null", Logger.Level.WARN);
return(AddingResult.FAILURE_DEFAULT);
}
Device copy = Device.buildDevice(device);
if (copy == null)
{
Logger.Log("Equipment::askAddDevice copy == null", Logger.Level.WARN);
return(AddingResult.FAILURE_DEFAULT);
}
//TODO test BioBricks equality (cf next line)
if (_devices.Exists(d => d.Equals(copy)))
//if(_devices.Exists(d => d.getInternalName() == copy.getInternalName()))
{
Logger.Log("Equipment::askAddDevice device already present", Logger.Level.INFO);
return(AddingResult.FAILURE_SAME_DEVICE);
}
_devices.Add(copy);
safeGetDisplayer().addEquipedDevice(copy);
addToReactionEngine(copy);
return(AddingResult.SUCCESS);
}
private void addDevice(Device device)
{
Logger.Log("Inventory::addDevice(" + device + "), count before=" + _devices.Count, Logger.Level.TRACE);
Device copy = Device.buildDevice(device);
if (device == null)
{
Logger.Log("Inventory::addDevice device==null", Logger.Level.WARN);
return;
}
string displayerString = _displayer != null ? "name=" + _displayer.name : "null";
Logger.Log("Inventory::addDevice(" + device + ")"
+ ", copy=" + copy
+ ", count before=" + _devices.Count
+ ", _devices=" + _devices
+ ", _displayer=" + displayerString
, Logger.Level.TRACE
);
_devices.Add(copy);
Logger.Log("Inventory::addDevice _devices.Add(copy); done", Logger.Level.TRACE);
_displayer.addInventoriedDevice(copy);
Logger.Log("Inventory::addDevice(" + device + "), count after=" + _devices.Count, Logger.Level.TRACE);
if (animator.isPlaying == false)
{
_deviceAdded = true;
animator.Play();
}
}
protected override DNABit produceDNABit()
{
LinkedList <BioBrick> deviceBricks = new LinkedList <BioBrick>();
string[] bricks = new string[] { promoterName, rbsName, geneName, terminatorName };
foreach (string brickName in bricks)
{
BioBrick brick = AvailableBioBricksManager.get().getBioBrickFromAll(brickName);
if (brick != null)
{
deviceBricks.AddLast(brick);
}
else
{
Logger.Log("PickableDeviceRef4Bricks::produceDNABit failed to add brick with name " + brickName + "!", Logger.Level.WARN);
}
}
if (ExpressionModule.isBioBricksSequenceValid(deviceBricks))
{
ExpressionModule deviceModule = new ExpressionModule(deviceName, deviceBricks);
LinkedList <ExpressionModule> deviceModules = new LinkedList <ExpressionModule>();
deviceModules.AddLast(deviceModule);
Device result = Device.buildDevice(deviceName, deviceModules);
return(result);
}
else
{
Logger.Log("PickableDeviceRef4Bricks::produceDNABit failed to produce DNABit - BioBrick sequence is incorrect: list=" + Logger.ToString <BioBrick>(deviceBricks), Logger.Level.WARN);
return(null);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// utilities
private Device getDeviceFromBricks(LinkedList <BioBrick> bricks)
{
Logger.Log("CraftZoneManager::getDeviceFromBricks(" + Logger.ToString <BioBrick>(bricks) + ")", Logger.Level.TRACE);
if (!ExpressionModule.isBioBricksSequenceValid(bricks))
{
Logger.Log("CraftZoneManager::getDeviceFromBricks invalid biobricks sequence", Logger.Level.TRACE);
return(null);
}
ExpressionModule module = new ExpressionModule("test", bricks);
LinkedList <ExpressionModule> modules = new LinkedList <ExpressionModule>();
modules.AddLast(module);
Device device = Device.buildDevice(modules);
if (device != null)
{
Logger.Log("CraftZoneManager::getDeviceFromBricks produced " + device, Logger.Level.TRACE);
}
else
{
Logger.Log("CraftZoneManager::getDeviceFromBricks device==null with bricks=" + Logger.ToString <BioBrick>(bricks)
, Logger.Level.WARN);
}
return(device);
}
public static void Initialize(
DisplayedDevice displayedDeviceScript
, Device device
, DevicesDisplayer devicesDisplayer
, DevicesDisplayer.DeviceType deviceType
)
{
if (device == null)
{
Logger.Log("DisplayedDevice::Initialize device==null", Logger.Level.WARN);
}
Logger.Log("DisplayedDevice::Initialize(" + displayedDeviceScript + ", " + device + ", " + devicesDisplayer + ", " + deviceType + ") starts", Logger.Level.DEBUG);
displayedDeviceScript._device = Device.buildDevice(device);
if (displayedDeviceScript._device == null)
{
Logger.Log("DisplayedDevice::Initialize _device==null", Logger.Level.WARN);
}
Logger.Log("DisplayedDevice::Create built device " + displayedDeviceScript._device + " from " + device, Logger.Level.TRACE);
if (_devicesDisplayer == null)
{
_devicesDisplayer = DevicesDisplayer.get();
}
displayedDeviceScript._deviceType = deviceType;
Logger.Log("DisplayedDevice::Initialize ends", Logger.Level.TRACE);
}
private Device getTestDevice(string name)
{
Logger.Log("Inventory::getTestDevice()", Logger.Level.TRACE);
Device testDevice = Device.buildDevice(
name,
getTestBeta(),
getTestFormula(),
getTestRBS(),
getTestProtein(),
getTestTerminator()
);
Logger.Log("Inventory::getTestDevice() testDevice=" + testDevice, Logger.Level.TRACE);
return(testDevice);
}
protected override DNABit produceDNABit()
{
PromoterBrick prom = new PromoterBrick("PromY2", 75f, "[0.01,2]Y");
RBSBrick rbs = new RBSBrick("RBS3", 3.0f);
GeneBrick gene = new GeneBrick("MOV", "MOV");
TerminatorBrick term = new TerminatorBrick("T1", 1.0f);
LinkedList <BioBrick> bricks = new LinkedList <BioBrick>(new List <BioBrick>()
{
prom, rbs, gene, term
});
ExpressionModule module = new ExpressionModule("expr", bricks);
return(Device.buildDevice("DEV", new LinkedList <ExpressionModule>(new List <ExpressionModule>()
{
module
})));
}
public void randomRename()
{
Logger.Log("CraftFinalizer::randomRename", Logger.Level.TRACE);
Device currentDevice = _craftZoneManager.getCurrentDevice();
string newName = Inventory.get().getAvailableDeviceDisplayedName();
Device newDevice = Device.buildDevice(newName, currentDevice.getExpressionModules());
if (newDevice != null)
{
Logger.Log("CraftFinalizer::randomRename _craftZoneManager.setDevice(" + newDevice + ")", Logger.Level.TRACE);
_craftZoneManager.setDevice(newDevice);
}
else
{
Logger.Log("CraftFinalizer::randomRename failed Device.buildDevice(name=" + newName
+ ", modules=" + Logger.ToString <ExpressionModule>(currentDevice.getExpressionModules()) + ")", Logger.Level.WARN);
}
}
protected override DNABit produceDNABit()
{
PromoterBrick prom = new PromoterBrick(promoterName, promoterBeta, promoterFormula);
RBSBrick rbs = new RBSBrick(rbsName, rbsFactor);
GeneBrick gene = new GeneBrick(geneName, geneProteinName);
TerminatorBrick term = new TerminatorBrick(terminatorName, terminatorFactor);
LinkedList <BioBrick> bricks = new LinkedList <BioBrick>(new List <BioBrick>()
{
prom, rbs, gene, term
});
ExpressionModule module = new ExpressionModule(expressionModuleName, bricks);
Device result = Device.buildDevice(deviceName, new LinkedList <ExpressionModule>(new List <ExpressionModule>()
{
module
}));
return(result);
}
//helper for simple devices
public static Device buildDevice(string name,
float beta, //promoter
string formula, //promoter
float rbsFactor, //rbs
string proteinName, //gene
float terminatorFactor //terminator
)
{
string nullName = (name == null)?"(null)":"";
Logger.Log("Device::buildDevice(name=" + name + nullName
+ ", beta=" + beta
+ ", formula='" + formula
+ "', rbsFactor=" + rbsFactor
+ ", proteinName=" + proteinName
+ ", terminatorFactor=" + terminatorFactor
+ ") starting...", Logger.Level.TRACE);
string notNullName = name;
if (notNullName == null)
{
notNullName = "device" + _idCounter;
}
BioBrick[] bioBrickArray =
{
new PromoterBrick(notNullName + "_promoter", beta, formula),
new RBSBrick(notNullName + "_rbs", rbsFactor),
new GeneBrick(notNullName + "_gene", proteinName),
new TerminatorBrick(notNullName + "_terminator", terminatorFactor)
};
LinkedList <BioBrick> bricks = new LinkedList <BioBrick>(bioBrickArray);
ExpressionModule[] modulesArray = { new ExpressionModule(notNullName + "_module", bricks) };
LinkedList <ExpressionModule> modules = new LinkedList <ExpressionModule>(modulesArray);
return(Device.buildDevice(notNullName, modules));
}
public LinkedList <Device> loadDevicesFromFile(string filePath)
{
Logger.Log("DeviceLoader::loadDevicesFromFile(" + filePath + ")", Logger.Level.INFO);
LinkedList <Device> resultDevices = new LinkedList <Device>();
XmlDocument xmlDoc = Tools.getXmlDocument(filePath);
XmlNodeList deviceList = xmlDoc.GetElementsByTagName(BioBricksXMLTags.DEVICE);
reinitVars();
foreach (XmlNode deviceNode in deviceList)
{
try
{
deviceName = deviceNode.Attributes[BioBricksXMLTags.ID].Value;
}
catch (NullReferenceException exc)
{
Logger.Log("DeviceLoader::loadDevicesFromFile bad xml, missing field \"id\"\n" + exc, Logger.Level.WARN);
continue;
}
catch (Exception exc)
{
Logger.Log("DeviceLoader::loadDevicesFromFile failed, got exc=" + exc, Logger.Level.WARN);
continue;
}
Logger.Log("DeviceLoader::loadDevicesFromFile got id=" + deviceName
, Logger.Level.TRACE);
bool processSuccess = true;
if (checkString(deviceName))
{
// processes longer grammars that use explicit brick nodes names
if (0 != deviceNode.ChildNodes.Count)
{
foreach (XmlNode attr in deviceNode)
{
if (attr.Name == BioBricksXMLTags.BIOBRICK)
{
//find brick in existing bricks
string brickName = attr.Attributes[BioBricksXMLTags.ID].Value;
if (!processBrick(brickName, filePath))
{
// processes even longer grammar that uses explicit brick description
// because the brick wasn't found neither in 'available' nor 'all' biobricks lists
brick = bLoader.loadBioBrick(attr);
if (null != brick)
{
AvailableBioBricksManager.get().addAvailableBioBrick(brick);
deviceBricks.AddLast(brick);
}
else
{
processSuccess = false;
break;
}
}
}
else
{
Logger.Log("DeviceLoader::loadDevicesFromFile unknown attr " + attr.Name, Logger.Level.WARN);
}
}
}
else
{
// processes shortened grammar that uses only device name
foreach (string brickName in deviceName.Split(':'))
{
if (!processBrick(brickName, filePath))
{
processSuccess = false;
break;
}
}
}
if (processSuccess)
{
ExpressionModule deviceModule = new ExpressionModule(deviceName, deviceBricks);
LinkedList <ExpressionModule> deviceModules = new LinkedList <ExpressionModule>();
deviceModules.AddLast(deviceModule);
device = Device.buildDevice(deviceName, deviceModules);
if (device != null)
{
resultDevices.AddLast(device);
}
}
}
else
{
Logger.Log("DeviceLoader::loadDevicesFromFile Error : missing attribute id in Device node", Logger.Level.WARN);
}
reinitVars();
}
return(resultDevices);
}
