/// <summary>
/// Returns whether two connectors can be connected based on their data types
/// </summary>
/// <param name="source">The source.</param>
/// <returns>True if connector's types are compatible</returns>
/// <exception cref="System.NotImplementedException"></exception>
public bool CanConnectTo(IConnectorOut source)
{
if (source.DataType == NodeDataType.List && DataType == NodeDataType.String)
{
return false;
}
if (DataType == source.DataType || DataType == NodeDataType.String || DataType == NodeDataType.Field || DataType == NodeDataType.Object)
{
return true;
}
switch (source.DataType)
{
case NodeDataType.String:
return false;
case NodeDataType.Decimal:
return false;
case NodeDataType.Double:
return DataType == NodeDataType.Decimal;
case NodeDataType.DateTime:
return false;
case NodeDataType.Int:
case NodeDataType.Result:
return DataType == NodeDataType.Double || DataType == NodeDataType.Decimal;
case NodeDataType.Boolean:
return false;
case NodeDataType.SPCChart:
return false;
case NodeDataType.GageRR:
return false;
case NodeDataType.ChartType:
return false;
}
if (DataType == NodeDataType.String)
{
return true;
}
throw new NotImplementedException(string.Format("The conversion from {0} to {1} is not implemented", source.DataType, DataType));
}
/// <summary>
/// Determines whether the specified connectors can be connected.
/// </summary>
/// <param name="source">The source connector.</param>
/// <param name="destination">The destination connector.</param>
/// <returns>ConnectivityState</returns>
public ConnectivityState CanConnect(IConnectorOut source, IConnectorIn destination)
{
var destinationField = FindDestinationField(destination);
if (destinationField == null)
return ConnectivityState.Allow();
if (!IsAccessible(destinationField))
return ConnectivityState.Refuse(
string.Format(CultureInfo.InvariantCulture, "Field {0} is not accessible", destinationField.Name));
if (destinationField.DataType == NodeDataType.List || destinationField.DataType == NodeDataType.Array
|| destinationField.DataType == NodeDataType.FixedArray || destinationField.DataType == NodeDataType.Checklist
|| destinationField.DataType == NodeDataType.Sample)
return ConnectivityState.Allow();
return IsValidMapping(source, GetSourceContext((DestinationField)destinationField.ParentField))
? ConnectivityState.Allow()
: ConnectivityState.Refuse();
}
/// <summary>
/// Determines whether the specified connectors can be connected.
/// </summary>
/// <param name="source">The source connector.</param>
/// <param name="destination">The destination connector.</param>
/// <returns>Returns <c>true</c> if the specified connectors can be connected; otherwise, <c>false</c>.</returns>
public ConnectivityState CanConnect(IConnectorOut source, IConnectorIn destination)
{
var sourceOwner = source.Owner as SourceFieldList;
var destinationOwner = destination.Owner as DestinationFieldList;
if (sourceOwner == null || destinationOwner == null)
return ConnectivityState.Allow();
var sourceField = sourceOwner.GetAllFields().FirstOrDefault(f => f.ConnectorOut.Id == source.Id);
var destinationField = destinationOwner.GetAllFields().FirstOrDefault(f => f.ConnectorIn.Id == destination.Id);
if (sourceField == null || destinationField == null)
return ConnectivityState.Allow();
var result = ConnectivityState.Allow();
if (sourceField.DataType == NodeDataType.CrossReference &&
destinationField.DataType == NodeDataType.CrossReference)
{
result &= CrossRefFieldsAreCompatible(sourceField, destinationField);
}
return result;
}
/// <summary>
/// Finds the source field.
/// </summary>
/// <param name="fields">The fields.</param>
/// <param name="connector">The connector.</param>
/// <returns>SourceField.</returns>
private SourceField FindSourceField(IEnumerable<SourceField> fields, IConnectorOut connector)
{
foreach (var sourceField in fields)
{
if (sourceField.ConnectorOut == connector)
return sourceField;
var subfield = FindSourceField(sourceField.Subfields.Cast<SourceField>(), connector);
if (subfield != null)
return subfield;
}
return null;
}
/// <summary>
/// Finds the source field.
/// </summary>
/// <param name="connector">The connector.</param>
/// <returns>SourceField.</returns>
private SourceField FindSourceField(IConnectorOut connector)
{
var fieldList = connector.Owner as SourceFieldList;
if (fieldList == null)
return null;
return FindSourceField(fieldList.Fields, connector);
}
/// <summary>
/// Gets the source context.
/// </summary>
/// <param name="connector">The connector.</param>
/// <returns>SourceField.</returns>
private SourceField GetSourceContext(IConnectorOut connector)
{
return FindSourceField(connector);
}
/// <summary>
/// Determines whether [is valid mapping] [the specified field list].
/// </summary>
/// <param name="fieldList">The field list.</param>
/// <param name="connector">The connector.</param>
/// <param name="sourceContext">The source context.</param>
/// <returns><c>true</c> if [is valid mapping] [the specified field list]; otherwise, <c>false</c>.</returns>
private bool IsValidMapping(SourceFieldList fieldList, IConnectorOut connector, SourceField sourceContext)
{
var sourceField = FindSourceField(fieldList.Fields, connector);
if (sourceField == null)
return false;
return CanAccess(sourceField, sourceContext);
}
/// <summary>
/// Determines whether [is valid mapping] [the specified connector].
/// </summary>
/// <param name="connector">The connector.</param>
/// <param name="sourceContext">The source context.</param>
/// <returns><c>true</c> if [is valid mapping] [the specified connector]; otherwise, <c>false</c>.</returns>
private bool IsValidMapping(IConnectorOut connector, SourceField sourceContext)
{
if (connector.Owner is ConstantExpression)
return true;
var oneInOneOutExpression = connector.Owner as OneInOneOutExpression;
if (oneInOneOutExpression != null)
return IsValidMapping(oneInOneOutExpression, sourceContext);
var twoInOneOutExpression = connector.Owner as TwoInOneOutExpression;
if (twoInOneOutExpression != null)
return IsValidMapping(twoInOneOutExpression, sourceContext);
var threeInOneOutExpression = connector.Owner as ThreeInOneOutExpression;
if (threeInOneOutExpression != null)
return IsValidMapping(threeInOneOutExpression, sourceContext);
var fourInOneOutExpression = connector.Owner as FourInOneOutExpression;
if (fourInOneOutExpression != null)
return IsValidMapping(fourInOneOutExpression, sourceContext);
var fiveInOneOutExpression = connector.Owner as FiveInOneOutExpression;
if (fiveInOneOutExpression != null)
return IsValidMapping(fiveInOneOutExpression, sourceContext);
var sixInOneOutExpression = connector.Owner as SixInOneOutExpression;
if (sixInOneOutExpression != null)
return IsValidMapping(sixInOneOutExpression, sourceContext);
var sourceFieldList = connector.Owner as SourceFieldList;
if (sourceFieldList != null)
return IsValidMapping(sourceFieldList, connector, sourceContext);
var functionExpression = connector.Owner as FunctionExpression;
if (functionExpression != null)
return true;
return false;
}
/// <summary>
/// Determines whether the specified connectors can be connected.
/// </summary>
/// <param name="sourceConnector">The source connector.</param>
/// <param name="destinationConnector">The destination connector.</param>
/// <returns>The ConnectivityState.</returns>
public ConnectivityState CanConnect(IConnectorOut sourceConnector, IConnectorIn destinationConnector)
{
var expressionItems = new List<IExpressionObjectBase>();
ExpressionTranslator.TranslateToExpressionObjects(expressionItems, Diagram);
ExpressionNodeFactory.RestoreConnections(expressionItems);
if (sourceConnector != null && destinationConnector != null)
return ExpressionValidator.CanConnect(sourceConnector, destinationConnector);
return ConnectivityState.Refuse();
}
private Connection CreateConnection(IConnectorOut source, IConnectorIn sink)
{
return new Connection { Source = source, Sink = sink };
}
