コード例 #1
0
 public NumericMixEvaluator(PropertyInfo targetProperty, T target, NumericEvalType evalType, MixType type)
 {
     TargetProperty = targetProperty;
     Target         = target;
     EvalType       = evalType;
     MixType        = type;
 }
コード例 #2
0
        public static MixType NumericEvalTypeToMixTypeVariant(NumericEvalType evalType)
        {
            switch (evalType)
            {
            case NumericEvalType.StrictLess:
                return(MixType.NUMERIC_STRICTLYLESS_VARIANT);

            case NumericEvalType.Less:
                return(MixType.NUMERIC_LESS_VARIANT);

            case NumericEvalType.Equal:
                return(MixType.NUMERIC_EQUAL_VARIANT);

            case NumericEvalType.More:
                return(MixType.NUMERIC_MORE_VARIANT);

            case NumericEvalType.StrictMore:
                return(MixType.NUMERIC_STRICTLYMORE_VARIANT);

            default:
                DebugHelper.Alert(new CallerInfo(), "Unexpected eval type");
                return(MixType.None);
            }
        }
コード例 #3
0
ファイル: MixViewModel.cs プロジェクト: yongjan/musicmink
        public static IMixEvaluator NumericMixEntryModelToMixEvaluator(MixType type, string input)
        {
            PropertyInfo info = null;

            switch (type & MixType.SUBTYPE_MASK)
            {
            case MixType.RATING_SUBTYPE:
                info = typeof(SongViewModel).GetRuntimeProperty(SongViewModel.Properties.Rating);
                break;

            case MixType.LENGTH_SUBTYPE:
                info = typeof(SongViewModel).GetRuntimeProperty(SongViewModel.Properties.DurationSeconds);
                break;

            case MixType.PLAYCOUNT_SUBTYPE:
                info = typeof(SongViewModel).GetRuntimeProperty(SongViewModel.Properties.PlayCount);
                break;

            default:
                DebugHelper.Alert(new CallerInfo(), "Unexpected NUMBER_TYPE MixType {0}", type);
                break;
            }

            NumericEvalType numericEvalType = NumericEvalType.Unknown;

            switch (type & MixType.VARIANT_MASK)
            {
            case MixType.NUMERIC_STRICTLYLESS_VARIANT:
                numericEvalType = NumericEvalType.StrictLess;
                break;

            case MixType.NUMERIC_LESS_VARIANT:
                numericEvalType = NumericEvalType.Less;
                break;

            case MixType.NUMERIC_EQUAL_VARIANT:
                numericEvalType = NumericEvalType.Equal;
                break;

            case MixType.NUMERIC_MORE_VARIANT:
                numericEvalType = NumericEvalType.More;
                break;

            case MixType.NUMERIC_STRICTLYMORE_VARIANT:
                numericEvalType = NumericEvalType.StrictMore;
                break;

            default:
                DebugHelper.Alert(new CallerInfo(), "Unexpected NUMBER_TYPE VARIANT_MASK MixType {0}", type);
                break;
            }

            if (info != null)
            {
                Type t = info.PropertyType;

                IComparable inputAsType = DebugHelper.CastAndAssert <IComparable>(Utilities.GetDefault(t));

                try
                {
                    inputAsType = DebugHelper.CastAndAssert <IComparable>(Convert.ChangeType(input, t));
                }
                catch (FormatException)
                {
                    // If cast is bad, ignore and use default type
                }

                return(new NumericMixEvaluator <IComparable>(info, inputAsType, numericEvalType, type));
            }

            return(new NoneMixEvaluator());
        }