Not supported at this time.
11457
@Override
    public Parser newFixedLengthParser(final Connection con, final InputStream dataSourceStream, final String dataDefinition) {
        throw new UnsupportedOperationException("Not supported...");
    }
402059
function unsupportedAction(res, statusCode, data) {

  return res.status(data
    ? statusCode
    : status.UNSUPPORTED_ACTION).json(data || statusCode || {
    message: 'Unsupported Action'
  });
}
472800
def _validate_if_patch_supported(self, headers, uri):
        """"""
        if not self._operation_allowed(headers, 'PATCH'):
                msg = ('PATCH Operation not supported on the resource '
                       '"%s"' % uri)
                raise exception.IloError(msg)
788758
def cancelled(self):
        """"""
        self._refresh_and_update()
        return (
            self._operation.HasField("error")
            and self._operation.error.code == code_pb2.CANCELLED
        )
172223
public function isPrestashopVersionSupported($version)
    {
        if (version_compare($version, self::PS_COMPATIBLE_VERSION_MIN, '>=') === false ||
            version_compare($version, self::PS_COMPATIBLE_VERSION_MAX, '<=') === false
        ) {
            $exception = 'This library is not compatible with this version of PrestaShop. ';
            $exception.= 'Please upgrade/downgrade this library';
            throw new PrestashopWebServiceException($exception);
        }
    }
380884
def update(self):
        """"""
        _LOGGER.debug("Querying the device..")
        time = datetime.now()
        value = struct.pack('BBBBBBB', PROP_INFO_QUERY,
                            time.year % 100, time.month, time.day,
                            time.hour, time.minute, time.second)

        self._conn.make_request(PROP_WRITE_HANDLE, value)
361880
def _is_version_supported_method(container, method_version):
        
        tmos_v = container._meta_data['bigip'].tmos_version
        if LooseVersion(tmos_v) < LooseVersion(method_version):
            error = "There was an attempt to use a method which " \
                    "has not been implemented or supported " \
                    "in the device's TMOS version: %s. " \
                    "Minimum TMOS version supported is %s" % (
                        tmos_v, method_version)
            raise UnsupportedTmosVersion(error)
999605
def support(self, version):
        

        if not self._known_version(version):
            warn("unknown feature: %s"%version)
            return True
        else:
            if not self._get_featureset_support(version):
                warn("You are not supporting %s anymore "%str(version), UserWarning, self.level)
            if self._alone_version(version):
                warn("%s is the last supported feature of this group, you can simplifiy this logic. "%str(version), UserWarning,self.level)
                
            return self.predicates.get(version, True)




        if (not self.PY3_supported) or (not self.PY2_supported):
            warn("You are only supporting 1 version of Python", UserWarning, self.level)

        if version == PY3:
            return sys.version_info.major == 3
        elif version == PY2:
            return sys.version_info.major == 2
133187
def is_supported(value, check_all=False, filters=None, iterate=False):
    """"""
    assert filters is not None
    if value is None:
        return True
    if not is_editable_type(value):
        return False
    elif not isinstance(value, filters):
        return False
    elif iterate:
        if isinstance(value, (list, tuple, set)):
            valid_count = 0
            for val in value:
                if is_supported(val, filters=filters, iterate=check_all):
                    valid_count += 1
                if not check_all:
                    break
            return valid_count > 0
        elif isinstance(value, dict):
            for key, val in list(value.items()):
                if not is_supported(key, filters=filters, iterate=check_all) \
                   or not is_supported(val, filters=filters,
                                       iterate=check_all):
                    return False
                if not check_all:
                    break
    return True
1294937
public static boolean supportsNative() {
        if (!testedLibLoading) {
            LiblasJNALibrary wrapper = LiblasWrapper.getWrapper();
            if (wrapper != null) {
                isNativeLibAvailable = true;
            }
            testedLibLoading = true;
        }
        return isNativeLibAvailable;
    }
257173
def device_not_active(self, addr):
        """"""
        self.aldb_device_handled(addr)
        for callback in self._cb_device_not_active:
            callback(addr)
462106
static UnsupportedOperationException unsupported(String message, String str, int pos) {
    return new UnsupportedOperationException(message + "\n" + context(str, pos));
  }
1139290
public static function checkPcreSupport(): void
	{
		static $supported = null;

		if ($supported === null) {
			$supported = @preg_match('/\pL/u', 'a') === 1;
		}

		if (!$supported) {
			throw new \RuntimeException(sprintf('Missing PCRE unicode support'));
		}
	}
580660
def out_of_date(self):
        """"""
        try:
            latest_remote_sha = self.pr_commits(self.pull_request.refresh(True))[-1].sha
            print("Latest remote sha: {}".format(latest_remote_sha))
            try:
                print("Ratelimit remaining: {}".format(self.github.ratelimit_remaining))
            except Exception:
                print("Failed to look up ratelimit remaining")
            return self.last_sha != latest_remote_sha
        except IndexError:
            return False
1119631
def up(self):
        '''  '''

        # Get existing device flags
        ifreq = struct.pack('16sh', self.name, 0)
        flags = struct.unpack('16sh', fcntl.ioctl(sockfd, SIOCGIFFLAGS, ifreq))[1]

        # Set new flags
        flags = flags | IFF_UP
        ifreq = struct.pack('16sh', self.name, flags)
        fcntl.ioctl(sockfd, SIOCSIFFLAGS, ifreq)
233654
def support_zrangebylex(self):
        
        if not hasattr(self, '_support_zrangebylex'):
            try:
                self._support_zrangebylex = self.redis_version >= (2, 8, 9) \
                    and hasattr(self.connection, 'zrangebylex')
            except:
                self._support_zrangebylex = False
        return self._support_zrangebylex
789920
private void checkIfUseDb(final DeviceProxy deviceProxy, final String origin) throws DevFailed {
        if (!deviceProxy.url.use_db) {
            Except.throw_non_db_exception("Api_NonDatabaseDevice", "Device " + name(deviceProxy)
                + " do not use database", "DeviceProxy(" + name(deviceProxy) + ")." + origin);
        }
    }