Tell if the table contains the given string. Ignore case.

@param s String to find

@return True if the String is in this vector
436245
public final boolean containsIgnoreCase(String s)
  {

    if (null == s)
      return false;

    for (int i = 0; i < m_firstFree; i++)
    {
      if (m_map[i].equalsIgnoreCase(s))
        return true;
    }

    return false;
  }
552145
static boolean hasFunkyChars(String s) {
        int length = s.length();

        if (length == 0)
            return false;

        for (int i = 0; i < length; ++i) {
            char c = s.charAt(i);

            if (Character.isLetterOrDigit(c) || c == '-' || c == '_')
                continue;
            else
                return true;
        }
        return false;
    }
93146
public boolean contains(List<String> containWith) {
		return contain(checkNotNull(containWith).toArray(new String[containWith.size()]));
	}
1252480
public static final boolean containsPassword(String s)
  {
    String u = s.toUpperCase();

    if (u.contains(PASSWORD))
      return true;
    else if (u.contains(PWD))
      return true;
    else if (u.contains(PASSWD))
      return true;
    else
      return false;
  }
820153
public static boolean isContained( String[] array, String s )
	{
		for (String string : array)
		{
			if( string.equals( s ) )
			{
				return true;
			}
		}
		return false;
	}
953780
public static boolean isValidImportString(String s) {
        if (s.equals("*"))
            return true;

        boolean valid = true;
        String t = s;
        int index = t.indexOf('*');

        if (index != -1) {
            // '*' must be last character...
            if (index == t.length() -1) {
                // ... any and preceding character must be '.'
                if ( index-1 >= 0 ) {
                    valid = t.charAt(index-1) == '.';
                    // Strip off ".*$" for identifier checks
                    t = t.substring(0, t.length()-2);
                }
            } else
                return false;
        }

        // Verify string is off the form (javaId \.)+ or javaId
        if (valid) {
            String[] javaIds = t.split("\\.", t.length()+2);
            for(String javaId: javaIds)
                valid &= SourceVersion.isIdentifier(javaId);
        }
        return valid;
    }
383624
public final static boolean isJavaKeyword(String s)
   {
      if (s == null || s.length() == 0)
      {
         return false;
      }

      for (int i = 0; i < keywords.length; i++)
      {
         if (keywords[i].equals(s))
         {
            return true;
         }
      }

      return false;
   }
491192
public boolean contains(final char ch) {
        final char[] thisBuf = buffer;
        for (int i = 0; i < this.size; i++) {
            if (thisBuf[i] == ch) {
                return true;
            }
        }
        return false;
    }
921465
public static boolean has(String text){
        for(char c : text.toCharArray()){
            if(is(c)){
                return true;
            }
        }
        return false;
    }
535410
private static boolean contains(Key[] haystack, Key needle) {
	for (int i = 0; i < haystack.length; i++) {
	    if (haystack[i].equalsIgnoreCase(needle)) return true;
	}
	return false;
    }
800545
static boolean containsNoDigit(final String s) {
    for (int k = 0; k < s.length(); k++) {
      if (Character.isDigit(s.charAt(k))) {
        return false;
      }
    }
    return true;
  }
614833
public boolean contains(Object o) {
    if (o instanceof String) {
      return set.contains(((String) o).toLowerCase());
    } else {
      return set.contains(o);
    }
  }
1108262
public boolean contains (E e) {
		for (int i = 0; size > i; i++) {
			if (e == data[i]) {
				return true;
			}
		}
		return false;
	}
9271
public boolean containsAll(CharSequence str) {
    final int n = str.length();
    for (int i = 0; i < n; ++i) {
      if (!contains(str.charAt(i))) {
        return false;
      }
    }
    return true;
  }
1061228
public boolean isFunctionName( String s ) {
        if( input1.containsKey(s))
            return true;
        if( inputN.containsKey(s))
            return true;

        return false;
    }
67181
public static boolean tableContainsString(VoltTable t, String s, boolean caseSenstive) {
        if (t.getRowCount() == 0) {
            return false;
        }
        if (!caseSenstive) {
            s = s.toLowerCase();
        }

        VoltTableRow row = t.fetchRow(0);
        do {
            for (int i = 0; i < t.getColumnCount(); i++) {
                if (t.getColumnType(i) == VoltType.STRING) {
                    String value = row.getString(i);
                    if (value == null) {
                        continue;
                    }
                    if (!caseSenstive) {
                        value = value.toLowerCase();
                    }
                    if (value.contains(s)) {
                        return true;
                    }
                }
            }

        } while (row.advanceRow());

        return false;
    }
1289445
public boolean contains(String column) {
		for ( String columnName : columnNames ) {
			if ( columnName.equals( column ) ) {
				return true;
			}
		}
		return false;
	}