Fallback when checking CompressedOopsEnabled.
349526
@SuppressFBWarnings("NP_BOOLEAN_RETURN_NULL")
    static Boolean isObjectLayoutCompressedOopsOrNull() {
        if (!UNSAFE_AVAILABLE) {
            return null;
        }

        Integer referenceSize = ReferenceSizeEstimator.getReferenceSizeOrNull();
        if (referenceSize == null) {
            return null;
        }

        // when reference size does not equal address size then it's safe to assume references are compressed
        return referenceSize != UNSAFE.addressSize();
    }
561687
def _get_more_compressed(collection_name, num_to_return, cursor_id, ctx):
    """"""
    return _compress(
        2005, _get_more(collection_name, num_to_return, cursor_id), ctx)
209231
public boolean shouldCompress(String requestUri) {
		String uri = requestUri.toLowerCase();
		return checkSuffixes(uri, zipSuffixes);
	}
1105828
def _update_compressed(
        collection_name, upsert, multi, spec, doc, check_keys, opts, ctx):
    """"""
    op_update, max_bson_size = _update(
        collection_name, upsert, multi, spec, doc, check_keys, opts)
    rid, msg = _compress(2001, op_update, ctx)
    return rid, msg, max_bson_size
22935
def is_zero_bytes_file(self, path):
        """"""
        return self._getReturnCodeCmd([self._hadoop_cmd, 'fs', '-test', '-z', self._full_hdfs_path(path)]) == 0
902910
def _insert_uncompressed(collection_name, docs, check_keys,
            safe, last_error_args, continue_on_error, opts):
    """"""
    op_insert, max_bson_size = _insert(
        collection_name, docs, check_keys, continue_on_error, opts)
    rid, msg = __pack_message(2002, op_insert)
    if safe:
        rid, gle, _ = __last_error(collection_name, last_error_args)
        return rid, msg + gle, max_bson_size
    return rid, msg, max_bson_size
88951
def check_program_compression(archive, command, program, compression):
    """"""
    program = os.path.basename(program)
    if compression:
        # check if compression is supported
        if not program_supports_compression(program, compression):
            if command == 'create':
                comp_command = command
            else:
                comp_command = 'extract'
            comp_prog = find_archive_program(compression, comp_command)
            if not comp_prog:
                msg = "cannot %s archive `%s': compression `%s' not supported"
                raise util.PatoolError(msg % (command, archive, compression))
861922
def comparable(self):
    """"""
    sub_comparable_string = (
        'compression_method: {0:s}').format(self.compression_method)
    return self._GetComparable(sub_comparable_string=sub_comparable_string)
1326126
def _compress(self):
        """"""

        # Don't compress too often
        now = time.time()
        if self._last_compression + self._compression_timer < now:
            self._last_compression = now
            for key in list(self._store.keys()):
                self.get(key)
399260
def _corrupt(self, data, dpos):
        """"""
        ws = list(self._BLK_BE.unpack_from(data, dpos))
        for t in range(16, 80):
            tmp = ws[(t - 3) & 15] ^ ws[(t - 8) & 15] ^ ws[(t - 14) & 15] ^ ws[(t - 16) & 15]
            ws[t & 15] = ((tmp << 1) | (tmp >> (32 - 1))) & 0xFFFFFFFF
        self._BLK_LE.pack_into(data, dpos, *ws)
106109
public void checkCanceled(final ResourceSet rs) {
    if ((rs instanceof XtextResourceSet)) {
      if ((((XtextResourceSet)rs).isOutdated() && (this.cancelationAllowed.get()).booleanValue())) {
        this.canceledManager.throwOperationCanceledException();
      }
    }
  }
1114635
def rm_compressed(ctx, dataset, kwargs):
    ""

    kwargs = parse_kwargs(kwargs)
    data(dataset, **ctx.obj).rm_compressed(**kwargs)
562530
def is_greater_then_zero_bytes(self, path):
        """"""
        return self._getReturnCodeCmd([self._hadoop_cmd, 'fs', '-test', '-s', self._full_hdfs_path(path)]) == 0
1305921
@SuppressFBWarnings("NP_BOOLEAN_RETURN_NULL")
    static Boolean isHotSpotCompressedOopsOrNull() {
        try {
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            ObjectName mbean = new ObjectName("com.sun.management:type=HotSpotDiagnostic");
            Object[] objects = {"UseCompressedOops"};
            String[] strings = {"java.lang.String"};
            String operation = "getVMOption";
            CompositeDataSupport compressedOopsValue = (CompositeDataSupport) server.invoke(mbean, operation, objects, strings);
            return Boolean.valueOf(compressedOopsValue.get("value").toString());
        } catch (Exception e) {
            getLogger(JVMUtil.class).fine("Failed to read HotSpot specific configuration: " + e.getMessage());
        }
        return null;
    }
323008
private static boolean _isAlreadyCompressed (final String sFilename)
  {
    for (final String sExt : EXTENSIONS_JS_COMPRESSED)
      if (sFilename.endsWith (sExt))
        return true;
    return false;
  }
23886
@Override
    protected boolean isCompressionAllowed() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "isCompressionAllowed");
        }
        // 1.1 will always allow compression, but 1.0 will only work with one
        // single finishRequest call since we cannot do streaming compression
        // with the request message
        boolean rc = true;
        if (!getRequest().getVersionValue().equals(VersionValues.V11)) {
            rc = !isPartialBody();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "isCompressionAllowed: " + rc);
        }
        return rc;
    }
132451
private boolean isLoopExitCondition() {
		while (workingDirectory.index == workingDirectory.files.length) {
			if (stack.isEmpty()) {
				return true;
			}
			pop();
		}
		return false;
	}