t[j] = '%'
			t[j+1] = "0123456789ABCDEF"[c>>4]
			t[j+2] = "0123456789ABCDEF"[c&15]
			j += 3
		default:
			t[j] = s[i]
			j++
		}
	}
	return string(t)
}

// s3EncodeName encodes string in response when encodingType is specified in AWS S3 requests.
func s3EncodeName(name, encodingType string) string {
	if strings.ToLower(encodingType) == "url" {
		return s3URLEncode(name)
	}
	return name
}

          }
        listener.onFailure(this, exception, response)
        return
      }
      if (canceled) {
        listener.onFailure(this, IOException("canceled"), response)
      } else {
        listener.onClosed(this)
      }
    }
  }

  private fun ResponseBody.isEventStream(): Boolean {
    val contentType = contentType() ?: return false
    return contentType.type == "text" && contentType.subtype == "event-stream"

     *
     * @param data the request data to be executed
     * @return the response data from the executed request
     */
    ResponseData execute(RequestData data);

    /**
     * Closes the crawler client and releases any resources associated with it.
     * This default implementation does nothing.
     *
     * @throws Exception if an error occurs during closing
     */
    @Override

     */
    SmbTreeHandle getTree();

    /**
     * Checks if this file handle is still valid
     *
     * @return whether the file descriptor is valid
     */
    boolean isValid();

    /**
     * Closes this file handle and optionally sets the last write time
     *
     * @param lastWriteTime the last write time to set, or 0 to leave unchanged
     * @throws CIFSException if an error occurs while closing the file
     */

 * </p>
 *
 * @author higa
 */
public abstract class Base64Util {

    /**
     * Do not instantiate.
     */
    protected Base64Util() {
    }

    /**
     * Encodes data in Base64.
     * <p>
     * This method uses {@link java.util.Base64.Encoder} for encoding.
     * </p>
     *
     * @param inData
     *            The data to encode

        if (!isTarget(path)) {
            return null;
        }

        return newDictionaryFile(encodePath(path), path, timestamp);
    }

    /**
     * Encodes a file path using Base64 URL-safe encoding.
     *
     * @param path the file path to encode
     * @return the Base64 encoded path
     */
    protected String encodePath(final String path) {

import okhttp3.Headers
import okhttp3.Request
import okhttp3.Response
import okhttp3.Route
import okhttp3.internal.connection.RealCall
import okio.Sink
import okio.Socket
import okio.Source

/** Encodes HTTP requests and decodes HTTP responses. */
interface ExchangeCodec {
  /** The connection or CONNECT tunnel that owns this codec. */
  val carrier: Carrier

      if (declaringClass.getEnclosingConstructor() != null) {
        // Enclosed in a constructor, needs hidden this
        return true;
      }
      Method enclosingMethod = declaringClass.getEnclosingMethod();
      if (enclosingMethod != null) {
        // Enclosed in a method, if it's not static, must need hidden this.
        return !Modifier.isStatic(enclosingMethod.getModifiers());

            return new ByteArrayInputStream(contents.getBytes(encoding));
        } catch (final UnsupportedEncodingException ex) {
            throw new IORuntimeException(ex);
        }
    }

    /**
     * Encodes the value of an attribute.
     *
     * @param s
     *            The attribute value.
     * @return The encoded attribute value.
     */
    public static String encodeAttrQuot(final String s) {

	if err != nil {
		return err
	}

	if dexp.Days <= 0 {
		return errInvalidDaysDelMarkerExpiration
	}

	*de = DelMarkerExpiration(dexp)
	return nil
}

// MarshalXML encodes a DelMarkerExpiration value into an XML element
func (de DelMarkerExpiration) MarshalXML(enc *xml.Encoder, start xml.StartElement) error {
	if de.Empty() {
		return nil
	}

	type delMarkerExpiration DelMarkerExpiration