Example #1
0
 // CONSTRUCTORS
 public AchievementCriterionData(ComparaisonOperatorEnum @operator, params string[] parameters)
     : base(@operator, parameters)
 {
     if (uint.TryParse(base[0], out this.m_achievementId))
     {
         this.m_achievement = Singleton <AchievementManager> .Instance.TryGetAchievement(this.m_achievementId);
     }
     else
     {
         throw new Exception();
     }
 }
Example #2
0
        public CriterionData(ComparaisonOperatorEnum @operator, params string[] parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }
            if (parameters.Length == 0)
            {
                throw new ArgumentException("parameters");
            }

            this.m_operator   = @operator;
            this.m_parameters = parameters;
        }
Example #3
0
        public static char GetOperatorChar(ComparaisonOperatorEnum op)
        {
            switch (op)
            {
            case ComparaisonOperatorEnum.EQUALS:
                return('=');

            case ComparaisonOperatorEnum.INEQUALS:
                return('!');

            case ComparaisonOperatorEnum.SUPERIOR:
                return('>');

            case ComparaisonOperatorEnum.INFERIOR:
                return('<');

            case ComparaisonOperatorEnum.LIKE:
                return('~');

            case ComparaisonOperatorEnum.STARTWITH:
                return('s');

            case ComparaisonOperatorEnum.STARTWITHLIKE:
                return('S');

            case ComparaisonOperatorEnum.ENDWITH:
                return('e');

            case ComparaisonOperatorEnum.ENDWITHLIKE:
                return('E');

            case ComparaisonOperatorEnum.INVALID:
                return('i');

            case ComparaisonOperatorEnum.VALID:
                return('v');

            case ComparaisonOperatorEnum.UNKNOWN_1:
                return('#');

            case ComparaisonOperatorEnum.UNKNOWN_2:
                return('/');

            case ComparaisonOperatorEnum.UNKNOWN_3:
                return('X');

            default:
                throw new Exception(string.Format("{0} is not a valid comparaison operator", op));
            }
        }
        // CONSTRUCTORS
        public DefaultCriterionData(ComparaisonOperatorEnum @operator, params string[] parameters)
            : base(@operator, parameters)
        {
            this.m_params = new int[parameters.Length];

            for (int i = 0; i < parameters.Length; i++)
            {
                if (int.TryParse(base[i], out this.m_params[i]))
                {
                }
                else
                {
                    throw new Exception();
                }
            }
        }
Example #5
0
 // METHODS
 public override DefaultCriterionData Parse(ComparaisonOperatorEnum @operator, params string[] parameters)
 {
     return(new DefaultCriterionData(@operator, parameters));
 }
Example #6
0
 // CONSTRUCTORS
 public CriterionData(ComparaisonOperatorEnum @operator)
 {
     this.m_operator = @operator;
 }
        public static char GetOperatorChar(ComparaisonOperatorEnum op)
        {
            char result;

            switch (op)
            {
            case ComparaisonOperatorEnum.EQUALS:
                result = '=';
                break;

            case ComparaisonOperatorEnum.INEQUALS:
                result = '!';
                break;

            case ComparaisonOperatorEnum.SUPERIOR:
                result = '>';
                break;

            case ComparaisonOperatorEnum.INFERIOR:
                result = '<';
                break;

            case ComparaisonOperatorEnum.LIKE:
                result = '~';
                break;

            case ComparaisonOperatorEnum.STARTWITH:
                result = 's';
                break;

            case ComparaisonOperatorEnum.STARTWITHLIKE:
                result = 'S';
                break;

            case ComparaisonOperatorEnum.ENDWITH:
                result = 'e';
                break;

            case ComparaisonOperatorEnum.ENDWITHLIKE:
                result = 'E';
                break;

            case ComparaisonOperatorEnum.VALID:
                result = 'v';
                break;

            case ComparaisonOperatorEnum.INVALID:
                result = 'i';
                break;

            case ComparaisonOperatorEnum.UNKNOWN_1:
                result = '#';
                break;

            case ComparaisonOperatorEnum.UNKNOWN_2:
                result = '/';
                break;

            case ComparaisonOperatorEnum.UNKNOWN_3:
                result = 'X';
                break;

            default:
                throw new System.Exception(string.Format("{0} is not a valid comparaison operator", op));
            }
            return(result);
        }
 // METHODS
 public override AchievementCriterionData Parse(ComparaisonOperatorEnum @operator, params string[] parameters)
 {
     return(new AchievementCriterionData(@operator, parameters));
 }
 // METHODS
 public abstract Data Parse(ComparaisonOperatorEnum @operator, params string[] parameters);