cookie.java

JSWDK服务器

     *
     *
     * @return			an integer specifying the maximum age of the
     *				cookie in seconds; if negative, means
     *				the cookie was not stored
     *
     *
     * @see #setMaxAge
     *
     */

    public int getMaxAge () {
	return maxAge;
    }
    
    
    

    /**
     *
Specifies a path for the cookie, which is the set of URIs
     * (Universal Resource Identifiers, the part of an URL that
     * represents the server path) 
     * to which the client should return the cookie.
     *
     * <p>The cookie is visible to all the pages in the directory
     * you specify, and all the pages in that directory's subdirectories. 
     * A cookie's path must include the servlet that set the cookie,
     * for example, <i>servlet/dir1</i>, which makes the cookie
     * visible to all directories on the server under <i>dir1</i>.
     *
     * <p>Consult RFC 2109 (available on the Internet) for more
     * information on setting path names for cookies.
     *
     *
     * @param uri		a string specifying a path, that
     *				contains a servlet name, for example,
     *				<i>servlet/dir1</i> 
     *
     *
     * @see #getPath
     *
     */

    public void setPath (String uri) {
	path = uri;
    }




    /**
     * Returns the paths (that is, URIs) on the server 
     * to which the browser returns this cookie. The
     * cookie is visible to all subdirectories within
     * the specified path on the server.
     *
     *
     * @return		a string specifying a path that contains
     *			a servlet name, for example, <i>servlet/dir1</i>
     *
     * @see #setPath
     *
     */ 

    public String getPath () {
	return path;
    }





    /**
     * Indicates to the browser whether the cookie should only be sent
     * using a secure protocol, such as HTTPS or SSL. You should only use
     * this method when the cookie's originating server used a secure
     * protocol to set the cookie's value.
     *
     * <p>The default value is <code>false</code>.
     *
     * @param flag	if true, sends the cookie from the browser
     *			to the server using only a secure protocol; if 
     *			false, uses a standard protocol
     *
     * @see #getSecure
     *
     */
 
    public void setSecure (boolean flag) {
	secure = flag;
    }




    /**
     * Returns <code>true</code> if the browser is sending cookies
     * only over a secure protocol, or <code>false</code> if the
     * browser can use a standard protocol.
     *
     * @return		<code>true</code> if the browser can use
     *			only a standard protocol; otherwise, <code>false</code>
     *
     * @see #setSecure
     *
     */

    public boolean getSecure () {
	return secure;
    }





    /**
     * Returns the name of the cookie. You cannot change the name
     * after the cookie is created.
     *
     * @return		a string specifying the cookie's name
     *
     */

    public String getName () {
	return name;
    }





    /**
     *
     * Assigns a new value to a cookie after the cookie is created.
     * The value can be anything the server chooses to send,
     * and usually does not make sense to the browser.
     * If you use a binary value, you may want to use BASE64 encoding.
     *
     * <p>With Version 0 cookies, values should not contain white 
     * space, brackets, parentheses, equals signs, commas,
     * double quotes, slashes, question marks, at signs, colons,
     * and semicolons. Empty values may not behave the same way
     * on all browsers.
     *
     * @param newValue		a string specifying the new value 
     *
     *
     * @see #getValue
     * @see #Cookie
     *
     */

    public void setValue (String newValue) {
	value = newValue;
    }




    /**
     * Returns the value of the cookie.
     *
     * @return			a string containing the cookie's
     *				present value
     *
     * @see setValue
     * @see Cookie
     *
     */

    public String getValue () {
	return value;
    }




    /**
     * Returns the version of the protocol this cookie complies 
     * with. Version 1 complies with RFC 2109, 
     * and version 0 complies with the original
     * cookie specification drafted by Netscape. Cookies provided
     * by a browser use and identify the browser's cookie version.
     * 
     *
     * @return			0 if the cookie complies with the
     *				original Netscape specification; 1
     *				if the cookie complies with RFC 2109
     *
     * @see #setVersion
     *
     */

    public int getVersion () {
	return version;
    }




    /**
     * Sets the version of the cookie protocol this cookie complies
     * with. Version 0 complies with the original Netscape cookie
     * specification. Version 1 complies with RFC 2109.
     *
     * <p>Since RFC 2109 is still somewhat new, consider
     * version 1 as experimental; do not use it yet on production sites.
     *
     *
     * @param v			0 if the cookie should comply with 
     *				the original Netscape specification;
     *				1 if the cookie should comply with RFC 2109
     *
     * @see #getVersion
     *
     */

    public void setVersion (int v) {
	version = v;
    }

    // Note -- disabled for now to allow full Netscape compatibility
    // from RFC 2068, token special case characters
    // 
    // private static final String tspecials = "()<>@,;:\\\"/[]?={} \t";

    private static final String tspecials = ",;";
    
    
    

    /*
     * Tests a string and returns true if the string counts as a 
     * reserved token in the Java language.
     * 
     * @param value		the string to be tested
     *
     * @return			<code>true</code> if the string is
     *				a reserved token; <code>false</code>
     *				if it is not			
     */

    private boolean isToken (String value) {
	int len = value.length ();

	for (int i = 0; i < len; i++) {
	    char c = value.charAt (i);

	    if (c < 0x20 || c >= 0x7f || tspecials.indexOf (c) != -1)
		return false;
	}
	return true;
    }






    /**
     *
     * Overrides the standard <code>java.lang.Object.clone</code> 
     * method to return a copy of this cookie.
     *		
     *
     */

    public Object clone () {
	try {
	    return super.clone ();
	} catch (CloneNotSupportedException e) {
	    throw new RuntimeException (e.getMessage ());
	}
    }
}