/// <summary>
///
/// </summary>
/// <param name="nodes"></param>
/// <param name="groups"></param>
/// <param name="rawData">Represents the current contents of the file. Reference is not held. A copy is made.</param>
/// <param name="file"></param>
/// <param name="errors"></param>
/// <param name="datasource"></param>
/// <param name="serializer"></param>
/// <param name="nodeFactory"></param>
/// <param name="domainUsage"></param>
/// <param name="getDocumentSource"></param>
/// <param name="autoCompletePatterns"></param>
public DomainFile(IEnumerable <GraphAndUI <NodeUIData> > nodes, IEnumerable <NodeGroup> groups, MemoryStream rawData, Id <FileInProject> file, DocumentPath path, ReadOnlyCollection <LoadError> errors, DomainDomain datasource, ISerializer <TData> serializer, INodeFactory nodeFactory, Func <IDomainUsage <ConversationNode, TransitionNoduleUIInfo> > domainUsage, Func <IDynamicEnumParameter, object, DynamicEnumParameter.Source> getDocumentSource, IEnumerable <IAutoCompletePattern> autoCompletePatterns, UpToDateFile.BackEnd backEnd)
: base(nodes, groups, errors, nodeFactory, null, getDocumentSource, NoAudio.Instance)
{
Id = file;
m_file = new SaveableFileUndoable(rawData, path.FileInfo, SaveTo, backEnd);
m_domainUsage = domainUsage;
foreach (var node in m_nodes)
{
var n = node;
node.Modified += () => NodeModified(n);
node.Data.Linked += () => NodeLinked(n);
}
m_nodes.Inserting += (n) =>
{
AddToData(n.Data.Only(), m_datasource);
ConversationDomainModified.Execute(); //No need to be picky about false positives
n.Modified += () => NodeModified(n);
n.Data.Linked += () => NodeLinked(n);
};
m_nodes.Removing += RemoveFromData;
m_nodes.Clearing += ClearData; //Currently nothing clears the list
m_datasource = datasource;
//m_conversationDatasource = conversationDataSource;
m_serializer = serializer;
m_autoCompletePatterns = new List <IAutoCompletePattern>(autoCompletePatterns);
}
/// <summary>
/// Triggered when the set of linked nodes of 'node' changes. This includes unlinking as well as linking.
/// </summary>
private void NodeLinked(ConversationNode node)
{
Action <NodeTypeData> categoryAction = category => { }; //Can't link categories to anything
Action <IntegerData> integerAction = data => { }; //Can't link integer definitions to anything
Action <DecimalData> decimalAction = data => { }; //Can't link decimal definitions to anything
Action <LocalizedStringData> localizedStringAction = data => { }; //Can't link localized string definitions to anything
Action <DynamicEnumerationData> dynamicEnumAction = data => { }; //Can't link dynamic enum definitions to anything
Action <LocalDynamicEnumerationData> localDynamicEnumAction = data => { }; //Can't link local dynamic enum definitions to anything
Action <EnumerationData> enumAction = data =>
{
m_datasource.UpdateEnumeration(data);
//m_conversationDatasource.UpdateEnumeration(data);
};
Action <EnumerationData> enumValueAction = data => { }; //It's only possible to link to an enum definition and that's already handled by enumAction
Action <NodeData> nodeAction = data =>
{
//Doesn't affect the domain domain
//m_conversationDatasource.NodeDefinitionModified(data);
};
Action <ConnectorDefinitionData> connectorAction = data =>
{
m_datasource.ModifyConnector(data);
//update conversation datasource when connector definition is linked to a parameter
};
Action <ConnectionDefinitionData> connectionAction = data => { }; //Can't line connection definitions to anything
DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction);
ConversationDomainModified.Execute(); //No need to be picky about false positives
}
/// <summary>
/// Remove the node's content from the domain and conversation datasources.
/// </summary>
protected override void RemoveFromData(ConversationNode node)
{
Action <NodeTypeData> categoryAction = category =>
{
m_datasource.RemoveCategory(category.Guid);
//m_conversationDatasource.RemoveCategory(category.Guid);
};
Action <IntegerData> integerAction = data =>
{
m_datasource.RemoveType(BaseType.Integer, data.TypeId);
//m_conversationDatasource.RemoveType(data.TypeID);
};
Action <DecimalData> decimalAction = data =>
{
m_datasource.RemoveType(BaseType.Decimal, data.TypeId);
//m_conversationDatasource.RemoveType(data.TypeID);
};
Action <LocalizedStringData> localizedStringAction = data =>
{
m_datasource.RemoveType(BaseType.LocalizedString, data.TypeId);
};
Action <DynamicEnumerationData> dynamicEnumAction = data =>
{
m_datasource.RemoveType(BaseType.DynamicEnumeration, data.TypeId);
//m_conversationDatasource.RemoveType(data.TypeID);
};
Action <LocalDynamicEnumerationData> localDynamicEnumAction = data =>
{
m_datasource.RemoveType(BaseType.LocalDynamicEnumeration, data.TypeId);
//m_conversationDatasource.RemoveType(data.TypeID);
};
Action <EnumerationData> enumAction = data =>
{
m_datasource.RemoveType(BaseType.Enumeration, data.TypeId);
//m_conversationDatasource.RemoveType(data.TypeID);
};
Action <EnumerationData> enumValueAction = data =>
{
m_datasource.UpdateEnumeration(data);
//m_conversationDatasource.UpdateEnumeration(data);
};
Action <NodeData> nodeAction = data =>
{
//Doesn't affect domain domain
//m_conversationDatasource.RemoveNodeType(data.Guid);
};
Action <ConnectorDefinitionData> connectorAction = data =>
{
m_datasource.RemoveConnector(data);
//m_conversationDatasource.RemoveConnector(data.Id);
};
Action <ConnectionDefinitionData> connectionAction = data =>
{
//Doesn't affect domain domain
};
DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction);
ConversationDomainModified.Execute(); //No need to be picky about false positives
}
public void Removed()
{
ClearData();
ConversationDomainModified.Execute();
}
private void NodeModified(ConversationNode node)
{
Action <NodeTypeData> categoryAction = category =>
{
//m_conversationDatasource.RenameCategory(category);
m_datasource.RenameCategory(category.Name, category.Guid);
};
Action <IntegerData> integerAction = data =>
{
//m_conversationDatasource.ModifyIntegerType(data);
m_datasource.RenameType(BaseType.Integer, data.Name, data.TypeId);
};
Action <DecimalData> decimalAction = data =>
{
//m_conversationDatasource.ModifyDecimalType(data);
m_datasource.RenameType(BaseType.Decimal, data.Name, data.TypeId);
};
Action <LocalizedStringData> localizedStringAction = data =>
{
m_datasource.RenameType(BaseType.LocalizedString, data.Name, data.TypeId);
};
Action <DynamicEnumerationData> dynamicEnumAction = data =>
{
//There's no data that the conversation domain needs
m_datasource.RenameType(BaseType.DynamicEnumeration, data.Name, data.TypeId);
};
Action <LocalDynamicEnumerationData> localDynamicEnumAction = data =>
{
//There's no data that the conversation domain needs
m_datasource.RenameType(BaseType.LocalDynamicEnumeration, data.Name, data.TypeId);
};
Action <EnumerationData> enumAction = data =>
{
//No impact on the conversation datasource
m_datasource.RenameType(BaseType.Enumeration, data.Name, data.TypeId);
};
Action <EnumerationData> enumValueAction = data =>
{
//m_conversationDatasource.UpdateEnumeration(data);
m_datasource.UpdateEnumeration(data);
};
Action <NodeData> nodeAction = data =>
{
//m_conversationDatasource.NodeDefinitionModified(data);
//Doesn't affect the domain domain
};
Action <ConnectorDefinitionData> connectorAction = data =>
{
//Update conversation datasource?
m_datasource.ModifyConnector(data);
};
Action <ConnectionDefinitionData> connectionAction = data =>
{
//Doesn't affect the domain domain
};
if (m_datasource.IsConnector(node.Data.NodeTypeId))
{
var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ConnectorOutputDefinition.Id);
var nodes = nodeConnector.Connections.Select(c => c.Parent).Where(n => n.NodeTypeId == DomainIDs.NodeGuid);
DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction);
}
else if (m_datasource.IsParameter(node.Data.NodeTypeId))
{
var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ParameterOutputDefinition.Id);
var nodes = nodeConnector.Connections.Select(c => c.Parent).Where(n => n.NodeTypeId == DomainIDs.NodeGuid);
DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction);
}
else if (m_datasource.IsConfig(node.Data.NodeTypeId))
{
var nodeConnector = node.Data.Connectors.Single(c => c.Definition.Id == DomainIDs.ConfigOutputDefinition.Id);
var connected = nodeConnector.Connections.Select(c => c.Parent);
var nodes = connected.Where(n => n.NodeTypeId == DomainIDs.NodeGuid);
DomainDomain.ForEachNode(nodes, categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction);
//Don't currently need to handle parameter config affecting nodes
//var parameters = connected.Where(n => m_datasource.IsParameter(n.NodeTypeID));
//var nodes2 = parameters.SelectMany(p=>p.Connectors.Where(c=>c.m_definition.Id == DomainIDs.PARAMETER_OUTPUT_DEFINITION.Id))
//DomainDomain.ForEachNode
}
else
{
DomainDomain.ForEachNode(node.Only(), categoryAction, integerAction, decimalAction, localizedStringAction, dynamicEnumAction, localDynamicEnumAction, enumAction, enumValueAction, nodeAction, connectorAction, connectionAction);
}
ConversationDomainModified.Execute(); //No need to be picky about false positives
}
