Beispiel #1
0
 public IntegrationMessageFilterContext(IIntegrationMessage message, MessageMetaData meta, IEndpoint endpoint, FilterDirection direction, MessageTypeProperties props)
 {
     Message         = message;
     MessageMetaData = meta;
     Endpoint        = endpoint;
     Direction       = direction;
     Props           = props;
 }
Beispiel #2
0
        public void Filter(string message, IChatWindow window, FilterDirection direction, Action <string> onAccept)
        {
            var filteredMessage = new StringBuilder(message);

            if (Filter(filteredMessage, window, direction))
            {
                onAccept(filteredMessage.ToString());
            }
        }
Beispiel #3
0
        public bool Filter(StringBuilder message, IChatWindow window, FilterDirection direction)
        {
            foreach (IMessageFilter filter in this.Where(f => (f.Direction & direction) == direction))
            {
                if (!filter.Filter(message, window))
                {
                    return(false);
                }
            }

            return(true);
        }
        public static ColumnSchemaCollection Filter(this ColumnSchemaCollection columns, FilterRules rules, FilterDirection direction)
        {
            var matches = (from column in columns
                            where !column.IsPrimaryKeyMember || !rules.HasFlag(FilterRules.IsPrimaryKey)
                            where !column.IsIdentityColumn() || !rules.HasFlag(FilterRules.IsIdentity)
                            where !column.IsIdentifierColumn() || !rules.HasFlag(FilterRules.IsIdentifier)
                            where !column.IsDeleteFlag() || !rules.HasFlag(FilterRules.IsDeleteFlag)
                            where !column.IsVersionDateColumn() || !rules.HasFlag(FilterRules.IsDeleteFlag)
                            where !column.IsVersionUserColumn() || !rules.HasFlag(FilterRules.IsVersionUser)
                            where !column.HasDefaultValue() || !rules.HasFlag(FilterRules.HasDefaultValue)
                            select column).ToList();

            return (direction == FilterDirection.Include)
                ? matches.ToColumnSchemaCollection()
                : columns.Where(column => !matches.Contains(column)).ToList().ToColumnSchemaCollection();
        }
Beispiel #5
0
        public FilterAttribute(Type filterInfo, FilterDirection direction = FilterDirection.Allow)
        {
            _filterInfo = filterInfo;

            if (!_filterInfo.GetInterfaces().Contains(typeof(Filter)))
            {
                throw new ArgumentException("Invalid argument to FilterAttribute");
            }

            _filterMethodInfo = _filterInfo.GetMethod("Filter", BindingFlags.Public | BindingFlags.Instance);

            if (_filterMethodInfo == null)
            {
                throw new ArgumentException("Filter must have a Filter method");
            }
            if (_filterMethodInfo.ReturnType != typeof(bool))
            {
                throw new ArgumentException("Filter method must return bool");
            }

            var constructors = _filterInfo.GetConstructors();

            if (constructors.Length != 1)
            {
                throw new ArgumentException("Filter type is supposed to have a single constructor");
            }

            var constructor = constructors.First();

            if (constructor.GetParameters().Count() != 0)
            {
                throw new ArgumentException("Filter object is not supposed to have arguments");
            }

            _filterObject = (Filter)constructor.Invoke(new object[0]);

            _direction = direction;
        }
