int bytesPerSect;

        @Override
        public long getCapacity() {
            return alloc * sectPerAlloc * bytesPerSect;
        }

        @Override
        public long getFree() {
            return free * sectPerAlloc * bytesPerSect;
        }

        @Override
        public String toString() {

    }

    /**
     * Check if negotiation was successful
     *
     * @return true if successful, false otherwise
     */
    public boolean isSuccess() {
        return status == 0;
    }

    /**
     * Get negotiation status
     *
     * @return status code (0 = success)
     */
    public int getStatus() {
        return status;
    }

    /**
     * Set negotiation status
     *

		if kvs.Empty() {
			return cfg, nil
		}
		return cfg, err
	}
	if !cfg.Enabled {
		return cfg, nil
	}

	allowEnc := env.Get(EnvCompressAllowEncryption, "")
	if allowEnc == "" {
		allowEnc = env.Get(EnvCompressAllowEncryptionLegacy, kvs.Get(AllowEncrypted))
	}

	cfg.AllowEncrypted, err = config.ParseBool(allowEnc)
	if err != nil {
		return cfg, err
	}

    }
    
    public long getIdleTime() {
        return System.currentTimeMillis() - lastActivityTime;
    }
    
    public boolean isHealthy() {
        return state == ChannelState.ACTIVE || state == ChannelState.ESTABLISHED;
    }
    
    public double getErrorRate() {
        long total = requestsSent.get();
        if (total == 0) return 0.0;
        return (double) errors.get() / total;
    }
    

      if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
        return set.headSet(lastInclusive, true);
      } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
        return set.tailSet(firstExclusive, false);
      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
        return set.subSet(firstExclusive, false, lastExclusive, false);

    }

    @Override
    public int add(E element, int occurrences) {
      checkArgument(occurrences >= 0);
      Integer frequency = backingMap.getOrDefault(element, 0);
      if (occurrences == 0) {
        return frequency;
      }
      checkArgument(occurrences <= Integer.MAX_VALUE - frequency);
      backingMap.put(element, frequency + occurrences);
      return frequency;
    }

    @Override

            if (pos > 0) {
                return value.substring(0, pos);
            }
            if (pos == -1) {
                return value;
            }
            return "localhost";
        }
        if (url.startsWith("file:")) {
            return "localhost";
        }

        return getHost(url);
    }

    /**
     * Get the role types.

    /**
     * Retrieves a specific role setting by ID.
     *
     * @param id the ID of the role setting to retrieve
     * @return JSON response containing the role setting
     */
    // GET /api/admin/role/setting/{id}
    @Execute
    public JsonResponse<ApiResult> get$setting(final String id) {
        return asJson(new ApiResult.ApiConfigResponse().setting(roleService.getRole(id).map(this::createEditBody).orElseGet(() -> {

            return cfg.getBatchLimit("TreeConnectAndX.OpenAndX");
        case SMB_COM_RENAME:
            return cfg.getBatchLimit("TreeConnectAndX.Rename");
        case SMB_COM_TRANSACTION:
            return cfg.getBatchLimit("TreeConnectAndX.Transaction");
        case SMB_COM_QUERY_INFORMATION:
            return cfg.getBatchLimit("TreeConnectAndX.QueryInformation");
        }
        return 0;
    }

    @Override

                return GIGABYTE;
            } else if (size >= MEGABYTE.bytes()) {
                return MEGABYTE;
            } else if (size >= KILOBYTE.bytes()) {
                return KILOBYTE;
            } else {
                return BYTE;
            }
        }
    }

    public String format(long size) {
        return format(size, null);
    }