public IOverlapRemovalParameters CreateParameters(string algorithmType, IOverlapRemovalParameters oldParameters)
{
switch (algorithmType)
{
case "FSA":
return(oldParameters as OverlapRemovalParameters == null
? new OverlapRemovalParameters()
: (IOverlapRemovalParameters)(oldParameters as OverlapRemovalParameters).Clone());
/*case "OneWayFSA":
* return ( oldParameters as OneWayFSAParameters ) == null
* ? new OneWayFSAParameters()
* : (IOverlapRemovalParameters)oldParameters.Clone();*/
default:
return(null);
}
}
/// <inheritdoc />
public IOverlapRemovalParameters CreateParameters(string algorithmType, IOverlapRemovalParameters parameters)
{
if (algorithmType is null)
{
throw new ArgumentNullException(nameof(algorithmType));
}
switch (algorithmType)
{
case FSAAlgorithm:
return(parameters.CreateNewParameters <OverlapRemovalParameters>());
case OneWayFSAAlgorithm:
return(parameters.CreateNewParameters <OneWayFSAParameters>());
}
return(null);
}
/// <inheritdoc />
public IOverlapRemovalAlgorithm <TVertex> CreateAlgorithm(
string algorithmType,
IOverlapRemovalContext <TVertex> context,
IOverlapRemovalParameters parameters)
{
if (algorithmType is null)
{
throw new ArgumentNullException(nameof(algorithmType));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (parameters is null)
{
throw new ArgumentNullException(nameof(parameters));
}
switch (algorithmType)
{
case FSAAlgorithm:
return(new FSAAlgorithm <TVertex>(context.Rectangles, parameters));
case OneWayFSAAlgorithm:
{
if (parameters is OneWayFSAParameters oneWayFSAParams)
{
return(new OneWayFSAAlgorithm <TVertex>(context.Rectangles, oneWayFSAParams));
}
throw new ArgumentException(
$"Must use {nameof(OneWayFSAParameters)} to create a {nameof(OneWayFSAAlgorithm<object>)} algorithm.",
nameof(parameters));
}
default:
return(null);
}
}
public TestFSAAlgorithm(
[NotNull] IDictionary <int, Rect> rectangles,
[NotNull] IOverlapRemovalParameters parameters)
: base(rectangles, parameters)
{
}
public IOverlapRemovalAlgorithm <TVertex> CreateAlgorithm(string newAlgorithmType, IOverlapRemovalContext <TVertex> context, IOverlapRemovalParameters parameters)
{
if (context == null || context.Rectangles == null)
{
return(null);
}
switch (newAlgorithmType)
{
case "FSA":
return(new FSAAlgorithm <TVertex>(context.Rectangles, parameters));
case "OneWayFSA":
return(new OneWayFSAAlgorithm <TVertex>(context.Rectangles, parameters as OneWayFSAParameters));
default:
return(null);
}
}
public FSAAlgorithm(IDictionary <TObject, Rect> rectangles, IOverlapRemovalParameters parameters)
: base(rectangles, parameters)
{
}
/// <summary>
/// Create and initialize overlap removal algorithm
/// </summary>
/// <param name="newAlgorithmType">Algorithm type</param>
/// <param name="rectangles">Object sizes list</param>
/// <param name="parameters">Optional algorithm parameters</param>
public IOverlapRemovalAlgorithm <TVertex> CreateOverlapRemovalAlgorithm(OverlapRemovalAlgorithmTypeEnum newAlgorithmType, IDictionary <TVertex, Rect> rectangles, IOverlapRemovalParameters parameters = null)
{
//if (Rectangles == null) return null;
if (parameters == null)
{
parameters = CreateOverlapRemovalParameters(newAlgorithmType);
}
switch (newAlgorithmType)
{
case OverlapRemovalAlgorithmTypeEnum.FSA:
return(new FSAAlgorithm <TVertex>(rectangles, parameters is OverlapRemovalParameters ? parameters : new OverlapRemovalParameters()));
case OverlapRemovalAlgorithmTypeEnum.OneWayFSA:
return(new OneWayFSAAlgorithm <TVertex>(rectangles, parameters is OneWayFSAParameters ? parameters as OneWayFSAParameters : new OneWayFSAParameters()));
default:
return(null);
}
}
public void StandardFactory()
{
var rectangles = new Dictionary <int, Rect>();
var context = new TestOverlapRemovalContext(rectangles);
var factory = new StandardOverlapRemovalAlgorithmFactory <int>();
CollectionAssert.AreEqual(new[] { "FSA", "OneWayFSA" }, factory.AlgorithmTypes);
Assert.IsNull(
factory.CreateAlgorithm(
string.Empty,
context,
new OverlapRemovalParameters()));
Assert.IsInstanceOf <FSAAlgorithm <int> >(
factory.CreateAlgorithm(
"FSA",
context,
new OverlapRemovalParameters()));
Assert.IsInstanceOf <OneWayFSAAlgorithm <int> >(
factory.CreateAlgorithm(
"OneWayFSA",
context,
new OneWayFSAParameters()));
var fsaParameters = new OverlapRemovalParameters();
IOverlapRemovalParameters createdParameters = factory.CreateParameters(string.Empty, fsaParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("fsa", fsaParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("FSA", fsaParameters);
Assert.IsInstanceOf <OverlapRemovalParameters>(createdParameters);
Assert.AreNotSame(fsaParameters, createdParameters);
createdParameters = factory.CreateParameters("FSA", null);
Assert.IsInstanceOf <OverlapRemovalParameters>(createdParameters);
Assert.AreNotSame(fsaParameters, createdParameters);
var oneWayFSAParameters = new OneWayFSAParameters();
createdParameters = factory.CreateParameters("OneWayFSA", oneWayFSAParameters);
Assert.IsInstanceOf <OneWayFSAParameters>(createdParameters);
Assert.AreNotSame(oneWayFSAParameters, createdParameters);
createdParameters = factory.CreateParameters("OneWayFSA", null);
Assert.IsInstanceOf <OneWayFSAParameters>(createdParameters);
Assert.AreNotSame(oneWayFSAParameters, createdParameters);
createdParameters = factory.CreateParameters("OneWayFSA", fsaParameters);
Assert.IsInstanceOf <OneWayFSAParameters>(createdParameters);
Assert.AreNotSame(fsaParameters, createdParameters);
Assert.AreNotSame(oneWayFSAParameters, createdParameters);
Assert.IsFalse(factory.IsValidAlgorithm(null));
Assert.IsFalse(factory.IsValidAlgorithm(string.Empty));
Assert.IsTrue(factory.IsValidAlgorithm("FSA"));
Assert.IsTrue(factory.IsValidAlgorithm("OneWayFSA"));
Assert.IsFalse(factory.IsValidAlgorithm("fsa"));
var algorithm1 = new FSAAlgorithm <int, OverlapRemovalParameters>(rectangles, new OverlapRemovalParameters());
Assert.IsEmpty(factory.GetAlgorithmType(algorithm1));
var algorithm2 = new FSAAlgorithm <int>(rectangles, new OverlapRemovalParameters());
Assert.AreEqual("FSA", factory.GetAlgorithmType(algorithm2));
var algorithm3 = new OneWayFSAAlgorithm <int>(rectangles, new OneWayFSAParameters());
Assert.AreEqual("OneWayFSA", factory.GetAlgorithmType(algorithm3));
}
public FSAAlgorithm(IDictionary <TObject, Rect> rectangles, IOverlapRemovalParameters parameters)
: base(rectangles, parameters)
{
Contract.Requires(rectangles != null);
}
