示例#1
0
        protected ModelParameters               DetermineParameters(ModelAction action)
        {
            try
            {
                ModelParameters allparameters = action.Parameters;
                ModelParameters choosen       = new ModelParameters();

                //Loop through the method parameters
                foreach (ParameterInfo info in action.Method.GetParameters())
                {
                    //Find the all parameters assoicated with this param
                    ModelParameters parameters = allparameters.Find(info.Name);
                    //Exclude invalid parameters (if not requested)
                    if (!this.InvalidParameters)
                    {
                        parameters = (ModelParameters)parameters.FindFlag((int)ModelItemFlags.Throws, false);
                    }
                    if (parameters.Count <= 0)
                    {
                        throw new ModelException(this, "Unable to find a ModelParameter for method parameter: '" + info.Name + "'");
                    }

                    //Choose one of the parameters, based upon weight
                    ModelParameter parameter = parameters.Choose(this);
                    parameter.Accessed++;

                    //Note: We cloning the param, since were choosing only one of the values to use this time.
                    parameter = (ModelParameter)parameter.Clone();

                    //Choose (or generate) one of the values
                    ModelValue value = DetermineParameterValue(parameter);
                    value.Accessed++;

                    //Add it to the array
                    parameter.Value = value;
                    choosen.Add(parameter);
                }

                return(choosen);
            }
            catch (Exception e)
            {
                //Make this easier to debug
                throw new ModelException(this, "DetermineParameters", e);
            }
        }
示例#2
0
 //Constructor
 public ModelExpression(ModelFunction func, ModelValue value)
     : base(null, value)
 {
     _func = func;
 }
示例#3
0
        protected ModelValue                    DetermineParameterValue(ModelParameter parameter)
        {
            ModelValues values = new ModelValues();

            values.Add(parameter.Values);

            //Parameter values, can be specified in numerous ways:
            //	1.  Value list - simply choose one of them
            //	2.  Expression - generate value that meets the criteria (ie: <, >, !=, etc)
            //	3.  Variable - simply obtain the value by calling a method/field

            //#3. Variable - simply obtain the value by calling a method/field
            if (parameter.Variable != null)
            {
                object current = parameter.Variable.CachedValue;
                if (current is IEnumerable && !typeof(IEnumerable).IsAssignableFrom(parameter.Type))
                {
                    foreach (object v in (IEnumerable)current)
                    {
                        values.Add(new ModelValue(v));
                    }
                }
                else
                {
                    values.Add(new ModelValue(current));
                }
            }

            //First ensure we have a set of values/requirements to choose from
            if (values.Count <= 0)
            {
                throw new ModelException(parameter, "No values specified to choose from");
            }

            //Note: Since we allow the operator on the individual values, this is a little more complex.
            //Note: We allow multiple operators, not just one, (ie: x > 5, < 10, and != 7).
            //This gives you great power and flexibility in expressions, but means we have to work a
            //little hard in determing a value that meets the requirements

            //#1.  Value list - simply choose one of them
            //Note: Bitmask is already exploded into combinations
            ModelValues equalvalues = values.FindOperator(ModelValueOperator.Equal);

            //#2.  Expression - generate value that meets the criteria (ie: <, >, !=, etc)
            //Note: Since we allow the operator on the individual values, this is a little more complex.
            //Note: We allow multiple operators, not just one, (ie: x > 5, < 10, and != 7).
            //This gives you great power and flexibility in expressions, but means we have to work a
            //little hard in determing a value that meets the requirements.
            int min = Int32.MinValue;
            int max = Int32.MaxValue;

            //Adjust our parameter, simplier to loop over all of them
            foreach (ModelValue value in values.FindOperator(ModelValueOperator.Equal, false).FindOperator(ModelValueOperator.NotEqual, false))
            {
                //To keep this simple, we just support integers (for now).
                if (!(value.Value is int || value.Value is Nullable <int>))
                {
                    throw new ModelException(parameter, "Generated value range must be specified in terms of integers, not '" + value.Type + "'");
                }

                //Simplify our life
                int v = (int)value.Value;

                //Adjust Max (if there is one)
                switch (value.Operator)
                {
                case ModelValueOperator.LessThanOrEqual:
                    if (v < max)
                    {
                        max = v;
                    }
                    break;

                case ModelValueOperator.GreaterThanOrEqual:
                    if (v > min)
                    {
                        min = v;
                    }
                    break;

                case ModelValueOperator.LessThan:
                    if (v - 1 < max && v > Int32.MinValue /*prevent underflow*/)
                    {
                        max = v - 1;
                    }
                    break;

                case ModelValueOperator.GreaterThan:
                    if (v + 1 > min && v < Int32.MaxValue /*prevent overflow*/)
                    {
                        min = v + 1;
                    }
                    break;
                }
                ;
            }

            //Choose a new value, within the specified range
            //Note: We retry in case it equals one of the existing invalid values (ie: !=)
            while (true)
            {
                ModelValue choice = null;
                if (equalvalues.Count > 0)
                {
                    //Simple: Choose one of the specified values
                    choice = new ModelValue(equalvalues.Choose(this).Value);
                }
                else
                {
                    //Otherwise: Choose a value within in the range
                    //Note: Random.Next = min <= x < max (so we have to add one)
                    int index = _options.Random.Next(min, max < Int32.MaxValue ? max + 1 : max);                        //Prevent overflow
                    choice = new ModelValue(index);
                }

                //As soon as we find a value, within the range, (and not in the invalid list), were done
                bool valid = true;
                foreach (ModelValue invalid in values.FindOperator(ModelValueOperator.NotEqual))
                {
                    if (invalid.Evaluate(choice.Value, ModelValueOperator.Equal))
                    {
                        valid = false;
                    }
                }

                if (valid)
                {
                    return(choice);
                }
            }
        }
示例#4
0
        public ModelRequirement(ModelAction action, ModelRequirementAttribute attr, ModelVariable variable, ModelValue value)
            : base(action != null ? action.Model : null, attr)
        {
            //Action
            _action = action;

            //Variable
            if (variable != null)
            {
                _variable = variable;
                if (variable.BitMask)
                {
                    this.BitMask = true;
                }
            }
            //if(_variable == null)
            //    throw new ModelException(this, "An empty variable is not a valid requirement", null);

            //Only override the attr, if values are really specified
            if (value != null)
            {
                _values = new ModelValues(value);
            }

            //BitMask
            //TODO: Better place to expand this, (incase values added later).
            if (this.BitMask)
            {
                this.AddBitCombinations();
            }

            //Infer dynamic variable(s)
            this.InferDynamicVariables();

            //Requirements assoicated with actions, are not global.  They are tied to that particular
            //instance of the model, and it's instance of state variables.  However if not assoicated
            //with actions, the default behavior is that their global, they apply to all models
            //that contain that state variable, unless explicitly indicated otherwise.
            _global = (action == null);
        }
示例#5
0
 public ModelRequirement(ModelAction action, ModelVariable variable, ModelValue value)
     : this(action, null, variable, value)
 {
     //Delegate
 }