public WINConnection findOrInsertConnectionWithProperties(IdGenerator idGen, PropertyObject prop)
{
//the very first thing we must do, is attempt to find our object
//in order to do this, we need a uniqueID to find, and a neuronType
//we assume both of these are provided
WINConnection conn = findWINConnection(prop);
//we found it, then return it if you don't mind
if (conn != null)
{
return(conn);
}
//we weren't able to find the node, now we must create it and return it (since we are find or insert!)
//this should create the appropriate ID for this object
conn = createWINConnection(prop);
//now we should take into account that our idGenerator needs to know about new innovations
idGen.mostRecentInnovationID(conn.UniqueID);
//might want this to be async in the future, but for now we make it synchronous
//property objects should have everything we need to identify the WINNode
return(conn);
}
private string tryGetValue(string key, PropertyObject prop)
{
string val;
prop.TryGetValue(key, out val);
return(val);
}
private long tryGetLong(string valString, PropertyObject prop)
{
string val = tryGetValue(valString, prop);
if (val != null)
{
return(long.Parse(val));
}
else
{
return(-1);
}
}
private NeuronType tryGetNeuronType(PropertyObject prop)
{
string val = tryGetValue(WINObject.SUniqueString, prop);
if (val != null)
{
return((NeuronType)Enum.Parse(typeof(NeuronType), val));
}
else
{
return(NeuronType.Undefined);
}
}
private double tryGetDouble(string valString, PropertyObject prop)
{
string val = tryGetValue(valString, prop);
if (val != null)
{
return(double.Parse(val));
}
else
{
return(-1);
}
}
//uniqueID and neuronType are assumed here!
/// <summary>
/// We are trying to find a node here. For now, we just check our local cache. In real WIN, we'll check against the database of entries.
/// </summary>
/// <param name="prop"></param>
/// <returns></returns>
public WINNode findWINNode(PropertyObject prop)
{
long uniqueID = tryGetUnique(prop);
NeuronType neuronType = tryGetNeuronType(prop);
WINNode node;
if (winNodes.TryGetValue(nodeKey(uniqueID, neuronType), out node))
{
return(node);
}
return(null);
}
public WINConnection createWINConnection(PropertyObject prop, IdGenerator idGen = null)
{
WINConnection conn;
lock (winConnections)
{
//here we would head out to the server, and get a newly created connection, since we couldn't find one
//call the server and get back our new unique id AND object, instead, we'll generate it ourselves for now
long uniqueID = tryGetUnique(prop);
if (uniqueID == -1)
{
uniqueID = nextConnectionUniqueID();
}
//if we have sent in an idgenerator, we should update the object with our nextID object
if (idGen != null)
{
idGen.mostRecentInnovationID(uniqueID);
}
//parse out our source and target, which are obviously required for creating a connection
long sourceID = tryGetSourceID(prop);
long targetID = tryGetTargetID(prop);
//double weight = tryGetDouble(WINConnection.SWeight, prop);
//need to return a WINNode object
conn = new WINConnection()
{
//Parsed the source and target, which are required
SourceID = sourceID,
TargetID = targetID,
//Weight = weight,
//set the parameters for posterity, this might be unncessary
Parameters = prop,
//set the uniqueID, which should be passed in
UniqueID = uniqueID
};
//temporarily cache this information, duh!
//also, we use a combination of our uniqueID and nodetype to create a unique string
//when we move to databases, this won't matter as much since we will query all properties at the same time
winConnections.Add(connectionKey(conn.SourceID, conn.TargetID), conn);
}
//then send it back
return(conn);
}
public WINConnection findWINConnection(PropertyObject prop)
{
//we have three uniquely defining properties, the unique id, the source and the target
//really, any connection that connects a unique source and target should be enough to define it. The unique ID should shortcut
//the search process
//long uniqueID = tryGetUnique(prop);
long sourceID = tryGetSourceID(prop);
long targetID = tryGetTargetID(prop);
WINConnection conn;
if (winConnections.TryGetValue(connectionKey(sourceID, targetID), out conn))
{
return(conn);
}
return(null);
}
public WINNode createWINNode(PropertyObject prop, IdGenerator idGen = null)
{
WINNode node;
lock (winNodes)
{
//here we would head out to the server, and get a new created node, since we couldn't find one
//call the server and get back our new unique id AND object, instead, we'll generate it ourselves for now
long uniqueID = tryGetUnique(prop);
if (uniqueID == -1)
{
uniqueID = nextNodeUniqueID();
}
//if we have sent in an idgenerator, we should update the object with our nextID object
if (idGen != null)
{
idGen.mostRecentInnovationID(uniqueID);
}
//Get our neurontype, which is assumed to have been sent in, it would be silly otherwise
NeuronType neuronType = tryGetNeuronType(prop);
//need to return a WINNode object
node = new WINNode()
{
//Parsed the neuron type before entering function, required
NodeType = neuronType,
//set the parameters for posterity, this might be unncessary
Parameters = prop,
//set the uniqueID, which should be passed in
UniqueID = uniqueID
};
//temporarily cache this information, duh!
//also, we use a combination of our uniqueID and nodetype to create a unique string
//when we move to databases, this won't matter as much since we will query all properties at the same time
winNodes.Add(nodeKey(node.UniqueID, node.NodeType), node);
}
//then send it back
return(node);
}
private long tryGetUnique(PropertyObject prop)
{
return(tryGetLong(WINObject.SUniqueString, prop));
}
private long tryGetTargetID(PropertyObject prop)
{
return(tryGetLong(WINConnection.STargetID, prop));
}
private long tryGetSourceID(PropertyObject prop)
{
return(tryGetLong(WINConnection.SSourceID, prop));
}