Beispiel #6
0
        public void FilterBackward()
        {
            int j, i, n = FilterSteps.Length;
            int nstvec = FilterSteps[0].StateVectorLength;
            int nmsvec = FilterSteps[0].MeasurementsVectorLength;

            if (n <= 0 || nstvec <= 0 || nmsvec <= 0)
            {
                return;
            }
            //for (i=n; i>=0; i--)
            for (i = n - 2; i >= 0; i--)
            {
                // predict the covariance of estimate
                double[,] Cmm = Matrices.Product(FilterSteps[i + 1].BackwardPropagator, FilterSteps[i + 1].FiltStateCovariance);
                double[,] Amm = Matrices.Transpose(FilterSteps[i + 1].BackwardPropagator);
                Cmm           = Matrices.Product(Cmm, Amm);
                Cmm           = Matrices.Sum(Cmm, FilterSteps[i + 1].NoiseCovariance);
                FilterSteps[i].SetPredictedStateCovariance(Cmm);

                // calculate kalman gain matrix
                double[,] Cnm    = Matrices.Product(FilterSteps[i].StateMeasure, FilterSteps[i].PredStateCovariance);
                double[,] Bmn    = Matrices.Transpose(FilterSteps[i].StateMeasure);
                double[,] Cnn    = Matrices.Product(Cnm, Bmn);
                Cnn              = Matrices.Sum(Cnn, FilterSteps[i].MeasCovariance);
                double[,] Cnninv = Matrices.InvertMatrix(Cnn);
                double[,] Cmn    = Matrices.Product(FilterSteps[i].PredStateCovariance, Bmn);
                FilterSteps[i].SetKalmanGain(Matrices.Product(Cmn, Cnninv));

                // predict and filter state vector
                if (i > 0)
                {
                    // if there is a measurement
                    double[] xm = Matrices.Product(FilterSteps[i + 1].BackwardPropagator, FilterSteps[i + 1].StateVec);
                    FilterSteps[i].SetPredStateVec(xm);
                    double[] ym = new double[xm.Length];
                    for (j = 0; j < xm.Length; j++)
                    {
                        ym[j] = xm[j];
                    }
                    double[] xn = Matrices.Product(FilterSteps[i].StateMeasure, xm);
                    xn = Matrices.Subtract(FilterSteps[i].MeasureVec, xn);
                    xm = Matrices.Product(FilterSteps[i].KalmanGain, xn);
                    xm = Matrices.Sum(xm, ym);
                    FilterSteps[i].SetStateVec(xm);
                }
                else
                {
                    // no measurement (i.e. final iteration)
                    FilterSteps[i].SetStateVec(Matrices.Product(FilterSteps[i + 1].BackwardPropagator, FilterSteps[i + 1].StateVec));
                }

                // filter covariance matrix
                Cmm           = Matrices.Product(FilterSteps[i].KalmanGain, FilterSteps[i].StateMeasure);
                double[,] Bmm = Matrices.Identity(nstvec);
                Bmm           = Matrices.Subtract(Bmm, Cmm);
                Bmm           = Matrices.Product(Bmm, FilterSteps[i].PredStateCovariance);
                FilterSteps[i].SetFiltStateCovariance(Bmm);

                //Quality checks on filtering progress
                if (i <= n)
                {
                    // calculate filtered residual
                    double[] zn = Matrices.Product(FilterSteps[i].StateMeasure, FilterSteps[i].StateVec);
                    zn = Matrices.Subtract(FilterSteps[i].MeasureVec, zn);
                    FilterSteps[i].SetResidualVec(zn);

                    // calculate residual covariance matrix
                    Cnn           = Matrices.Product(FilterSteps[i].StateMeasure, FilterSteps[i].KalmanGain);
                    double[,] Bnn = Matrices.Identity(nmsvec);
                    Bnn           = Matrices.Subtract(Bnn, Cnn);
                    Bnn           = Matrices.Product(Bnn, FilterSteps[i].MeasCovariance);
                    FilterSteps[i].SetResidualMat(Bnn);

                    // calculate chi-squared
                    double[,] Dnn = Matrices.InvertMatrix(FilterSteps[i].ResidualMat);
                    zn            = Matrices.Product(Dnn, FilterSteps[i].ResidualVec);
                    FilterSteps[i].SetChiSquared(Matrices.ScalarProduct(FilterSteps[i].ResidualVec, zn));
                }
            }
            LastFilter = FilterDirection.Forward;
        }
        public static ColumnSchemaCollection Filter(this ColumnSchemaCollection columns, FilterRules rules, FilterDirection direction)
        {
            var matches = (from column in columns
                           where !column.IsPrimaryKeyMember || !rules.HasFlag(FilterRules.IsPrimaryKey)
                           where !column.IsIdentityColumn() || !rules.HasFlag(FilterRules.IsIdentity)
                           where !column.IsIdentifierColumn() || !rules.HasFlag(FilterRules.IsIdentifier)
                           where !column.IsDeleteFlag() || !rules.HasFlag(FilterRules.IsDeleteFlag)
                           where !column.IsVersionDateColumn() || !rules.HasFlag(FilterRules.IsDeleteFlag)
                           where !column.IsVersionUserColumn() || !rules.HasFlag(FilterRules.IsVersionUser)
                           where !column.HasDefaultValue() || !rules.HasFlag(FilterRules.HasDefaultValue)
                           select column).ToList();

            return((direction == FilterDirection.Include)
                ? matches.ToColumnSchemaCollection()
                : columns.Where(column => !matches.Contains(column)).ToList().ToColumnSchemaCollection());
        }
Beispiel #8
0
 public TransportMessageFilterContext(TransportMessage message, IEndpoint endpoint, FilterDirection direction)
 {
     TransportMessage = message;
     Endpoint         = endpoint;
     Direction        = direction;
 }