}

        /**
         * Check if lease has handle caching
         *
         * @return true if handle caching is enabled
         */
        public boolean hasHandleCache() {
            return Smb2LeaseState.hasHandleCaching(leaseState);
        }

        /**
         * Gets the unique lease key identifier for this lease entry

     *            {@link PreparedStatement}. Must not be {@literal null}.
     * @return {@link ResultSet}
     * @throws SQLRuntimeException
     *             If a {@link SQLException} occurs.
     */
    public static ResultSet executeQuery(final PreparedStatement ps) throws SQLRuntimeException {
        assertArgumentNotNull("ps", ps);

        try {
            return ps.executeQuery();
        } catch (final SQLException ex) {

            }
            return entity;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });

        return asJson(new ApiUpdateResponse().id(dataConfig.getId()).created(true).status(Status.OK).result());
    }

    /**

    }
  }

  double sumOfProductsOfDeltas() {
    return sumOfProductsOfDeltas;
  }

  private static double ensurePositive(double value) {
    if (value > 0.0) {
      return value;
    } else {
      return Double.MIN_VALUE;
    }
  }

  private static double ensureInUnitRange(double value) {
    if (value >= 1.0) {
      return 1.0;
    }
    if (value <= -1.0) {
      return -1.0;

  override fun createSocket(): SSLSocket {
    val sslSocket = delegate.createSocket() as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(host, port) as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(

	return os.Stat(name)
}

// Create captures time taken to call os.Create
func Create(name string) (f *os.File, err error) {
	defer updateOSMetrics(osMetricCreate, name)(err)
	return os.Create(name)
}

// Fdatasync captures time taken to call Fdatasync
func Fdatasync(f *os.File) (err error) {
	fn := ""
	if f != nil {
		fn = f.Name()
	}
	defer updateOSMetrics(osMetricFdatasync, fn)(err)

    @Override
    protected String getNamePrefix() {
        return NAME_PREFIX;
    }

    @Override
    protected String getApiPath() {
        return API_PATH;
    }

    @Override
    protected String getKeyProperty() {
        return KEY_PROPERTY;
    }

    @Override
    protected String getListEndpointSuffix() {
        return LIST_ENDPOINT_SUFFIX;
    }

    @Override

  operator fun set(
    hostname: String,
    addresses: List<InetAddress>,
  ): FakeDns {
    hostAddresses[hostname] = addresses
    return this
  }

  /** Clears the results for `hostname`.  */
  fun clear(hostname: String): FakeDns {
    hostAddresses.remove(hostname)
    return this
  }

  @Throws(UnknownHostException::class)
  fun lookup(
    hostname: String,
    index: Int,

        return i > 0;
      }

      @Override
      public int nextIndex() {
        return i;
      }

      @Override
      public String previous() {
        if (!hasPrevious()) {
          throw new NoSuchElementException();
        }
        return array[--i];
      }

      @Override
      public int previousIndex() {
        return i - 1;
      }
    };
  }

        return i > 0;
      }

      @Override
      public int nextIndex() {
        return i;
      }

      @Override
      public String previous() {
        if (!hasPrevious()) {
          throw new NoSuchElementException();
        }
        return array[--i];
      }

      @Override
      public int previousIndex() {
        return i - 1;
      }
    };
  }