def filterOr(self, **kwargs):
        '''
            filterOr - Performs a filter and returns a QueryableList object of the same type.

                Anythe provided filters can match for the item to be returned.

            @params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.

            @return - A QueryableList object of the same type, with only the matching objects returned.
        '''
        filters = getFiltersFromArgs(kwargs)
        ret = self.__class__()

        if USE_CACHED:
            caches = [dict() for i in range(len(self))]
            get_item_value = self._getItemValueFunction(caches, self._get_item_value)
        else:
            get_item_value = self._get_item_value

        # OR filtering - For each item in the collection
        #   Run through each filter type. If anything matches, we add the item to the collection and continue
        #   If we get to the end without a match, we continue to next item
        for item in self:
            keepIt = False

            # Do is/isnot (and implicitly isnull) first.
            for fieldName, value in filters['is']:
                if get_item_value(item, fieldName) is value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['isnot']:
                if get_item_value(item, fieldName) is not value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, matchFunc in filters['customMatch']:
                val = get_item_value(item, fieldName)
                if matchFunc(val):
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['in']:
                if get_item_value(item, fieldName) in value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['notin']:
                if get_item_value(item, fieldName) not in value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['eq']:
                if get_item_value(item, fieldName) == value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['ieq']:
                # If we can't lowercase the item's value, it obviously doesn't match whatever we previously could.
                # Reminder: the "i" filter's values have already been lowercased
                itemValue = get_item_value(item, fieldName)
                try:
                    itemValueLower = itemValue.lower()
                except:
                    keepIt = False
                    break

                if itemValueLower == value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['ne']:
                if get_item_value(item, fieldName) != value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['ine']:
                itemValue = get_item_value(item, fieldName)
                try:
                    itemValueLower = itemValue.lower()
                except:
                    # If we can't convert the field value to lowercase, it does not equal the other.
                    continue

                if itemValueLower != value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['lt']:
                if get_item_value(item, fieldName) < value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['lte']:
                if get_item_value(item, fieldName) <= value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['gt']:
                if get_item_value(item, fieldName) > value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue


            for fieldName, value in filters['gte']:
                if get_item_value(item, fieldName) >= value:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['contains']:
                itemValue = get_item_value(item, fieldName)
                try:
                    if value in itemValue:
                        keepIt = True
                        break
                except:
                    # If field does not support "in", it does not contain the item.
                    continue

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['icontains']:
                itemValue = get_item_value(item, fieldName)
                try:
                    itemValue = itemValue.lower()

                    if value in itemValue:
                        keepIt = True
                        break
                except:
                    continue

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['notcontains']:
                itemValue = get_item_value(item, fieldName)
                try:
                    if value not in itemValue:
                        keepIt = True
                        break
                except:
                    # If field does not support "in", it does not contain the item.
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['noticontains']:
                itemValue = get_item_value(item, fieldName)
                try:
                    itemValue = itemValue.lower()

                    if value not in itemValue:
                        keepIt = True
                        break
                except:
                    # If field does not support "in", it does not contain the item.
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue


            for fieldName, value in filters['containsAny']:
                itemValue = get_item_value(item, fieldName)

                if itemValue is None:
                    # None contains nothing, no match
                    continue

                didContain = False
                for maybeContains in value:
                    if maybeContains in itemValue:
                        didContain = True
                        break
                if didContain is True:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['notcontainsAny']:
                itemValue = get_item_value(item, fieldName)

                if itemValue is None:
                    # None contains nothing, so this is a match
                    keepIt = True
                    break

                didContain = False
                for maybeContains in value:
                    if maybeContains in itemValue:
                        didContain = True
                        break
                if didContain is False:
                    keepIt = True
                    break

            if keepIt is True:
                ret.append(item)
                continue


            for fieldName, value in filters['splitcontains']:
                (splitBy, maybeContains) = value

                itemValue = get_item_value(item, fieldName)

                if itemValue is None:
                    # Cannot split, no match
                    continue

                try:
                    itemValue = itemValue.split(splitBy)
                    if maybeContains in itemValue:
                        keepIt = True
                        break
                except:
                    # If field does not supprt "in", or cannot be split, it does not contain the item.
                    continue


            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['splitnotcontains']:
                (splitBy, maybeContains) = value

                itemValue = get_item_value(item, fieldName)

                if itemValue is None:
                    # Cannot split, so does not contain and is a match.
                    keepIt = True
                    break


                try:
                    itemValue = itemValue.split(splitBy)
                    if maybeContains not in itemValue:
                        keepIt = True
                        break
                except:
                    # If field does not supprt "in", or cannot be split, it does not contain the item and thus matches here.
                    keepIt = True
                    break


            if keepIt is True:
                ret.append(item)
                continue


            for fieldName, value in filters['splitcontainsAny']:
                (splitBy, maybeContainsLst) = value

                itemValue = get_item_value(item, fieldName)

                if itemValue is None:
                    # Cannot split, so it does not contain a match
                    continue

                try:
                    itemValue = itemValue.split(splitBy)
                except:
                    # Cannot split, does not match.
                    continue


                didContain = False
                for maybeContains in maybeContainsLst:
                    if maybeContains in itemValue:
                        didContain = True
                        break

                if didContain is True:
                    keepIt = True
                    break


            if keepIt is True:
                ret.append(item)
                continue

            for fieldName, value in filters['splitnotcontainsAny']:
                (splitBy, maybeContainsLst) = value

                itemValue = get_item_value(item, fieldName)

                if itemValue is None:
                    # Cannot split, so it must not contain any (and is a match)
                    keepIt = True
                    break

                try:
                    itemValue = itemValue.split(splitBy)
                except:
                    # Cannot split, so must not contain any (and is a match)
                    keepIt = True
                    break

                didContain = False
                for maybeContains in maybeContainsLst:
                    if maybeContains in itemValue:
                        didContain = True
                        break
                if didContain is False:
                    keepIt = True
                    break


            if keepIt is True:
                ret.append(item)
                continue


        return ret