Converts an uncompressed String representation in an Guid-object
@param uncompressedGuidString the uncompressed String representation of a GUID
@return an Guid-object
778595
public static Guid getGuidFromUncompressedString(String uncompressedGuidString){
		String[] parts = uncompressedGuidString.split("-");
		Guid guid = new Guid();
		guid.Data1 = Long.parseLong(parts[0], 16);
		guid.Data2 = Integer.parseInt(parts[1],16);
		guid.Data3 = Integer.parseInt(parts[2], 16);
		
		String temp;
		
		temp = parts[3];
		guid.Data4[0] = (char) Integer.parseInt(temp.substring(0, 2), 16);
		guid.Data4[1] = (char) Integer.parseInt(temp.substring(2, 4), 16);
		 
		temp = parts[4];
		guid.Data4[2] = (char) Integer.parseInt(temp.substring(0, 2), 16);
		guid.Data4[3] = (char) Integer.parseInt(temp.substring(2, 4), 16);
		guid.Data4[4] = (char) Integer.parseInt(temp.substring(4, 6), 16);
		guid.Data4[5] = (char) Integer.parseInt(temp.substring(6, 8), 16);
		guid.Data4[6] = (char) Integer.parseInt(temp.substring(8, 10), 16);
		guid.Data4[7] = (char) Integer.parseInt(temp.substring(10, 12), 16);
		
		return guid;
	}
359763
def _from_string(cls, serialized):
        
        parse = cls.parse_url(serialized)

        if parse['version_guid']:
            parse['version_guid'] = cls.as_object_id(parse['version_guid'])

        return cls(**{key: parse.get(key) for key in cls.KEY_FIELDS})
293959
public static String uncompressGuidString(String compressedString) throws InvalidGuidException{
		Guid guid = new Guid();
		getGuidFromCompressedString(compressedString, guid);
		return getUncompressedStringFromGuid(guid);
	}
1189838
public static Guid deserialize(String str) throws IOException {
    if (str.length() != 2 * GUID_LENGTH) {
      throw new IOException("String is not an encoded guid.");
    }
    try {
      return new Guid(Hex.decodeHex(str.toCharArray()), true);
    } catch (DecoderException de) {
      throw new IOException(de);
    }
  }
602097
public static function GUid(): string
    {
        mt_srand((double)microtime() * 10000);

        $charId = strtolower(md5(uniqid(mt_rand(), true)));
        // $hyphen = chr(45);
        $uuid = substr($charId, 0, 8) .
            substr($charId, 8, 4) .
            substr($charId, 12, 4) .
            substr($charId, 16, 4) .
            substr($charId, 20, 12);

        return $uuid;
    }
406212
protected String keyToString(Object rawKey)
    {
        if (rawKey instanceof String) {
            return (String) rawKey;
        }
        return String.valueOf(rawKey);
    }
694996
@SuppressWarnings("unchecked")
    public static <D> Mapping<D, String> toStringMapping() {
        return (Mapping<D, String>) TOSTRING_MAPPING;
    }
289981
def guid_check_convert(guid, allow_none=False):
        
        if isinstance(guid, string_types):
            return ensure_unicode(UUID(guid).hex)
        elif guid is None and allow_none:
            return None
        else:
            raise ValueError('guid must be a string')
180337
public static byte[] compress(String s, String encoding)
            throws UnsupportedEncodingException, IOException
    {
        byte[] data = s.getBytes(encoding);
        return compress(data);
    }
664539
public static byte[] getGuidAsByteArray(final String GUID) {
        final UUID uuid = UUID.fromString(GUID);

        final ByteBuffer buff = ByteBuffer.wrap(new byte[16]);
        buff.putLong(uuid.getMostSignificantBits());
        buff.putLong(uuid.getLeastSignificantBits());

        byte[] res = new byte[] {
            buff.get(3),
            buff.get(2),
            buff.get(1),
            buff.get(0),
            buff.get(5),
            buff.get(4),
            buff.get(7),
            buff.get(6),
            buff.get(8),
            buff.get(9),
            buff.get(10),
            buff.get(11),
            buff.get(12),
            buff.get(13),
            buff.get(14),
            buff.get(15), };

        return res;
    }
