Returns whether or not the <code>octet</code> is in the base 64 alphabet.

@param octet
The value to test
@return {@code true} if the value is defined in the the base 64 alphabet, {@code false} otherwise.
@since 1.4
339567
public static boolean isBase64(final byte octet) {
        return octet == PAD_DEFAULT || (octet >= 0 && octet < DECODE_TABLE.length && DECODE_TABLE[octet] != -1);
    }
381885
public static boolean isSignedInteger(String s) {
        if (isEmpty(s)) return defaultEmptyOK;

        try {
            Integer.parseInt(s);

            return true;
        } catch (Exception e) {
            return false;
        }

        // int startPos = 0;
        // boolean secondArg = defaultEmptyOK;

        // if(isSignedInteger.arguments.length > 1) secondArg = isSignedInteger.arguments[1];

        // skip leading + or -
        // if((s.charAt(0) == "-") ||(s.charAt(0) == "+") ) startPos = 1;
        // return(isInteger(s.substring(startPos, s.length), secondArg))
    }
83540
def _hex_to_octets(addr):
    '''
    
    '''
    return '{0}:{1}:{2}:{3}'.format(
        int(addr[6:8], 16),
        int(addr[4:6], 16),
        int(addr[2:4], 16),
        int(addr[0:2], 16),
    )
682478
public static boolean isCombiningChar(int ch)
   {
      return (0x0300 <= ch && ch <= 0x0345) || (0x0360 <= ch && ch <= 0x0361) || (0x0483 <= ch && ch <= 0x0486)
         || (0x0591 <= ch && ch <= 0x05A1) || (0x05A3 <= ch && ch <= 0x05B9) || (0x05BB <= ch && ch <= 0x05BD)
         || 0x05BF == ch || (0x05C1 <= ch && ch <= 0x05C2) || 0x05C4 == ch || (0x064B <= ch && ch <= 0x0652)
         || 0x0670 == ch || (0x06D6 <= ch && ch <= 0x06DC) || (0x06DD <= ch && ch <= 0x06DF)
         || (0x06E0 <= ch && ch <= 0x06E4) || (0x06E7 <= ch && ch <= 0x06E8) || (0x06EA <= ch && ch <= 0x06ED)
         || (0x0901 <= ch && ch <= 0x0903) || 0x093C == ch || (0x093E <= ch && ch <= 0x094C) || 0x094D == ch
         || (0x0951 <= ch && ch <= 0x0954) || (0x0962 <= ch && ch <= 0x0963) || (0x0981 <= ch && ch <= 0x0983)
         || 0x09BC == ch || 0x09BE == ch || 0x09BF == ch || (0x09C0 <= ch && ch <= 0x09C4)
         || (0x09C7 <= ch && ch <= 0x09C8) || (0x09CB <= ch && ch <= 0x09CD) || 0x09D7 == ch
         || (0x09E2 <= ch && ch <= 0x09E3) || 0x0A02 == ch || 0x0A3C == ch || 0x0A3E == ch || 0x0A3F == ch
         || (0x0A40 <= ch && ch <= 0x0A42) || (0x0A47 <= ch && ch <= 0x0A48) || (0x0A4B <= ch && ch <= 0x0A4D)
         || (0x0A70 <= ch && ch <= 0x0A71) || (0x0A81 <= ch && ch <= 0x0A83) || 0x0ABC == ch
         || (0x0ABE <= ch && ch <= 0x0AC5) || (0x0AC7 <= ch && ch <= 0x0AC9) || (0x0ACB <= ch && ch <= 0x0ACD)
         || (0x0B01 <= ch && ch <= 0x0B03) || 0x0B3C == ch || (0x0B3E <= ch && ch <= 0x0B43)
         || (0x0B47 <= ch && ch <= 0x0B48) || (0x0B4B <= ch && ch <= 0x0B4D) || (0x0B56 <= ch && ch <= 0x0B57)
         || (0x0B82 <= ch && ch <= 0x0B83) || (0x0BBE <= ch && ch <= 0x0BC2) || (0x0BC6 <= ch && ch <= 0x0BC8)
         || (0x0BCA <= ch && ch <= 0x0BCD) || 0x0BD7 == ch || (0x0C01 <= ch && ch <= 0x0C03)
         || (0x0C3E <= ch && ch <= 0x0C44) || (0x0C46 <= ch && ch <= 0x0C48) || (0x0C4A <= ch && ch <= 0x0C4D)
         || (0x0C55 <= ch && ch <= 0x0C56) || (0x0C82 <= ch && ch <= 0x0C83) || (0x0CBE <= ch && ch <= 0x0CC4)
         || (0x0CC6 <= ch && ch <= 0x0CC8) || (0x0CCA <= ch && ch <= 0x0CCD) || (0x0CD5 <= ch && ch <= 0x0CD6)
         || (0x0D02 <= ch && ch <= 0x0D03) || (0x0D3E <= ch && ch <= 0x0D43) || (0x0D46 <= ch && ch <= 0x0D48)
         || (0x0D4A <= ch && ch <= 0x0D4D) || 0x0D57 == ch || 0x0E31 == ch || (0x0E34 <= ch && ch <= 0x0E3A)
         || (0x0E47 <= ch && ch <= 0x0E4E) || 0x0EB1 == ch || (0x0EB4 <= ch && ch <= 0x0EB9)
         || (0x0EBB <= ch && ch <= 0x0EBC) || (0x0EC8 <= ch && ch <= 0x0ECD) || (0x0F18 <= ch && ch <= 0x0F19)
         || 0x0F35 == ch || 0x0F37 == ch || 0x0F39 == ch || 0x0F3E == ch || 0x0F3F == ch
         || (0x0F71 <= ch && ch <= 0x0F84) || (0x0F86 <= ch && ch <= 0x0F8B) || (0x0F90 <= ch && ch <= 0x0F95)
         || 0x0F97 == ch || (0x0F99 <= ch && ch <= 0x0FAD) || (0x0FB1 <= ch && ch <= 0x0FB7) || 0x0FB9 == ch
         || (0x20D0 <= ch && ch <= 0x20DC) || 0x20E1 == ch || (0x302A <= ch && ch <= 0x302F) || 0x3099 == ch
         || 0x309A == ch;
   }
