Beispiel #1
0
 public DoubleEffector(string fieldName
                       , string effectorName
                       , EffectorFunction <double> func
                       , EffectorOperatorType opType = EffectorOperatorType.InPlace
                       , EffectorValueType valueType = EffectorValueType.RelativeToStart
                       , bool reusable = false)
     : base(fieldName, effectorName, func, opType, valueType, reusable)
 {
 }
 public CoerciveEffector(string propertyName
                         , string effectorName
                         , EffectorFunction <T2> func
                         , EffectorOperatorType opType = EffectorOperatorType.InPlace
                         , EffectorValueType valueType = EffectorValueType.RelativeToStart
                         , bool reusable = false)
     : this(propertyName
            , effectorName
            , func
            , new EffectorOperator <T2>(opType)
            , valueType
            , reusable)
 {
 }
        public EffectorOperator(EffectorOperatorType type)
        {
            InternalType = type;
            var _ops = Operators;

            if (_ops == null)
            {
                switch (type)
                {
                case EffectorOperatorType.InPlace:
                    Operate = (a, b) => b;
                    break;

                case EffectorOperatorType.Additive:
                    Operate = GenericOperators.Add <T>;
                    break;

                case EffectorOperatorType.Multiplicative:
                    Operate = GenericOperators.Mul <T>;
                    break;

                case EffectorOperatorType.ArithmeticAveraging:
                    Operate = GenericOperators.Average <T>;
                    break;

                default:
                    throw new EffectorOperatorException(
                              String.Format(
                                  "Unknown EffectorOperatorType supplied: '{0}'.", type
                                  )
                              );
                }
            }
            else
            {
                Operate = _ops[type];
            }
        }
 public VectorEffectorOperator(EffectorOperatorType type) : base(type)
 {
 }
 public DoubleEffectorOperator(EffectorOperatorType type) : base(type)
 {
 }
 public IntEffectorOperator(EffectorOperatorType type) : base(type)
 {
 }