Determines if a character is contained within the character set.

 @param [String] char
   The character to search for.

 @return [Boolean]
   Specifies whether the character is contained within the
   character set.
481317
def include_char?(char)
      unless char.empty?
        @chars.has_value?(char) || include_byte?(char_to_byte(char))
      else
        false
      end
    end
401312
private static boolean isValidEscaping(char c) {
        return ((c == 'n') || (c == 'r') || (c == 't') || (c == 'f') || (c == 'b') || (c == '\\') || (c == '/')
                || (c == '"') || (c == 'u'));
    }
186150
public final boolean containsAny(char... a) {
        for (int i = 0; i < len; ++i) {
            for (char b : a) {
                if (b == fb[off + i]) {
                    return true;
                }
            }
        }
        return false;
    }
382104
def include? position
      position = Position.normalize(position)
      contain?(position) && !(position.line == start.line && position.character == start.character)
    end
538957
def has_control_chars(i):
        
        if not hasattr(i, 'type_'):
            return False

        if i.type_ != Type.string:
            return False

        if i.token in ('VAR', 'PARAMDECL'):
            return True  # We don't know what an alphanumeric variable will hold

        if i.token == 'STRING':
            for c in i.value:
                if 15 < ord(c) < 22:  # is it an attr char?
                    return True
            return False

        for j in i.children:
            if Translator.has_control_chars(j):
                return True

        return False
1229306
def charlock_detect(str)
      if defined? CharlockHolmes::EncodingDetector
        if detected = CharlockHolmes::EncodingDetector.detect(str)
          str.force_encoding(detected[:encoding]) if detected[:encoding]
        end
      end

      str
    end
922899
def encapsulate_string(string)
      string = string.gsub('\\', '\\\\')

      ENCAPSULATED_CHARACTERS.each do |char|
        string = string.gsub(char, "\\#{char}")
      end

      string
    end
1358731
public final boolean contains(char a) {
        for (int i = off; i < (off + len); ++i) {
            if (fb[i] == a) {
                return true;
            }
        }
        return false;
    }
605041
private boolean isAlphanumericOrPlusMinusPoint(char character) {
        return (character >= 'A' && character <= 'Z') // Unicode A..Z
                || (character >= 'a' && character <= 'z') // Unicode a..z
                || (character >= '0' && character <= '9') // Unicode 0..9
                || character == '+' || character == '-' || character == '.';
    }
1152097
def set_char( at , char )
      raise "char not fixnum #{char.class}" unless char.kind_of? ::Integer
      index = range_correct_index(at)
      set_internal_byte( index , char)
    end
244542
public boolean contains(final char ch) {
        for (final CharRange range : set) {
            if (range.contains(ch)) {
                return true;
            }
        }
        return false;
    }
690248
public static boolean hasSingleCharacterArg(Closure c) {
        if (c.getMaximumNumberOfParameters() != 1) return false;
        String typeName = c.getParameterTypes()[0].getName();
        return typeName.equals("char") || typeName.equals("java.lang.Character");
    }
1331091
public static boolean isAllLetter(String text)
    {
        for (int i = 0; i < text.length(); ++i)
        {
            char c = text.charAt(i);
            if ((((c < 'a' || c > 'z')) && ((c < 'A' || c > 'Z'))))
            {
                return false;
            }
        }

        return true;
    }
480881
public final boolean contains(char c1, char c2) {
    try {
      String s = new String(new String(new char[]{c1, c2}).getBytes(enc), enc);
      return s.length() == 2 && s.charAt(0) == c1 && s.charAt(1) == c2;
    }
    catch (UnsupportedEncodingException e) {
      return false;
    }
    // work around gcj bug (libgcj/9802)
    catch (RuntimeException e) {
      return false;
    }
  }
442059
def is_blankspace(self, char):
        
        if len(char) > 1:
            raise TypeError("Expected a char.")
        if char in self.blankspaces:
            return True
        return False
1033981
def _IsIdentifier(cls, string):
    
    return (
        string and not string[0].isdigit() and
        all(character.isalnum() or character == '_' for character in string))
1372375
def lookup_char(self, char):
        
        Unihan = self.sql.base.classes.Unihan
        return self.sql.session.query(Unihan).filter_by(char=char)