989627
@SneakyThrows
    public static String decompress(final String zippedBase64Str) {
        val bytes = EncodingUtils.decodeBase64(zippedBase64Str);
        try (val zi = new GZIPInputStream(new ByteArrayInputStream(bytes))) {
            return IOUtils.toString(zi, Charset.defaultCharset());
        }
    }
154200
public static String getUncompressedStringFromGuid(Guid guid){
		String result = new String();
		result += String.format("%1$08x", guid.Data1); 
		result += "-";
		result += String.format("%1$04x", guid.Data2); 
		result += "-";
		result += String.format("%1$04x", guid.Data3); 
		result += "-";
		result += String.format("%1$02x%2$02x", (int)guid.Data4[0], (int)guid.Data4[1]); 
		result += "-";
		result += String.format("%1$02x%2$02x%3$02x%4$02x%5$02x%6$02x", (int)guid.Data4[2], (int)guid.Data4[3], (int)guid.Data4[4], (int)guid.Data4[5], (int)guid.Data4[6], (int)guid.Data4[7]); 
		return result;
	}
1250277
public static Date parseCompressedISO8601Date(String dateString) {
        try {
            return new Date(compressedIso8601DateFormat.parseMillis(dateString));
        } catch (RuntimeException ex) {
            throw handleException(ex);
        }
   }
820099
private static int writeUncompressedLength(byte[] compressed, int compressedOffset, int uncompressedLength) {
        int highBitMask = 0x80;
        if (uncompressedLength < (1 << 7) && uncompressedLength >= 0) {
            compressed[compressedOffset++] = (byte) (uncompressedLength);
        } else if (uncompressedLength < (1 << 14) && uncompressedLength > 0) {
            compressed[compressedOffset++] = (byte) (uncompressedLength | highBitMask);
            compressed[compressedOffset++] = (byte) (uncompressedLength >>> 7);
        } else if (uncompressedLength < (1 << 21) && uncompressedLength > 0) {
            compressed[compressedOffset++] = (byte) (uncompressedLength | highBitMask);
            compressed[compressedOffset++] = (byte) ((uncompressedLength >>> 7) | highBitMask);
            compressed[compressedOffset++] = (byte) (uncompressedLength >>> 14);
        } else if (uncompressedLength < (1 << 28) && uncompressedLength > 0) {
            compressed[compressedOffset++] = (byte) (uncompressedLength | highBitMask);
            compressed[compressedOffset++] = (byte) ((uncompressedLength >>> 7) | highBitMask);
            compressed[compressedOffset++] = (byte) ((uncompressedLength >>> 14) | highBitMask);
            compressed[compressedOffset++] = (byte) (uncompressedLength >>> 21);
        } else {
            compressed[compressedOffset++] = (byte) (uncompressedLength | highBitMask);
            compressed[compressedOffset++] = (byte) ((uncompressedLength >>> 7) | highBitMask);
            compressed[compressedOffset++] = (byte) ((uncompressedLength >>> 14) | highBitMask);
            compressed[compressedOffset++] = (byte) ((uncompressedLength >>> 21) | highBitMask);
            compressed[compressedOffset++] = (byte) (uncompressedLength >>> 28);
        }
        return compressedOffset;
    }
616188
private static int[] uncompressTheSurprisingValues(final CompressedState source) {
    final int srcK = 1 << source.lgK;
    final int numPairs = source.numCsv;
    assert numPairs > 0;
    final int[] pairs = new int[numPairs];
    final int numBaseBits = CpcCompression.golombChooseNumberOfBaseBits(srcK + numPairs, numPairs);
    lowLevelUncompressPairs(pairs, numPairs, numBaseBits, source.csvStream, source.csvLengthInts);
    return pairs;
  }
934148
private static function uncompressByteString($string)
    {
        $uncompressedString = '';
        $strLen = strlen($string);
        for ($i = 0; $i < $strLen; ++$i) {
            $uncompressedString .= $string[$i] . "\0";
        }

        return $uncompressedString;
    }
410209
public static String decodeString(String encoded)
    {
        return decodeString(encoded,0,encoded.length(),StringUtil.__ISO_8859_1);
    }