protected HttpsURLConnectionImpl(URL u) throws IOException 
{
        super(u);
}

 HttpsURLConnectionImpl(URL u,
    Handler handler) throws IOException 
{
//    HttpsURLConnectionOldImpl(URL u, Handler handler) throws IOException {
        this(u, null, handler);
}

 HttpsURLConnectionImpl(URL u,
    Proxy p,
    Handler handler) throws IOException 
{
//    HttpsURLConnectionOldImpl(URL u, Proxy p, Handler handler) throws IOException {
        super(u);
        delegate = new DelegateHttpsURLConnection(url, p, handler, this);
}

 public  void addRequestProperty(String key,
    String value) 
{
        delegate.addRequestProperty(key, value);
}

Adds a general request property specified by a key-value pair. This method will not overwrite existing values associated with the same key.

 public  void connect() throws IOException 
{
        delegate.connect();
}

Implements the HTTP protocol handler's "connect" method, establishing an SSL connection to the server as necessary.

 public  void disconnect() 
{
        delegate.disconnect();
}

Disconnect from the server.

 public boolean equals(Object obj) 
{
        return delegate.equals(obj);
}

 protected  void finalize() throws Throwable 
{
        delegate.dispose();
}

 public boolean getAllowUserInteraction() 
{
        return delegate.getAllowUserInteraction();
}

 public String getCipherSuite() 
{
        return delegate.getCipherSuite();
}

Returns the cipher suite in use on this connection.

 public int getConnectTimeout() 
{
        return delegate.getConnectTimeout();
}

 public Object getContent() throws IOException 
{
        return delegate.getContent();
}

 public Object getContent(Class[] classes) throws IOException 
{
        return delegate.getContent(classes);
}

 public String getContentEncoding() 
{
        return delegate.getContentEncoding();
}

 public int getContentLength() 
{
        return delegate.getContentLength();
}

 public long getContentLengthLong() 
{
        return delegate.getContentLengthLong();
}

 public String getContentType() 
{
        return delegate.getContentType();
}

 public long getDate() 
{
        return delegate.getDate();
}

 public boolean getDefaultUseCaches() 
{
        return delegate.getDefaultUseCaches();
}

 public boolean getDoInput() 
{
        return delegate.getDoInput();
}

 public boolean getDoOutput() 
{
        return delegate.getDoOutput();
}

 public InputStream getErrorStream() 
{
        return delegate.getErrorStream();
}

 public long getExpiration() 
{
        return delegate.getExpiration();
}

 public String getHeaderField(String name) 
{
        return delegate.getHeaderField(name);
}

Gets a header field by name. Returns null if not known.

 public String getHeaderField(int n) 
{
        return delegate.getHeaderField(n);
}

Gets a header field by index. Returns null if not known.

 public long getHeaderFieldDate(String name,
    long Default) 
{
        return delegate.getHeaderFieldDate(name, Default);
}

 public int getHeaderFieldInt(String name,
    int Default) 
{
        return delegate.getHeaderFieldInt(name, Default);
}

 public String getHeaderFieldKey(int n) 
{
        return delegate.getHeaderFieldKey(n);
}

Gets a header field by index. Returns null if not known.

 public long getHeaderFieldLong(String name,
    long Default) 
{
        return delegate.getHeaderFieldLong(name, Default);
}

 public Map getHeaderFields() 
{
        return delegate.getHeaderFields();
}

Returns an unmodifiable Map of the header fields. The Map keys are Strings that represent the response-header field names. Each Map value is an unmodifiable List of Strings that represents the corresponding field values.

 public long getIfModifiedSince() 
{
        return delegate.getIfModifiedSince();
}

 public synchronized InputStream getInputStream() throws IOException 
{
        return delegate.getInputStream();
}

 public boolean getInstanceFollowRedirects() 
{
        return delegate.getInstanceFollowRedirects();
}

 public long getLastModified() 
{
        return delegate.getLastModified();
}

 public Certificate[] getLocalCertificates() 
{
        return delegate.getLocalCertificates();
}

Returns the certificate chain the client sent to the server, or null if the client did not authenticate.

 public Principal getLocalPrincipal() 
{
        return delegate.getLocalPrincipal();
}

Returns the principal the client sent to the server, or null if the client did not authenticate.

 public synchronized OutputStream getOutputStream() throws IOException 
{
        return delegate.getOutputStream();
}

 public Principal getPeerPrincipal() throws SSLPeerUnverifiedException 
{
        return delegate.getPeerPrincipal();
}

Returns the principal with which the server authenticated itself, or throw a SSLPeerUnverifiedException if the server did not authenticate.

 public Permission getPermission() throws IOException 
{
        return delegate.getPermission();
}

 public int getReadTimeout() 
{
        return delegate.getReadTimeout();
}

 public String getRequestMethod() 
{
        return delegate.getRequestMethod();
}

 public Map getRequestProperties() 
{
        return delegate.getRequestProperties();
}

