Beispiel #1
0
        public override bool Equals(object obj)
        {
            if (obj.GetType() != typeof(DIDATuple))
            {
                return(false);
            }

            DIDATuple tupleData = (DIDATuple)obj;

            if (Arguments.Count != tupleData.Arguments.Count)
            {
                return(false);
            }

            for (int i = 0; i < Arguments.Count; i++)
            {
                if (Arguments[i].GetType() == typeof(string))
                {
                    if (tupleData.Arguments[i].GetType() != typeof(string))
                    {
                        return(false);
                    }

                    Regex rx = new Regex((string)tupleData.Arguments[i]);
                    if (!rx.IsMatch((string)Arguments[i]))
                    {
                        return(false);
                    }
                }

                if (Arguments[i] == null && tupleData.Arguments[i] != null)
                {
                    return(false);
                }
                if (tupleData.Arguments[i].GetType() == typeof(Type) && tupleData.Arguments[i].Equals(Arguments[i].GetType()))
                {
                    return(false);
                }
                if (Arguments[i].GetType() != tupleData.Arguments[i].GetType())
                {
                    return(false);
                }
                if (!Arguments[i].Equals(tupleData.Arguments[i]))
                {
                    return(false);
                }
            }

            return(true);
        }
Beispiel #2
0
        public bool Matches(DIDATuple otherTuple)
        {
            if (this.Arguments.Count != otherTuple.Arguments.Count)
            {
                return(false);
            }

            for (int i = 0; i < Arguments.Count; i++)
            {
                object thisArgument = this.Arguments[i];
                Type   thisType     = thisArgument.GetType();

                object otherArgument = otherTuple.Arguments[i];
                Type   otherType;

                if (otherArgument == null)
                {
                    Console.WriteLine($" >> User argument{i} is any object...");
                    // User is looking for an object of any type, other than string and this tuple argument i is a string
                    if (thisType == typeof(string))
                    {
                        return(false);
                    }
                    // If this tuple argument is not a string, than anything goes, because otherArgument as null, matches any object.
                    else
                    {
                        continue;
                    }
                }
                else
                {
                    // Since the other argument is not a null, we need to know if we are dealing, with strings, types or specific objects.
                    otherType = otherArgument.GetType();
                    if (otherType == typeof(string))
                    {
                        Console.WriteLine($" >> User argument{i} is a string...");
                        // If user is searching for a tuple whose argument[i] is a string, then this tuple must also be a string and must match.
                        // If this tuple doesn't have string in argument i. It's not a match.
                        if (thisType != typeof(string))
                        {
                            return(false);
                        }
                        // If both are of type string and they match, advance to the next argument of this tuple.
                        else if (TryStringMatch(thisArgument, otherArgument))
                        {
                            continue;
                        }
                        // Both are Strings but they dont match. Search for another feasible tuple.
                        else
                        {
                            return(false);
                        }
                    }
                    else
                    {
                        // User is not searching for a string. He is searching for an object.
                        // If otherArgument is null, we would done everything we wanted on the first condition of this function.
                        // So we we need to check if the user wants an object of a Type, or if he wants a specific object.
                        if (otherArgument.GetType().Name.Equals("RuntimeType"))
                        {
                            Console.WriteLine($" >> User argument{i} is a Type...");
                            // User is looking for an object of a given type, but it's parameters don't matter. Just check if type is the same.
                            // Types are the same, compare next argument
                            if (otherArgument.Equals(thisType))
                            {
                                continue;
                            }
                            // Types are not equal, search another tuple.
                            else
                            {
                                return(false);
                            }
                        }
                        // User is searching for a specific object, with the same type and same parameters
                        // If they are do a object equality comparison. If they are the same check next tuple argument
                        Console.WriteLine($" >> User argument{i} is a specific object...");
                        if (otherArgument.Equals(thisArgument))
                        {
                            continue;
                        }
                        // Else, search another tuple.
                        else
                        {
                            return(false);
                        }
                    }
                }
            }
            // If all arguments matched correctly return the trueeeeeeeeeee
            return(true);
        }