message = "moved to val",
    replaceWith = ReplaceWith(expression = "url"),
    level = DeprecationLevel.ERROR,
  )
  fun url(): HttpUrl = url

  @JvmName("-deprecated_dns")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "dns"),
    level = DeprecationLevel.ERROR,
  )
  fun dns(): Dns = dns

  @JvmName("-deprecated_socketFactory")
  @Deprecated(

     */
    public String url;

    /**
     * The minimum error count field for filtering failure URLs.
     */
    public String errorCountMin;

    /**
     * The maximum error count field for filtering failure URLs.
     */
    public String errorCountMax;

    /**
     * The error name field for searching failure URLs by error type.
     */
    public String errorName;

    }

    /**
     * Handle channel failure
     *
     * @param failedChannel failed channel
     * @param error error that caused failure
     */
    public void handleFailure(ChannelInfo failedChannel, Exception error) {
        log.warn("Channel {} failed: {}", failedChannel.getChannelId(), error.getMessage());

        // Mark channel as failed
        failedChannel.setState(ChannelState.FAILED);

func (d DeleteReplication) Validate() error {
	if d.IsEmpty() {
		return errDeleteReplicationMissing
	}
	if d.Status != Disabled && d.Status != Enabled {
		return errInvalidDeleteReplicationStatus
	}
	return nil
}

// UnmarshalXML - decodes XML data.
func (d *DeleteReplication) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) (err error) {
	// Make subtype to avoid recursive UnmarshalXML().

     * @param request the request to create a key for
     * @throws IOException if an I/O error occurs
     */
    protected abstract void makeKey(Request request) throws IOException;

    /**
     * Reads and returns the key of the next message without consuming it.
     *
     * @return the request key of the next message
     * @throws IOException if an I/O error occurs
     */
    protected abstract Request peekKey() throws IOException;

   * (That would also have ensured that its cause was always an Error, rather than possibly another
   * kind of Throwable that was later passed to initCause. Then we could have declared the override
   * `public final Error getCause()`.)
   */

  /**
   * Creates a new instance with {@code null} as its detail message and no cause.
   *
   * @deprecated Prefer {@linkplain ExecutionError(Error)} a constructor that accepts a cause: Users

)

type errPos [2]int // line number, byte offset where error occurred

// DecoderError contains a detailed decoding error.
type DecoderError struct {
	msg       string // description of error
	context   string // additional error context
	pos       errPos
	atChar    byte
	readerErr error // underlying reader error, if any
}

// ReaderErr returns the underlying error.
func (e DecoderError) ReaderErr() error { return e.readerErr }

		t.Error(err)
	}
	// Build simple token with updated expiration claim
	token := jwtgo.NewWithClaims(jwtgo.SigningMethodHS256, claimsMap)
	tokenString, err := token.SignedString(signKey)
	if err != nil {
		t.Error(err)
	}

	// Parse token to be sure it is valid
	err = jwtm.ParseWithClaims(tokenString, claimsMap, func(*jwtm.MapClaims) ([]byte, error) {
		return signKey, nil
	})

        return LaRequestUtil.getOptionalRequest().map(req -> (T) req.getAttribute(name)).orElse(null);
    }

    /**
     * Sets an error in the current request with the specified status code and message.
     *
     * @param statusCode The HTTP status code
     * @param message The error message
     */
    public static void setError(final int statusCode, final String message) {

			case errFileNotFound.Error():
				fallthrough
			case errVolumeNotFound.Error():
				fallthrough
			case errFileVersionNotFound.Error():
				continue
			}
		}
		return false
	}
	return len(errs) > 0
}

// isAllBucketsNotFound will return true if all the errors are either errFileNotFound
// or errFileCorrupt
// A 0 length slice will always return false.
func isAllBucketsNotFound(errs []error) bool {