903801
public boolean isThumbnail() {
    if (tags.containsTagId(254)) {
      if (tags.get(254).getCardinality() > 0)
        return BigInteger.valueOf(tags.get(254).getFirstNumericValue()).testBit(0);
    }
    if (tags.containsTagId(255)) {
      if (tags.get(255).getCardinality() > 0)
        return tags.get(255).getFirstNumericValue() == 2;
    }
    if (hasSubIFD() && getImageSize() < getsubIFD().getImageSize()) {
      return true;
    }
    if (hasParent() && getImageSize() < getParent().getImageSize()) {
      return true;
    }
    return false;
  }
529783
public static boolean isNumeric(String s)
    {
        boolean ret = true;
        for(int i = 0; i < s.length() && ret; i++)
        {
            char c = s.charAt(i);
            ret = (c >= '0' && c <= '9');
        }
        return ret;
    }
624749
public boolean isSet(int bit) {
    int bite = byteForBit(bit);
    if (bite >= bits.length || bits.length == 0) {
      return false;
    }
    int bitOnByte = bitOnByte(bit, bite);
    return ((1 << bitOnByte) & bits[bite]) != 0;
  }
663204
def read_octet(self):
        """"""
        self.bitcount = self.bits = 0
        return unpack('B', self.input.read(1))[0]
1089260
def write_octet(self, n):
        
        if (n < 0) or (n > 255):
            raise ValueError('Octet out of range 0..255')
        self._flushbits()
        self.out.write(pack('B', n))
1102940
protected static boolean isNumeric(String s)
    {
        for (char c : s.toCharArray())
        {
            if (!Character.isDigit(c))
                return false;
        }
        return true;
    }
391031
public static boolean isPrefixFreeCode(final Set<Bits> keySet) {
    final TreeSet<Bits> check = new TreeSet<Bits>();
    for (final Bits code : keySet) {
      final Bits ceiling = check.ceiling(code);
      if (null != ceiling
        && (ceiling.startsWith(code) || code.startsWith(ceiling))) {
        return false;
      }
      final Bits floor = check.floor(code);
      if (null != floor && (floor.startsWith(code) || code.startsWith(floor))) {
        return false;
      }
      check.add(code);
    }
    return true;
  }
919725
public static boolean isDuplicated(final String input) {
    int len = input.length();
    if (len % 2 == 0) {
      int half = len / 2;
      if (hasEqualParts(input, half, half)) {
        return true;
      }
      if (input.substring(half, half + 1).equals(" ")
          && input.substring(half - 1, half).matches("[;,]")) {
        return hasEqualParts(input, half - 1, half + 1);
      }
    } else {
      int half = len / 2;
      String middlePart = input.substring(half - 1, half + 2);
      if (isSpaceCommaSpace(middlePart)) {
        return hasEqualParts(input, half - 1, half + 2);
      } else if (isCommaInTheMiddle(middlePart)
                 || isLineBreakInTheMiddle(middlePart)) {
        return hasEqualParts(input, half, half + 1);
      }
    }
    return false;
  }
1040761
static boolean isAlphanum(int c) {
		return ( (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || 
				 (c >= 'A' && c <= 'Z') || c == '_' || c == '$' || c == '\\' || 
				 c > 126);
	}
1262155
public static boolean isAlphaNumeric(String in) {
		char c = 0;
		for (int i = in.length(); i > 0; i--) {
			c = in.charAt(i - 1);
			if (!Character.isLetterOrDigit(c)) {
				return false;
			}
		}
		return true;
	}
52374
public byte[] getOctets() {
        byte[] octets = new byte[8];
        long bits = this.bits;
        for (int n = 8; --n >= 0; bits >>= 8) {
            octets[n] = (byte) (bits & 0xff);
        }
        return octets;
    }
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;
    }
991212
private boolean isValid(CharSequence text) {
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            // as defined by http://www.w3.org/TR/REC-xml/#charsets.
            boolean valid = c == 0x9 || c == 0xA || c == 0xD
                    || (c >= 0x20 && c <= 0xd7ff)
                    || (c >= 0xe000 && c <= 0xfffd);
            if (!valid) {
                return false;
            }
        }
        return true;
    }