public IEnumerable <RuleValidationMessage> Validate(T rule)
{
List <RuleValidationMessage> createRuleValidationMessages = new List <RuleValidationMessage>(0);
List <IInvariant <T> > createRuleInvariants = new List <IInvariant <T> >(0);
foreach (Type invariantType in this.InvariantTypes)
{
IInvariant <T> createRuleInvariant = this.invariantFactory.GetRuleInvariant(invariantType);
createRuleInvariants.Add(createRuleInvariant);
}
foreach (IInvariant <T> createRuleInvariant in createRuleInvariants)
{
InvariantResult invariantResult = createRuleInvariant.IsValid(rule);
if (!invariantResult.Valid)
{
foreach (string message in invariantResult.Messages)
{
createRuleValidationMessages.Add(new RuleValidationMessage
{
Code = invariantResult.Code,
Message = message
});
}
}
}
return(createRuleValidationMessages);
}
public void NeighboursInBlockForMultipleBondsIgnoringBondOrders()
{
string acpString = "C0C1C2C3C4 0:1(1),0:2(2),0:3(1),1:4(1),2:4(1),3:4(2)";
IAtomContainer ac = AtomContainerPrinter.FromString(acpString, builder);
AtomRefinable refinable = new AtomRefinable(ac, false, true);
IInvariant invariant = refinable.NeighboursInBlock(Set(1, 2), 0);
Assert.IsTrue(invariant is IntegerInvariant);
Assert.AreEqual(new IntegerInvariant(2), invariant);
}
public void NeighboursInBlockForSingleBonds()
{
string acpString = "C0C1C2C3 0:1(1),0:3(1),1:2(1),2:3(1)";
IAtomContainer ac = AtomContainerPrinter.FromString(acpString, builder);
AtomRefinable refinable = new AtomRefinable(ac);
IInvariant invariant = refinable.NeighboursInBlock(Set(0, 2), 1);
Assert.IsTrue(invariant is IntegerInvariant);
Assert.AreEqual(new IntegerInvariant(2), invariant);
}
public InvariantLawsTests(IInvariant <TF> invariant, IEqK <TF> eqK)
{
var invariantLaws = new InvariantLaws <TF>(invariant);
Add("Invariant Identity", args =>
invariantLaws.InvariantIdentity(args.LiftedA).Holds(eqK));
Add("Invariant Composition", args =>
invariantLaws
.InvariantComposition(args.LiftedA, args.FuncAtoB, args.FuncBtoA, args.FuncBtoC, args.FuncCtoB)
.Holds(eqK));
}
/// <summary>
/// Initializes a new instance of the <see cref="VarianceExample"/> class.
/// </summary>
/// <param name="orangeInvariant">An interface with an invariant type of
/// <see cref="Orange"/>.</param>
/// <param name="bananaCovariant">An interface with a covariant type of
/// <see cref="Banana"/>.</param>
/// <param name="fruitContravariant">An interface with a contravariant type of
/// <see cref="Fruit"/>.</param>
/// <exception cref="ArgumentNullException"><paramref name="orangeInvariant"/>,
/// <paramref name="bananaCovariant"/>, or <paramref name="fruitContravariant"/> is
/// <see langword="null"/>.</exception>
public VarianceExample(
IInvariant <Orange> orangeInvariant,
ICovariant <Banana> bananaCovariant,
IContravariant <Fruit> fruitContravariant)
{
ParameterValidation.IsNotNull(orangeInvariant, nameof(orangeInvariant));
ParameterValidation.IsNotNull(bananaCovariant, nameof(bananaCovariant));
ParameterValidation.IsNotNull(fruitContravariant, nameof(fruitContravariant));
this.orangeInvariantInterface = orangeInvariant;
this.bananaCovariantInterface = bananaCovariant;
this.fruitContravariantInterface = fruitContravariant;
}
public int CompareTo(IInvariant o)
{
int[] other = ((IntegerListInvariant)o).values;
for (int index = 0; index < values.Length; index++)
{
if (values[index] > other[index])
{
return(-1);
}
else if (values[index] < other[index])
{
return(1);
}
else
{
continue;
}
}
return(0);
}
public InvariantLaws(IInvariant <TF> invariant) => _invariant = invariant;
public void M(IInvariant <object> v)
{ /* ... */
}
static void Main(string[] args)
{
//
// 1. 다형성
//
// 좌측 = 우측
// 생성 타입 | 부모 타입 = 생성 타입
//
string s = "Hello";
object o = s; // 부모 타입
Level2 l22 = new Level2(); // 같은 타입(불변)
Level1 l12 = new Level2(); // 부모 타입
//Level3 l32 = new Level2(); // 자식 타입, 에러
//
// 2. Generic 불변성
//
IEnumerable <Level2> y = null;
Dictionary <Level2, Level2> x = null;
List <Level2> values22 = new List <Level2>(); // 같은 타입
//List<Level1> values12 = new List<Level2>(); // 부모 타입, 에러
//List<Level3> values32 = new List<Level2>(); // 자식 타입, 에러
IInvariant <Level2> valuei22 = null;
IInvariant <Level2> i22 = valuei22; // 같은 타입
//IInvariant<Level1> i12 = valuei22; // 부모 타입, 에러
//IInvariant<Level3> i32 = valuei22; // 자식 타입, 에러
//
// 3. Generic 공변성
//
// Level1 → IWriteOnlyRepo<Level1>
// ↑ ↑
// Level2 → IWriteOnlyRepo<Level2>
//
IReadOnlyRepo <Level2> out22 = null;
IReadOnlyRepo <Level2> wo22 = out22; // 같은 타입
IReadOnlyRepo <Level1> wo12 = out22; // 부모 타입
//IWriteOnlyRepo<Level3> wo32 = out22; // 자식 타입, 에러
Func <Level2> fun22 = Program.Fun; // 같은 타입
Func <Level1> fun12 = Program.Fun; // 부모 타입
//Func<Level3> fun32 = Program.Fun; // 자식 타입, 에러
//
// 4. Generic 반공변성(상속 관계가 역전된다)
//
// Level2 ↘ IWriteOnlyRepo<Level3>
// ↑ ↑
// Level3 ↗ IWriteOnlyRepo<Level2>
//
//
IWriteOnlyRepo <Level2> in22 = null;
IWriteOnlyRepo <Level2> ro22 = in22; // 같은 타입
//IReadOnlyRepo<Level1> ro12 = in22; // 부모 타입, 에러
IWriteOnlyRepo <Level3> ro31 = in22; // 자식 타입
Action <Level2> a22 = Program.Act; // 같은 타입
//Action<Level1> a12 = Program.Act; // 부모 타입, 에러
Action <Level3> a32 = Program.Act; // 자식 타입
}
public int CompareTo(IInvariant o)
{
return(value.CompareTo(((IntegerInvariant)o).value));
}
public static ValidationResult ToValidationResult <T>(this IInvariant <T> source) => new ValidationResult(source.Error);
