Example #1
0
        public IEquivaler Instantiate(ISettingsResultSet settings, EquivalenceKind kind)
        {
            switch (settings)
            {
            case ISettingsSingleRowResultSet x: return(InstantiateSingleRow(x));

            case ISettingsResultSet x: return(InstantiateMultipleRows(x, kind));

            default: throw new ArgumentException();
            }
        }
Example #2
0
 protected virtual void BuildSettings(ColumnType keysDefaultType, ColumnType valuesDefaultType, Tolerance defaultTolerance)
 {
     if (IsByName())
     {
         settings = new SettingsNameResultSet(valuesDefaultType, defaultTolerance, GetAllColumns(keysDefaultType, valuesDefaultType));
     }
     else
     {
         settings = new SettingsOrdinalResultSet(keysSet, valuesSet, valuesDefaultType, defaultTolerance, definitionColumns);
     }
 }
Example #3
0
 public Evaluator Instantiate(ISettingsResultSet settings)
 {
     if (settings is SettingsOrdinalResultSet)
     {
         return(new OrdinalEvaluator(settings as SettingsOrdinalResultSet));
     }
     else if (settings is SettingsNameResultSet)
     {
         return(new NameEvaluator(settings as SettingsNameResultSet));
     }
     throw new ArgumentOutOfRangeException();
 }
Example #4
0
        public IEquivaler InstantiateMultipleRows(ISettingsResultSet settings, EquivalenceKind kind)
        {
            var factory   = new AnalyzersFactory();
            var analyzers = factory.Instantiate(kind);

            switch (settings)
            {
            case SettingsOrdinalResultSet x: return(new OrdinalEquivaler(analyzers, x));

            case SettingsNameResultSet x: return(new NameEquivaler(analyzers, x));

            default: throw new ArgumentException();
            }
        }
Example #5
0
        public IEquivaler Instantiate(ISettingsResultSet settings, EquivalenceKind kind)
        {
            if (settings is SettingsSingleRowResultSet)
            {
                return(new SingleRowEquivaler(settings as SettingsSingleRowResultSet));
            }
            else
            {
                var factory   = new AnalyzersFactory();
                var analyzers = factory.Instantiate(kind);

                if (settings is SettingsIndexResultSet)
                {
                    return(new IndexEquivaler(analyzers, settings as SettingsIndexResultSet));
                }

                else if (settings is SettingsNameResultSet)
                {
                    return(new NameEquivaler(analyzers, settings as SettingsNameResultSet));
                }
            }
            throw new ArgumentOutOfRangeException(nameof(settings));
        }
Example #6
0
        protected virtual void BuildSettings(ColumnType keysDefaultType, ColumnType valuesDefaultType, Tolerance defaultTolerance)
        {
            if (IsByName())
            {
                var allColumns =
                    nameKeys.Select(x => new Column()
                {
                    Identifier = new ColumnNameIdentifier(x), Role = ColumnRole.Key, Type = keysDefaultType
                })
                    .Union(nameValues.Select(x => new Column()
                {
                    Identifier = new ColumnNameIdentifier(x), Role = ColumnRole.Value, Type = valuesDefaultType
                })
                           .Union(definitionColumns)
                           );

                settings = new SettingsNameResultSet(valuesDefaultType, defaultTolerance, allColumns);
            }
            else
            {
                settings = new SettingsOrdinalResultSet(keysSet, valuesSet, valuesDefaultType, defaultTolerance, definitionColumns);
            }
        }
Example #7
0
 public Evaluator(ISettingsResultSet settings)
 {
     Settings = settings;
 }
Example #8
0
 public BaseResultSetComparisonConstraint Using(ISettingsResultSet settings)
 {
     this.Engine.Settings = settings;
     return(this);
 }
Example #9
0
 public AbstractByColumnGrouping(ISettingsResultSet settings)
 {
     Settings = settings;
 }
Example #10
0
 protected ColumnGrouping(ISettingsResultSet settings, Context context)
 => (Settings, Context) = (settings, context);