/// <summary>
/// Method to get a basic description of a given constraint for output.
/// </summary>
/// <param name="constraint">The Constraint which we want information about.</param>
/// <param name="export">The export we are matching the constraint against.</param>
/// <returns>A string providing some details about the given constraint.</returns>
private string GetConstraintString(IImportSatisfiabilityConstraint constraint, PartExport export)
{
if (constraint == null || export == null)
{
return(Strings.DoesNotExists);
}
string constraintString = constraint.ToString() !;
string actualValue = export.ToString() !;
// Try to treat the constraint as an indentity constraint
if (constraint is ExportTypeIdentityConstraint)
{
var identityConstraint = (ExportTypeIdentityConstraint)constraint;
constraintString = string.Format(
CultureInfo.CurrentCulture,
Strings.TypeFormat,
identityConstraint.TypeIdentityName);
actualValue = string.Format(
CultureInfo.CurrentCulture,
Strings.TypeFormat,
export.ExportingType);
}
else if (constraint is ExportMetadataValueImportConstraint)
{
// Try to treat the constraint as an metadata constraint
var metadataConstraint = (ExportMetadataValueImportConstraint)constraint;
var exportDetails = export.ExportDetails;
string keyName = metadataConstraint.Name;
constraintString = string.Format(
CultureInfo.CurrentCulture,
Strings.MetadataFormat,
keyName,
metadataConstraint.Value);
string pairValue = Strings.MissingKeyText;
if (exportDetails.Metadata.ContainsKey(keyName))
{
var keyValue = exportDetails.Metadata[keyName];
pairValue = keyValue != null?keyValue.ToString() !: Strings.DoesNotExists;
}
actualValue = string.Format(
CultureInfo.CurrentCulture,
Strings.MetadataFormat,
keyName,
pairValue);
}
// If it is neither just return the toString text of the two parameters
return(string.Format(
CultureInfo.CurrentCulture,
Strings.ExpectedFoundFormat,
constraintString,
actualValue));
}
public bool Equals(IImportSatisfiabilityConstraint obj)
{
var other = obj as ImportConstraint;
if (other == null)
{
return(false);
}
return(this.definition.Equals(other.definition));
}
public bool Equals(IImportSatisfiabilityConstraint obj)
{
var other = obj as ImportMetadataViewConstraint;
if (other == null)
{
return(false);
}
return(ByValueEquality.Dictionary <string, MetadatumRequirement>().Equals(this.Requirements, other.Requirements));
}
public bool Equals(IImportSatisfiabilityConstraint obj)
{
var other = obj as PartCreationPolicyConstraint;
if (other == null)
{
return(false);
}
return(this.RequiredCreationPolicy == other.RequiredCreationPolicy);
}
public bool Equals(IImportSatisfiabilityConstraint obj)
{
var other = obj as ExportTypeIdentityConstraint;
if (other == null)
{
return(false);
}
return(this.TypeIdentityName == other.TypeIdentityName);
}
public bool Equals(IImportSatisfiabilityConstraint obj)
{
var other = obj as ExportMetadataValueImportConstraint;
if (other == null)
{
return(false);
}
return(this.Name == other.Name &&
EqualityComparer <object> .Default.Equals(this.Value, other.Value));
}
private void Write(IImportSatisfiabilityConstraint importConstraint)
{
using (this.Trace(nameof(IImportSatisfiabilityConstraint)))
{
ConstraintTypes type;
if (importConstraint is ImportMetadataViewConstraint)
{
type = ConstraintTypes.ImportMetadataViewConstraint;
}
else if (importConstraint is ExportTypeIdentityConstraint)
{
type = ConstraintTypes.ExportTypeIdentityConstraint;
}
else if (importConstraint is PartCreationPolicyConstraint)
{
type = ConstraintTypes.PartCreationPolicyConstraint;
}
else if (importConstraint is ExportMetadataValueImportConstraint)
{
type = ConstraintTypes.ExportMetadataValueImportConstraint;
}
else
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Strings.ImportConstraintTypeNotSupported, importConstraint.GetType().FullName));
}
this.writer !.Write((byte)type);
switch (type)
{
case ConstraintTypes.ImportMetadataViewConstraint:
var importMetadataViewConstraint = (ImportMetadataViewConstraint)importConstraint;
this.WriteCompressedUInt((uint)importMetadataViewConstraint.Requirements.Count);
foreach (var item in importMetadataViewConstraint.Requirements)
{
this.Write(item.Key);
this.Write(item.Value.MetadatumValueTypeRef);
this.writer.Write(item.Value.IsMetadataumValueRequired);
}
break;
case ConstraintTypes.ExportTypeIdentityConstraint:
var exportTypeIdentityConstraint = (ExportTypeIdentityConstraint)importConstraint;
this.Write(exportTypeIdentityConstraint.TypeIdentityName);
break;
case ConstraintTypes.PartCreationPolicyConstraint:
var partCreationPolicyConstraint = (PartCreationPolicyConstraint)importConstraint;
this.Write(partCreationPolicyConstraint.RequiredCreationPolicy);
break;
case ConstraintTypes.ExportMetadataValueImportConstraint:
var exportMetadataValueImportConstraint = (ExportMetadataValueImportConstraint)importConstraint;
this.Write(exportMetadataValueImportConstraint.Name);
this.WriteObject(exportMetadataValueImportConstraint.Value);
break;
default:
throw Assumes.NotReachable();
}
}
}
public ImportDefinition AddExportConstraint(IImportSatisfiabilityConstraint constraint)
{
Requires.NotNull(constraint, nameof(constraint));
return(this.WithExportConstraints(this.exportConstraints.Add(constraint)));
}