Returns an unmodifiable Map of general request properties for this connection. The Map keys are Strings that represent the request-header field names. Each Map value is a unmodifiable List of Strings that represents the corresponding field values.

 public String getRequestProperty(String key) 
{
        return delegate.getRequestProperty(key);
}

 public int getResponseCode() throws IOException 
{
        return delegate.getResponseCode();
}

Overwrite super class method

 public String getResponseMessage() throws IOException 
{
        return delegate.getResponseMessage();
}

 public X509Certificate[] getServerCertificateChain() 
{
        try {
            return delegate.getServerCertificateChain();
        } catch (SSLPeerUnverifiedException e) {
            // this method does not throw an exception as declared in
            // com.sun.net.ssl.HttpsURLConnection.
            // Return null for compatibility.
            return null;
        }
}

Returns the server's X.509 certificate chain, or null if the server did not authenticate. NOTE: This method is not necessary for the version of this class implementing javax.net.ssl.HttpsURLConnection, but provided for compatibility with the com.sun.net.ssl.HttpsURLConnection version.

 public Certificate[] getServerCertificates() throws SSLPeerUnverifiedException 
{
        return delegate.getServerCertificates();
}

Returns the server's certificate chain, or throws SSLPeerUnverified Exception if the server did not authenticate.

 public URL getURL() 
{
        return delegate.getURL();
}

 public boolean getUseCaches() 
{
        return delegate.getUseCaches();
}

 public int hashCode() 
{
        return delegate.hashCode();
}

 protected boolean isConnected() 
{
        return delegate.isConnected();
}

Used by subclass to access "connected" variable. Since we are delegating the actual implementation to "delegate", we need to delegate the access of "connected" as well.

 public  void setAllowUserInteraction(boolean allowuserinteraction) 
{
        delegate.setAllowUserInteraction(allowuserinteraction);
}

 public  void setChunkedStreamingMode(int chunklen) 
{
        delegate.setChunkedStreamingMode(chunklen);
}

 public  void setConnectTimeout(int timeout) 
{
        delegate.setConnectTimeout(timeout);
}

 protected  void setConnected(boolean conn) 
{
        delegate.setConnected(conn);
}

Used by subclass to access "connected" variable. Since we are delegating the actual implementation to "delegate", we need to delegate the access of "connected" as well.

 public  void setDefaultUseCaches(boolean defaultusecaches) 
{
        delegate.setDefaultUseCaches(defaultusecaches);
}

 public  void setDoInput(boolean doinput) 
{
        delegate.setDoInput(doinput);
}

 public  void setDoOutput(boolean dooutput) 
{
        delegate.setDoOutput(dooutput);
}

 public  void setFixedLengthStreamingMode(int contentLength) 
{
        delegate.setFixedLengthStreamingMode(contentLength);
}

 public  void setIfModifiedSince(long ifmodifiedsince) 
{
        delegate.setIfModifiedSince(ifmodifiedsince);
}

 public  void setInstanceFollowRedirects(boolean shouldFollow) 
{
        delegate.setInstanceFollowRedirects(shouldFollow);
}

 protected  void setNewClient(URL url) throws IOException 
{
        delegate.setNewClient(url, false);
}

Create a new HttpClient object, bypassing the cache of HTTP client objects/connections.

 protected  void setNewClient(URL url,
    boolean useCache) throws IOException 
{
        delegate.setNewClient(url, useCache);
}

Obtain a HttpClient object. Use the cached copy if specified.

 protected  void setProxiedClient(URL url,
    String proxyHost,
    int proxyPort) throws IOException 
{
        delegate.setProxiedClient(url, proxyHost, proxyPort);
}

Create a new HttpClient object, set up so that it uses per-instance proxying to the given HTTP proxy. This bypasses the cache of HTTP client objects/connections.

 protected  void setProxiedClient(URL url,
    String proxyHost,
    int proxyPort,
    boolean useCache) throws IOException 
{
        delegate.setProxiedClient(url, proxyHost, proxyPort, useCache);
}

Obtain a HttpClient object, set up so that it uses per-instance proxying to the given HTTP proxy. Use the cached copy of HTTP client objects/connections if specified.

 public  void setReadTimeout(int timeout) 
{
        delegate.setReadTimeout(timeout);
}

 public  void setRequestMethod(String method) throws ProtocolException 
{
        delegate.setRequestMethod(method);
}

 public  void setRequestProperty(String key,
    String value) 
{
        delegate.setRequestProperty(key, value);
}

Sets request property. If a property with the key already exists, overwrite its value with the new value.

 public  void setUseCaches(boolean usecaches) 
{
        delegate.setUseCaches(usecaches);
}

 public String toString() 
{
        return delegate.toString();
}

 public boolean usingProxy() 
{
        return delegate.usingProxy();
}