text:
package com.mysql.jdbc.jdbc2.optional;

import java.io.InputStream;
import java.io.Reader;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.RowId;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLXML;
import java.sql.Statement;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import com.mysql.jdbc.ConnectionImpl;
import com.mysql.jdbc.SQLError;

import com.mysql.jdbc.jdbc2.optional.ConnectionWrapper;
import com.mysql.jdbc.jdbc2.optional.MysqlPooledConnection;

/**
 */
public class JDBC4CallableStatementWrapper extends CallableStatementWrapper {

	public JDBC4CallableStatementWrapper(ConnectionWrapper c, MysqlPooledConnection conn,
			CallableStatement toWrap) {
		super(c, conn, toWrap);
	}

	public void close() throws SQLException {
		try {
			super.close();
		} finally {
			this.unwrappedInterfaces = null;
		}
	}

	public boolean isClosed() throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return this.wrappedStmt.isClosed();
			} else {
				throw SQLError.createSQLException("Statement already closed",
						SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return false; // never get here - compiler can't tell
	}

	public void setPoolable(boolean poolable) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				this.wrappedStmt.setPoolable(poolable);
			} else {
				throw SQLError.createSQLException("Statement already closed",
						SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public boolean isPoolable() throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return this.wrappedStmt.isPoolable();
			} else {
				throw SQLError.createSQLException("Statement already closed",
						SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return false; // never get here - compiler can't tell
	}

	public void setRowId(int parameterIndex, RowId x) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setRowId(parameterIndex,
						x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setNClob(int parameterIndex, NClob value) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
						value);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setSQLXML(int parameterIndex, SQLXML xmlObject)
			throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setSQLXML(parameterIndex,
						xmlObject);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setNString(int parameterIndex,
            String value)
            throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setNString(parameterIndex,
						value);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

    public void setNCharacterStream(int parameterIndex,
                    Reader value,
                    long length)
                    throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setNCharacterStream(parameterIndex,
						value, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setClob(int parameterIndex,
            Reader reader,
            long length)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
						reader, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setBlob(int parameterIndex,
            InputStream inputStream,
            long length)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
						inputStream, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setNClob(int parameterIndex,
            Reader reader,
            long length)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
						reader, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setAsciiStream(int parameterIndex,
            InputStream x,
            long length)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setAsciiStream(parameterIndex,
						x, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setBinaryStream(int parameterIndex,
            InputStream x,
            long length)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setBinaryStream(parameterIndex,
						x, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setCharacterStream(int parameterIndex,
            Reader reader,
            long length)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setCharacterStream(parameterIndex,
						reader, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setAsciiStream(int parameterIndex,
            InputStream x)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setAsciiStream(parameterIndex,
						x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setBinaryStream(int parameterIndex,
            InputStream x)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setBinaryStream(parameterIndex,
						x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setCharacterStream(int parameterIndex,
            Reader reader)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setCharacterStream(parameterIndex,
						reader);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

    }

    public void setNCharacterStream(int parameterIndex,
            Reader value)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setNCharacterStream(parameterIndex,
						value);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

    }

    public void setClob(int parameterIndex,
            Reader reader)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setClob(parameterIndex,
						reader);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

    }

    public void setBlob(int parameterIndex,
            InputStream inputStream)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setBlob(parameterIndex,
						inputStream);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

    public void setNClob(int parameterIndex,
            Reader reader)
            throws SQLException {
    	try {
			if (this.wrappedStmt != null) {
				((PreparedStatement) this.wrappedStmt).setNClob(parameterIndex,
						reader);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
    }

	/**
	 * Returns true if this either implements the interface argument or is
	 * directly or indirectly a wrapper for an object that does. Returns false
	 * otherwise. If this implements the interface then return true, else if
	 * this is a wrapper then return the result of recursively calling
	 * isWrapperFor on the wrapped object. If this does not
	 * implement the interface and is not a wrapper, return false. This method
	 * should be implemented as a low-cost operation compared to
	 * unwrap so that callers can use this method to avoid
	 * expensive unwrap calls that may fail. If this method
	 * returns true then calling unwrap with the same argument
	 * should succeed.
	 *
	 * @param interfaces
	 *            a Class defining an interface.
	 * @return true if this implements the interface or directly or indirectly
	 *         wraps an object that does.
	 * @throws java.sql.SQLException
	 *             if an error occurs while determining whether this is a
	 *             wrapper for an object with the given interface.
	 * @since 1.6
	 */
	public boolean isWrapperFor(Class<?> iface) throws SQLException {

		boolean isInstance = iface.isInstance(this);

		if (isInstance) {
			return true;
		}

		String interfaceClassName = iface.getName();

		return (interfaceClassName.equals("com.mysql.jdbc.Statement")
				|| interfaceClassName.equals("java.sql.Statement")
				|| interfaceClassName.equals("java.sql.PreparedStatement")
				|| interfaceClassName.equals("java.sql.Wrapper"));
	}

	/**
	 * Returns an object that implements the given interface to allow access to
	 * non-standard methods, or standard methods not exposed by the proxy. The
	 * result may be either the object found to implement the interface or a
	 * proxy for that object. If the receiver implements the interface then that
	 * is the object. If the receiver is a wrapper and the wrapped object
	 * implements the interface then that is the object. Otherwise the object is
	 * the result of calling unwrap recursively on the wrapped
	 * object. If the receiver is not a wrapper and does not implement the
	 * interface, then an SQLException is thrown.
	 *
	 * @param iface
	 *            A Class defining an interface that the result must implement.
	 * @return an object that implements the interface. May be a proxy for the
	 *         actual implementing object.
	 * @throws java.sql.SQLException
	 *             If no object found that implements the interface
	 * @since 1.6
	 */
	public synchronized <T> T unwrap(java.lang.Class<T> iface)
			throws java.sql.SQLException {
		try {
			if ("java.sql.Statement".equals(iface.getName())
					|| "java.sql.PreparedStatement".equals(iface.getName())
					|| "java.sql.Wrapper.class".equals(iface.getName())) {
				return iface.cast(this);
			}

			if (unwrappedInterfaces == null) {
				unwrappedInterfaces = new HashMap();
			}

			Object cachedUnwrapped = unwrappedInterfaces.get(iface);

			if (cachedUnwrapped == null) {
				if (cachedUnwrapped == null) {
					cachedUnwrapped = Proxy.newProxyInstance(
							this.wrappedStmt.getClass().getClassLoader(),
							new Class[] { iface },
							new ConnectionErrorFiringInvocationHandler(this.wrappedStmt));
					unwrappedInterfaces.put(iface, cachedUnwrapped);
				}
				unwrappedInterfaces.put(iface, cachedUnwrapped);
			}

			return iface.cast(cachedUnwrapped);
		} catch (ClassCastException cce) {
			throw SQLError.createSQLException("Unable to unwrap to "
					+ iface.toString(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
		}
	}

	public void setRowId(String parameterName, RowId x) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setRowId(parameterName, x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setSQLXML(parameterName, xmlObject);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public SQLXML getSQLXML(int parameterIndex) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getSQLXML(parameterIndex);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;

	}

	public SQLXML getSQLXML(String parameterName) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getSQLXML(parameterName);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	public RowId getRowId(String parameterName) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getRowId(parameterName);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	public void setNClob(String parameterName, NClob value) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setNClob(parameterName, value);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setNClob(String parameterName, Reader reader) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setNClob(parameterName, reader);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setNClob(parameterName, reader, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setNString(String parameterName, String value) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setNString(parameterName, value);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	/**
	 * @see java.sql.CallableStatement#getCharacterStream(int)
	 */
	public Reader getCharacterStream(int parameterIndex) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getCharacterStream(parameterIndex);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	/**
	 * @see java.sql.CallableStatement#getCharacterStream(java.lang.String)
	 */
	public Reader getCharacterStream(String parameterName) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getCharacterStream(parameterName);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	/**
	 * @see java.sql.CallableStatement#getNCharacterStream(int)
	 */
	public Reader getNCharacterStream(int parameterIndex) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getNCharacterStream(parameterIndex);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	/**
	 * @see java.sql.CallableStatement#getNCharacterStream(java.lang.String)
	 */
	public Reader getNCharacterStream(String parameterName) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getNCharacterStream(parameterName);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	/**
	 * @see java.sql.CallableStatement#getNClob(java.lang.String)
	 */
	public NClob getNClob(String parameterName) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getNClob(parameterName);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	/**
	 * @see java.sql.CallableStatement#getNString(java.lang.String)
	 */
	public String getNString(String parameterName) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getNString(parameterName);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setAsciiStream(parameterName, x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setAsciiStream(parameterName, x, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setBinaryStream(parameterName, x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setBinaryStream(parameterName, x, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setBlob(String parameterName, InputStream x) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setBlob(parameterName, x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setBlob(String parameterName, InputStream x, long length) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setBlob(parameterName, x, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setBlob(String parameterName, Blob x) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setBlob(parameterName, x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setCharacterStream(parameterName, reader);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setCharacterStream(parameterName, reader, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setClob(String parameterName, Clob x) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setClob(parameterName, x);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setClob(String parameterName, Reader reader) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setClob(parameterName, reader);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setClob(String parameterName, Reader reader, long length) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setClob(parameterName, reader, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setNCharacterStream(String parameterName, Reader reader) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setNCharacterStream(parameterName, reader);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public void setNCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				((CallableStatement) this.wrappedStmt).setNCharacterStream(parameterName, reader, length);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}
	}

	public NClob getNClob(int parameterIndex) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getNClob(parameterIndex);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	public String getNString(int parameterIndex) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getNString(parameterIndex);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}

	public RowId getRowId(int parameterIndex) throws SQLException {
		try {
			if (this.wrappedStmt != null) {
				return ((CallableStatement) this.wrappedStmt).getRowId(parameterIndex);
			} else {
				throw SQLError.createSQLException(
						"No operations allowed after statement closed",
						SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);
			}
		} catch (SQLException sqlEx) {
			checkAndFireConnectionError(sqlEx);
		}

		return null;
	}
}


text:
package java.util;

import java.security.AccessController;
import java.security.PrivilegedAction;
import java.text.DateFormatSymbols;

/**
 * This class represents a time zone offset and handles daylight savings.
 *
 * You can get the default time zone with getDefault.
 * This represents the time zone where program is running.
 *
 * Another way to create a time zone is getTimeZone, where
 * you can give an identifier as parameter.  For instance, the identifier
 * of the Central European Time zone is "CET".
 *
 * With the getAvailableIDs method, you can get all the
 * supported time zone identifiers.
 *
 * @see Calendar
 * @see SimpleTimeZone
 * @author Jochen Hoenicke
 */
public abstract class TimeZone implements java.io.Serializable, Cloneable
{

  /**
   * Constant used to indicate that a short timezone abbreviation should
   * be returned, such as "EST"
   */
  public static final int SHORT = 0;

  /**
   * Constant used to indicate that a long timezone name should be
   * returned, such as "Eastern Standard Time".
   */
  public static final int LONG = 1;

  /**
   * The time zone identifier, e.g. PST.
   */
  private String ID;

  /**
   * The default time zone, as returned by getDefault.
   */
  private static TimeZone defaultZone0;

  /**
   * Tries to get the default TimeZone for this system if not already
   * set.  It will call getDefaultTimeZone(String) with
   * the result of System.getProperty("user.timezone").
   * If that fails it calls VMTimeZone.getDefaultTimeZoneId().
   * If that also fails GMT is returned.
   */
  private static synchronized TimeZone defaultZone()
  {
    /* Look up default timezone */
    if (defaultZone0 == null)
      {
	defaultZone0 = (TimeZone) AccessController.doPrivileged
	  (new PrivilegedAction()
	    {
	      public Object run()
	      {
		TimeZone zone = null;

		// Prefer System property user.timezone.
		String tzid = System.getProperty("user.timezone");
		if (tzid != null && !tzid.equals(""))
		  zone = getDefaultTimeZone(tzid);

		// Try platfom specific way.
		if (zone == null)
		  zone = VMTimeZone.getDefaultTimeZoneId();

		// Fall back on GMT.
		if (zone == null)
		  zone = (TimeZone) timezones().get("GMT");

		return zone;
	      }
	    });
      }

    return defaultZone0;
  }

  private static final long serialVersionUID = 3581463369166924961L;

  /**
   * HashMap for timezones by ID.
   */
  private static HashMap timezones0;
  /* initialize this static field lazily to overhead if
   * it is not needed:
   */
  // Package-private to avoid a trampoline.
  static synchronized HashMap timezones()
  {
    if (timezones0 == null)
      {
	HashMap timezones = new HashMap();
	timezones0 = timezones;

	TimeZone tz;
	// Automatically generated by scripts/timezones.pl
	// XXX - Should we read this data from a file?
	tz = new SimpleTimeZone(-11000 * 3600, "MIT");
	timezones0.put("MIT", tz);
	timezones0.put("Pacific/Apia", tz);
	timezones0.put("Pacific/Midway", tz);
	timezones0.put("Pacific/Niue", tz);
	timezones0.put("Pacific/Pago_Pago", tz);
	tz = new SimpleTimeZone
	  (-10000 * 3600, "America/Adak",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("America/Adak", tz);
	tz = new SimpleTimeZone(-10000 * 3600, "HST");
	timezones0.put("HST", tz);
	timezones0.put("Pacific/Fakaofo", tz);
	timezones0.put("Pacific/Honolulu", tz);
	timezones0.put("Pacific/Johnston", tz);
	timezones0.put("Pacific/Rarotonga", tz);
	timezones0.put("Pacific/Tahiti", tz);
	tz = new SimpleTimeZone(-9500 * 3600, "Pacific/Marquesas");
	timezones0.put("Pacific/Marquesas", tz);
	tz = new SimpleTimeZone
	  (-9000 * 3600, "AST",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("AST", tz);
	timezones0.put("America/Anchorage", tz);
	timezones0.put("America/Juneau", tz);
	timezones0.put("America/Nome", tz);
	timezones0.put("America/Yakutat", tz);
	tz = new SimpleTimeZone(-9000 * 3600, "Pacific/Gambier");
	timezones0.put("Pacific/Gambier", tz);
	tz = new SimpleTimeZone
	  (-8000 * 3600, "America/Tijuana",
	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("America/Tijuana", tz);
	tz = new SimpleTimeZone
	  (-8000 * 3600, "PST",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("PST", tz);
	timezones0.put("PST8PDT", tz);
	timezones0.put("America/Dawson", tz);
	timezones0.put("America/Los_Angeles", tz);
	timezones0.put("America/Vancouver", tz);
	timezones0.put("America/Whitehorse", tz);
	timezones0.put("US/Pacific-New", tz);
	tz = new SimpleTimeZone(-8000 * 3600, "Pacific/Pitcairn");
	timezones0.put("Pacific/Pitcairn", tz);
	tz = new SimpleTimeZone
	  (-7000 * 3600, "America/Chihuahua",
	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("America/Chihuahua", tz);
	timezones0.put("America/Mazatlan", tz);
	tz = new SimpleTimeZone(-7000 * 3600, "MST7");
	timezones0.put("MST7", tz);
	timezones0.put("PNT", tz);
	timezones0.put("America/Dawson_Creek", tz);
	timezones0.put("America/Hermosillo", tz);
	timezones0.put("America/Phoenix", tz);
	tz = new SimpleTimeZone
	  (-7000 * 3600, "MST",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("MST", tz);
	timezones0.put("MST7MDT", tz);
	timezones0.put("America/Boise", tz);
	timezones0.put("America/Cambridge_Bay", tz);
	timezones0.put("America/Denver", tz);
	timezones0.put("America/Edmonton", tz);
	timezones0.put("America/Inuvik", tz);
	timezones0.put("America/Shiprock", tz);
	timezones0.put("America/Yellowknife", tz);
	tz = new SimpleTimeZone
	  (-6000 * 3600, "America/Cancun",
	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("America/Cancun", tz);
	timezones0.put("America/Merida", tz);
	timezones0.put("America/Mexico_City", tz);
	timezones0.put("America/Monterrey", tz);
	tz = new SimpleTimeZone(-6000 * 3600, "America/Belize");
	timezones0.put("America/Belize", tz);
	timezones0.put("America/Costa_Rica", tz);
	timezones0.put("America/El_Salvador", tz);
	timezones0.put("America/Guatemala", tz);
	timezones0.put("America/Managua", tz);
	timezones0.put("America/Regina", tz);
	timezones0.put("America/Swift_Current", tz);
	timezones0.put("America/Tegucigalpa", tz);
	timezones0.put("Pacific/Galapagos", tz);
	tz = new SimpleTimeZone
	  (-6000 * 3600, "CST",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("CST", tz);
	timezones0.put("CST6CDT", tz);
	timezones0.put("America/Chicago", tz);
	timezones0.put("America/Indiana/Knox", tz);
	timezones0.put("America/Indiana/Petersburg", tz);
	timezones0.put("America/Indiana/Vincennes", tz);
	timezones0.put("America/Menominee", tz);
	timezones0.put("America/North_Dakota/Center", tz);
	timezones0.put("America/North_Dakota/New_Salem", tz);
	timezones0.put("America/Rainy_River", tz);
	timezones0.put("America/Rankin_Inlet", tz);
	timezones0.put("America/Winnipeg", tz);
	tz = new SimpleTimeZone
	  (-6000 * 3600, "Pacific/Easter",
	   Calendar.OCTOBER, 2, Calendar.SATURDAY, 22000 * 3600,
	   Calendar.MARCH, 2, Calendar.SATURDAY, 22000 * 3600);
	timezones0.put("Pacific/Easter", tz);
	tz = new SimpleTimeZone(-5000 * 3600, "EST5");
	timezones0.put("EST5", tz);
	timezones0.put("IET", tz);
	timezones0.put("America/Atikokan", tz);
	timezones0.put("America/Bogota", tz);
	timezones0.put("America/Cayman", tz);
	timezones0.put("America/Eirunepe", tz);
	timezones0.put("America/Guayaquil", tz);
	timezones0.put("America/Jamaica", tz);
	timezones0.put("America/Lima", tz);
	timezones0.put("America/Panama", tz);
	timezones0.put("America/Rio_Branco", tz);
	tz = new SimpleTimeZone
	  (-5000 * 3600, "America/Havana",
	   Calendar.APRIL, 1, Calendar.SUNDAY, 0 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 1000 * 3600);
	timezones0.put("America/Havana", tz);
	tz = new SimpleTimeZone
	  (-5000 * 3600, "America/Grand_Turk",
	   Calendar.APRIL, 1, Calendar.SUNDAY, 0 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 0 * 3600);
	timezones0.put("America/Grand_Turk", tz);
	timezones0.put("America/Port-au-Prince", tz);
	tz = new SimpleTimeZone
	  (-5000 * 3600, "EST",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("EST", tz);
	timezones0.put("EST5EDT", tz);
	timezones0.put("America/Detroit", tz);
	timezones0.put("America/Indiana/Indianapolis", tz);
	timezones0.put("America/Indiana/Marengo", tz);
	timezones0.put("America/Indiana/Vevay", tz);
	timezones0.put("America/Iqaluit", tz);
	timezones0.put("America/Kentucky/Louisville", tz);
	timezones0.put("America/Kentucky/Monticello", tz);
	timezones0.put("America/Montreal", tz);
	timezones0.put("America/Nassau", tz);
	timezones0.put("America/New_York", tz);
	timezones0.put("America/Nipigon", tz);
	timezones0.put("America/Pangnirtung", tz);
	timezones0.put("America/Thunder_Bay", tz);
	timezones0.put("America/Toronto", tz);
	tz = new SimpleTimeZone
	  (-4000 * 3600, "America/Asuncion",
	   Calendar.OCTOBER, 3, Calendar.SUNDAY, 0 * 3600,
	   Calendar.MARCH, 2, Calendar.SUNDAY, 0 * 3600);
	timezones0.put("America/Asuncion", tz);
	tz = new SimpleTimeZone(-4000 * 3600, "PRT");
	timezones0.put("PRT", tz);
	timezones0.put("America/Anguilla", tz);
	timezones0.put("America/Antigua", tz);
	timezones0.put("America/Aruba", tz);
	timezones0.put("America/Barbados", tz);
	timezones0.put("America/Blanc-Sablon", tz);
	timezones0.put("America/Boa_Vista", tz);
	timezones0.put("America/Caracas", tz);
	timezones0.put("America/Curacao", tz);
	timezones0.put("America/Dominica", tz);
	timezones0.put("America/Grenada", tz);
	timezones0.put("America/Guadeloupe", tz);
	timezones0.put("America/Guyana", tz);
	timezones0.put("America/La_Paz", tz);
	timezones0.put("America/Manaus", tz);
	timezones0.put("America/Martinique", tz);
	timezones0.put("America/Montserrat", tz);
	timezones0.put("America/Port_of_Spain", tz);
	timezones0.put("America/Porto_Velho", tz);
	timezones0.put("America/Puerto_Rico", tz);
	timezones0.put("America/Santo_Domingo", tz);
	timezones0.put("America/St_Kitts", tz);
	timezones0.put("America/St_Lucia", tz);
	timezones0.put("America/St_Thomas", tz);
	timezones0.put("America/St_Vincent", tz);
	timezones0.put("America/Tortola", tz);
	tz = new SimpleTimeZone
	  (-4000 * 3600, "America/Campo_Grande",
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 0 * 3600,
	   Calendar.FEBRUARY, -1, Calendar.SUNDAY, 0 * 3600);
	timezones0.put("America/Campo_Grande", tz);
	timezones0.put("America/Cuiaba", tz);
	tz = new SimpleTimeZone
	  (-4000 * 3600, "America/Goose_Bay",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 60000,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 60000);
	timezones0.put("America/Goose_Bay", tz);
	tz = new SimpleTimeZone
	  (-4000 * 3600, "America/Glace_Bay",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("America/Glace_Bay", tz);
	timezones0.put("America/Halifax", tz);
	timezones0.put("America/Moncton", tz);
	timezones0.put("America/Thule", tz);
	timezones0.put("Atlantic/Bermuda", tz);
	tz = new SimpleTimeZone
	  (-4000 * 3600, "America/Santiago",
	   Calendar.OCTOBER, 9, -Calendar.SUNDAY, 0 * 3600,
	   Calendar.MARCH, 9, -Calendar.SUNDAY, 0 * 3600);
	timezones0.put("America/Santiago", tz);
	timezones0.put("Antarctica/Palmer", tz);
	tz = new SimpleTimeZone
	  (-4000 * 3600, "Atlantic/Stanley",
	   Calendar.SEPTEMBER, 1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.APRIL, 3, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("Atlantic/Stanley", tz);
	tz = new SimpleTimeZone
	  (-3500 * 3600, "CNT",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 60000,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 60000);
	timezones0.put("CNT", tz);
	timezones0.put("America/St_Johns", tz);
	tz = new SimpleTimeZone
	  (-3000 * 3600, "America/Godthab",
	   Calendar.MARCH, 30, -Calendar.SATURDAY, 22000 * 3600,
	   Calendar.OCTOBER, 30, -Calendar.SATURDAY, 23000 * 3600);
	timezones0.put("America/Godthab", tz);
	tz = new SimpleTimeZone
	  (-3000 * 3600, "America/Miquelon",
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("America/Miquelon", tz);
	tz = new SimpleTimeZone
	  (-3000 * 3600, "America/Montevideo",
	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.MARCH, 2, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("America/Montevideo", tz);
	tz = new SimpleTimeZone
	  (-3000 * 3600, "America/Sao_Paulo",
	   Calendar.NOVEMBER, 1, Calendar.SUNDAY, 0 * 3600,
	   Calendar.FEBRUARY, -1, Calendar.SUNDAY, 0 * 3600);
	timezones0.put("America/Sao_Paulo", tz);
	tz = new SimpleTimeZone(-3000 * 3600, "AGT");
	timezones0.put("AGT", tz);
	timezones0.put("America/Araguaina", tz);
	timezones0.put("America/Argentina/Buenos_Aires", tz);
	timezones0.put("America/Argentina/Catamarca", tz);
	timezones0.put("America/Argentina/Cordoba", tz);
	timezones0.put("America/Argentina/Jujuy", tz);
	timezones0.put("America/Argentina/La_Rioja", tz);
	timezones0.put("America/Argentina/Mendoza", tz);
	timezones0.put("America/Argentina/Rio_Gallegos", tz);
	timezones0.put("America/Argentina/San_Juan", tz);
	timezones0.put("America/Argentina/Tucuman", tz);
	timezones0.put("America/Argentina/Ushuaia", tz);
	timezones0.put("America/Bahia", tz);
	timezones0.put("America/Belem", tz);
	timezones0.put("America/Cayenne", tz);
	timezones0.put("America/Fortaleza", tz);
	timezones0.put("America/Maceio", tz);
	timezones0.put("America/Paramaribo", tz);
	timezones0.put("America/Recife", tz);
	timezones0.put("Antarctica/Rothera", tz);
	tz = new SimpleTimeZone(-2000 * 3600, "America/Noronha");
	timezones0.put("America/Noronha", tz);
	timezones0.put("Atlantic/South_Georgia", tz);
	tz = new SimpleTimeZone
	  (-1000 * 3600, "America/Scoresbysund",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 0 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 1000 * 3600);
	timezones0.put("America/Scoresbysund", tz);
	timezones0.put("Atlantic/Azores", tz);
	tz = new SimpleTimeZone(-1000 * 3600, "Atlantic/Cape_Verde");
	timezones0.put("Atlantic/Cape_Verde", tz);
	tz = new SimpleTimeZone(0 * 3600, "GMT");
	timezones0.put("GMT", tz);
	timezones0.put("UTC", tz);
	timezones0.put("Africa/Abidjan", tz);
	timezones0.put("Africa/Accra", tz);
	timezones0.put("Africa/Bamako", tz);
	timezones0.put("Africa/Banjul", tz);
	timezones0.put("Africa/Bissau", tz);
	timezones0.put("Africa/Casablanca", tz);
	timezones0.put("Africa/Conakry", tz);
	timezones0.put("Africa/Dakar", tz);
	timezones0.put("Africa/El_Aaiun", tz);
	timezones0.put("Africa/Freetown", tz);
	timezones0.put("Africa/Lome", tz);
	timezones0.put("Africa/Monrovia", tz);
	timezones0.put("Africa/Nouakchott", tz);
	timezones0.put("Africa/Ouagadougou", tz);
	timezones0.put("Africa/Sao_Tome", tz);
	timezones0.put("America/Danmarkshavn", tz);
	timezones0.put("Atlantic/Reykjavik", tz);
	timezones0.put("Atlantic/St_Helena", tz);
	tz = new SimpleTimeZone
	  (0 * 3600, "WET",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 1000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("WET", tz);
	timezones0.put("Atlantic/Canary", tz);
	timezones0.put("Atlantic/Faroe", tz);
	timezones0.put("Atlantic/Madeira", tz);
	timezones0.put("Europe/Dublin", tz);
	timezones0.put("Europe/Guernsey", tz);
	timezones0.put("Europe/Isle_of_Man", tz);
	timezones0.put("Europe/Jersey", tz);
	timezones0.put("Europe/Lisbon", tz);
	timezones0.put("Europe/London", tz);
	tz = new SimpleTimeZone(1000 * 3600, "Africa/Algiers");
	timezones0.put("Africa/Algiers", tz);
	timezones0.put("Africa/Bangui", tz);
	timezones0.put("Africa/Brazzaville", tz);
	timezones0.put("Africa/Douala", tz);
	timezones0.put("Africa/Kinshasa", tz);
	timezones0.put("Africa/Lagos", tz);
	timezones0.put("Africa/Libreville", tz);
	timezones0.put("Africa/Luanda", tz);
	timezones0.put("Africa/Malabo", tz);
	timezones0.put("Africa/Ndjamena", tz);
	timezones0.put("Africa/Niamey", tz);
	timezones0.put("Africa/Porto-Novo", tz);
	tz = new SimpleTimeZone
	  (1000 * 3600, "Africa/Windhoek",
	   Calendar.SEPTEMBER, 1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.APRIL, 1, Calendar.SUNDAY, 2000 * 3600);
	timezones0.put("Africa/Windhoek", tz);
	tz = new SimpleTimeZone
	  (1000 * 3600, "CET",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("CET", tz);
	timezones0.put("ECT", tz);
	timezones0.put("MET", tz);
	timezones0.put("Africa/Ceuta", tz);
	timezones0.put("Africa/Tunis", tz);
	timezones0.put("Arctic/Longyearbyen", tz);
	timezones0.put("Atlantic/Jan_Mayen", tz);
	timezones0.put("Europe/Amsterdam", tz);
	timezones0.put("Europe/Andorra", tz);
	timezones0.put("Europe/Belgrade", tz);
	timezones0.put("Europe/Berlin", tz);
	timezones0.put("Europe/Bratislava", tz);
	timezones0.put("Europe/Brussels", tz);
	timezones0.put("Europe/Budapest", tz);
	timezones0.put("Europe/Copenhagen", tz);
	timezones0.put("Europe/Gibraltar", tz);
	timezones0.put("Europe/Ljubljana", tz);
	timezones0.put("Europe/Luxembourg", tz);
	timezones0.put("Europe/Madrid", tz);
	timezones0.put("Europe/Malta", tz);
	timezones0.put("Europe/Monaco", tz);
	timezones0.put("Europe/Oslo", tz);
	timezones0.put("Europe/Paris", tz);
	timezones0.put("Europe/Podgorica", tz);
	timezones0.put("Europe/Prague", tz);
	timezones0.put("Europe/Rome", tz);
	timezones0.put("Europe/San_Marino", tz);
	timezones0.put("Europe/Sarajevo", tz);
	timezones0.put("Europe/Skopje", tz);
	timezones0.put("Europe/Stockholm", tz);
	timezones0.put("Europe/Tirane", tz);
	timezones0.put("Europe/Vaduz", tz);
	timezones0.put("Europe/Vatican", tz);
	timezones0.put("Europe/Vienna", tz);
	timezones0.put("Europe/Warsaw", tz);
	timezones0.put("Europe/Zagreb", tz);
	timezones0.put("Europe/Zurich", tz);
	tz = new SimpleTimeZone
	  (2000 * 3600, "ART",
	   Calendar.APRIL, -1, Calendar.FRIDAY, 0 * 3600,
	   Calendar.SEPTEMBER, -1, Calendar.THURSDAY, 24000 * 3600);
	timezones0.put("ART", tz);
	timezones0.put("Africa/Cairo", tz);
	tz = new SimpleTimeZone(2000 * 3600, "CAT");
	timezones0.put("CAT", tz);
	timezones0.put("Africa/Blantyre", tz);
	timezones0.put("Africa/Bujumbura", tz);
	timezones0.put("Africa/Gaborone", tz);
	timezones0.put("Africa/Harare", tz);
	timezones0.put("Africa/Johannesburg", tz);
	timezones0.put("Africa/Kigali", tz);
	timezones0.put("Africa/Lubumbashi", tz);
	timezones0.put("Africa/Lusaka", tz);
	timezones0.put("Africa/Maputo", tz);
	timezones0.put("Africa/Maseru", tz);
	timezones0.put("Africa/Mbabane", tz);
	timezones0.put("Africa/Tripoli", tz);
	timezones0.put("Asia/Jerusalem", tz);
	tz = new SimpleTimeZone
	  (2000 * 3600, "Asia/Amman",
	   Calendar.MARCH, -1, Calendar.THURSDAY, 0 * 3600,
	   Calendar.OCTOBER, -1, Calendar.FRIDAY, 1000 * 3600);
	timezones0.put("Asia/Amman", tz);
	tz = new SimpleTimeZone
	  (2000 * 3600, "Asia/Beirut",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 0 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 0 * 3600);
	timezones0.put("Asia/Beirut", tz);
	tz = new SimpleTimeZone
	  (2000 * 3600, "Asia/Damascus",
	   Calendar.APRIL, 1, 0, 0 * 3600,
	   Calendar.OCTOBER, 1, 0, 0 * 3600);
	timezones0.put("Asia/Damascus", tz);
	tz = new SimpleTimeZone
	  (2000 * 3600, "Asia/Gaza",
	   Calendar.APRIL, 1, 0, 0 * 3600,
	   Calendar.OCTOBER, 3, Calendar.FRIDAY, 0 * 3600);
	timezones0.put("Asia/Gaza", tz);
	tz = new SimpleTimeZone
	  (2000 * 3600, "EET",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 4000 * 3600);
	timezones0.put("EET", tz);
	timezones0.put("Asia/Istanbul", tz);
	timezones0.put("Asia/Nicosia", tz);
	timezones0.put("Europe/Athens", tz);
	timezones0.put("Europe/Bucharest", tz);
	timezones0.put("Europe/Chisinau", tz);
	timezones0.put("Europe/Helsinki", tz);
	timezones0.put("Europe/Istanbul", tz);
	timezones0.put("Europe/Kiev", tz);
	timezones0.put("Europe/Mariehamn", tz);
	timezones0.put("Europe/Nicosia", tz);
	timezones0.put("Europe/Riga", tz);
	timezones0.put("Europe/Simferopol", tz);
	timezones0.put("Europe/Sofia", tz);
	timezones0.put("Europe/Tallinn", tz);
	timezones0.put("Europe/Uzhgorod", tz);
	timezones0.put("Europe/Vilnius", tz);
	timezones0.put("Europe/Zaporozhye", tz);
	tz = new SimpleTimeZone
	  (2000 * 3600, "Europe/Kaliningrad",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Europe/Kaliningrad", tz);
	timezones0.put("Europe/Minsk", tz);
	tz = new SimpleTimeZone
	  (3000 * 3600, "Asia/Baghdad",
	   Calendar.APRIL, 1, 0, 3000 * 3600,
	   Calendar.OCTOBER, 1, 0, 4000 * 3600);
	timezones0.put("Asia/Baghdad", tz);
	tz = new SimpleTimeZone
	  (3000 * 3600, "Europe/Moscow",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Europe/Moscow", tz);
	timezones0.put("Europe/Volgograd", tz);
	tz = new SimpleTimeZone(3000 * 3600, "EAT");
	timezones0.put("EAT", tz);
	timezones0.put("Africa/Addis_Ababa", tz);
	timezones0.put("Africa/Asmara", tz);
	timezones0.put("Africa/Dar_es_Salaam", tz);
	timezones0.put("Africa/Djibouti", tz);
	timezones0.put("Africa/Kampala", tz);
	timezones0.put("Africa/Khartoum", tz);
	timezones0.put("Africa/Mogadishu", tz);
	timezones0.put("Africa/Nairobi", tz);
	timezones0.put("Antarctica/Syowa", tz);
	timezones0.put("Asia/Aden", tz);
	timezones0.put("Asia/Bahrain", tz);
	timezones0.put("Asia/Kuwait", tz);
	timezones0.put("Asia/Qatar", tz);
	timezones0.put("Asia/Riyadh", tz);
	timezones0.put("Indian/Antananarivo", tz);
	timezones0.put("Indian/Comoro", tz);
	timezones0.put("Indian/Mayotte", tz);
	tz = new SimpleTimeZone(3500 * 3600, "Asia/Tehran");
	timezones0.put("Asia/Tehran", tz);
	tz = new SimpleTimeZone
	  (4000 * 3600, "Asia/Baku",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 4000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 5000 * 3600);
	timezones0.put("Asia/Baku", tz);
	tz = new SimpleTimeZone
	  (4000 * 3600, "Asia/Yerevan",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Yerevan", tz);
	timezones0.put("Europe/Samara", tz);
	tz = new SimpleTimeZone(4000 * 3600, "NET");
	timezones0.put("NET", tz);
	timezones0.put("Asia/Dubai", tz);
	timezones0.put("Asia/Muscat", tz);
	timezones0.put("Asia/Tbilisi", tz);
	timezones0.put("Indian/Mahe", tz);
	timezones0.put("Indian/Mauritius", tz);
	timezones0.put("Indian/Reunion", tz);
	tz = new SimpleTimeZone(4500 * 3600, "Asia/Kabul");
	timezones0.put("Asia/Kabul", tz);
	tz = new SimpleTimeZone
	  (5000 * 3600, "Asia/Yekaterinburg",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Yekaterinburg", tz);
	tz = new SimpleTimeZone(5000 * 3600, "PLT");
	timezones0.put("PLT", tz);
	timezones0.put("Asia/Aqtau", tz);
	timezones0.put("Asia/Aqtobe", tz);
	timezones0.put("Asia/Ashgabat", tz);
	timezones0.put("Asia/Dushanbe", tz);
	timezones0.put("Asia/Karachi", tz);
	timezones0.put("Asia/Oral", tz);
	timezones0.put("Asia/Samarkand", tz);
	timezones0.put("Asia/Tashkent", tz);
	timezones0.put("Indian/Kerguelen", tz);
	timezones0.put("Indian/Maldives", tz);
	tz = new SimpleTimeZone(5500 * 3600, "BST");
	timezones0.put("BST", tz);
	timezones0.put("IST", tz);
	timezones0.put("Asia/Calcutta", tz);
	timezones0.put("Asia/Colombo", tz);
	tz = new SimpleTimeZone(5750 * 3600, "Asia/Katmandu");
	timezones0.put("Asia/Katmandu", tz);
	tz = new SimpleTimeZone(6000 * 3600, "Antarctica/Mawson");
	timezones0.put("Antarctica/Mawson", tz);
	timezones0.put("Antarctica/Vostok", tz);
	timezones0.put("Asia/Almaty", tz);
	timezones0.put("Asia/Bishkek", tz);
	timezones0.put("Asia/Dhaka", tz);
	timezones0.put("Asia/Qyzylorda", tz);
	timezones0.put("Asia/Thimphu", tz);
	timezones0.put("Indian/Chagos", tz);
	tz = new SimpleTimeZone
	  (6000 * 3600, "Asia/Novosibirsk",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Novosibirsk", tz);
	timezones0.put("Asia/Omsk", tz);
	tz = new SimpleTimeZone(6500 * 3600, "Asia/Rangoon");
	timezones0.put("Asia/Rangoon", tz);
	timezones0.put("Indian/Cocos", tz);
	tz = new SimpleTimeZone(7000 * 3600, "VST");
	timezones0.put("VST", tz);
	timezones0.put("Antarctica/Davis", tz);
	timezones0.put("Asia/Bangkok", tz);
	timezones0.put("Asia/Jakarta", tz);
	timezones0.put("Asia/Phnom_Penh", tz);
	timezones0.put("Asia/Pontianak", tz);
	timezones0.put("Asia/Saigon", tz);
	timezones0.put("Asia/Vientiane", tz);
	timezones0.put("Indian/Christmas", tz);
	tz = new SimpleTimeZone
	  (7000 * 3600, "Asia/Hovd",
	   Calendar.MARCH, -1, Calendar.SATURDAY, 2000 * 3600,
	   Calendar.SEPTEMBER, -1, Calendar.SATURDAY, 2000 * 3600);
	timezones0.put("Asia/Hovd", tz);
	tz = new SimpleTimeZone
	  (7000 * 3600, "Asia/Krasnoyarsk",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Krasnoyarsk", tz);
	tz = new SimpleTimeZone(8000 * 3600, "CTT");
	timezones0.put("CTT", tz);
	timezones0.put("Antarctica/Casey", tz);
	timezones0.put("Asia/Brunei", tz);
	timezones0.put("Asia/Chongqing", tz);
	timezones0.put("Asia/Harbin", tz);
	timezones0.put("Asia/Hong_Kong", tz);
	timezones0.put("Asia/Kashgar", tz);
	timezones0.put("Asia/Kuala_Lumpur", tz);
	timezones0.put("Asia/Kuching", tz);
	timezones0.put("Asia/Macau", tz);
	timezones0.put("Asia/Makassar", tz);
	timezones0.put("Asia/Manila", tz);
	timezones0.put("Asia/Shanghai", tz);
	timezones0.put("Asia/Singapore", tz);
	timezones0.put("Asia/Taipei", tz);
	timezones0.put("Asia/Urumqi", tz);
	timezones0.put("Australia/Perth", tz);
	tz = new SimpleTimeZone
	  (8000 * 3600, "Asia/Irkutsk",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Irkutsk", tz);
	tz = new SimpleTimeZone
	  (8000 * 3600, "Asia/Ulaanbaatar",
	   Calendar.MARCH, -1, Calendar.SATURDAY, 2000 * 3600,
	   Calendar.SEPTEMBER, -1, Calendar.SATURDAY, 2000 * 3600);
	timezones0.put("Asia/Ulaanbaatar", tz);
	tz = new SimpleTimeZone(8750 * 3600, "Australia/Eucla");
	timezones0.put("Australia/Eucla", tz);
	tz = new SimpleTimeZone
	  (9000 * 3600, "Asia/Choibalsan",
	   Calendar.MARCH, -1, Calendar.SATURDAY, 2000 * 3600,
	   Calendar.SEPTEMBER, -1, Calendar.SATURDAY, 2000 * 3600);
	timezones0.put("Asia/Choibalsan", tz);
	tz = new SimpleTimeZone(9000 * 3600, "JST");
	timezones0.put("JST", tz);
	timezones0.put("Asia/Dili", tz);
	timezones0.put("Asia/Jayapura", tz);
	timezones0.put("Asia/Pyongyang", tz);
	timezones0.put("Asia/Seoul", tz);
	timezones0.put("Asia/Tokyo", tz);
	timezones0.put("Pacific/Palau", tz);
	tz = new SimpleTimeZone
	  (9000 * 3600, "Asia/Yakutsk",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Yakutsk", tz);
	tz = new SimpleTimeZone
	  (9500 * 3600, "Australia/Adelaide",
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Australia/Adelaide", tz);
	timezones0.put("Australia/Broken_Hill", tz);
	tz = new SimpleTimeZone(9500 * 3600, "ACT");
	timezones0.put("ACT", tz);
	timezones0.put("Australia/Darwin", tz);
	tz = new SimpleTimeZone(10000 * 3600, "Antarctica/DumontDUrville");
	timezones0.put("Antarctica/DumontDUrville", tz);
	timezones0.put("Australia/Brisbane", tz);
	timezones0.put("Australia/Lindeman", tz);
	timezones0.put("Pacific/Guam", tz);
	timezones0.put("Pacific/Port_Moresby", tz);
	timezones0.put("Pacific/Saipan", tz);
	timezones0.put("Pacific/Truk", tz);
	tz = new SimpleTimeZone
	  (10000 * 3600, "Asia/Sakhalin",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Sakhalin", tz);
	timezones0.put("Asia/Vladivostok", tz);
	tz = new SimpleTimeZone
	  (10000 * 3600, "Australia/Currie",
	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Australia/Currie", tz);
	timezones0.put("Australia/Hobart", tz);
	tz = new SimpleTimeZone
	  (10000 * 3600, "AET",
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.MARCH, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("AET", tz);
	timezones0.put("Australia/Melbourne", tz);
	timezones0.put("Australia/Sydney", tz);
	tz = new SimpleTimeZone
	  (10500 * 3600, "Australia/Lord_Howe",
	  Calendar.OCTOBER, -1, Calendar.SUNDAY, 2000 * 3600,
	  Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600, 500 * 3600);
	timezones0.put("Australia/Lord_Howe", tz);
	tz = new SimpleTimeZone
	  (11000 * 3600, "Asia/Magadan",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Magadan", tz);
	tz = new SimpleTimeZone(11000 * 3600, "SST");
	timezones0.put("SST", tz);
	timezones0.put("Pacific/Efate", tz);
	timezones0.put("Pacific/Guadalcanal", tz);
	timezones0.put("Pacific/Kosrae", tz);
	timezones0.put("Pacific/Noumea", tz);
	timezones0.put("Pacific/Ponape", tz);
	tz = new SimpleTimeZone(11500 * 3600, "Pacific/Norfolk");
	timezones0.put("Pacific/Norfolk", tz);
	tz = new SimpleTimeZone
	  (12000 * 3600, "NST",
	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.MARCH, 3, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("NST", tz);
	timezones0.put("Antarctica/McMurdo", tz);
	timezones0.put("Antarctica/South_Pole", tz);
	timezones0.put("Pacific/Auckland", tz);
	tz = new SimpleTimeZone
	  (12000 * 3600, "Asia/Anadyr",
	   Calendar.MARCH, -1, Calendar.SUNDAY, 2000 * 3600,
	   Calendar.OCTOBER, -1, Calendar.SUNDAY, 3000 * 3600);
	timezones0.put("Asia/Anadyr", tz);
	timezones0.put("Asia/Kamchatka", tz);
	tz = new SimpleTimeZone(12000 * 3600, "Pacific/Fiji");
	timezones0.put("Pacific/Fiji", tz);
	timezones0.put("Pacific/Funafuti", tz);
	timezones0.put("Pacific/Kwajalein", tz);
	timezones0.put("Pacific/Majuro", tz);
	timezones0.put("Pacific/Nauru", tz);
	timezones0.put("Pacific/Tarawa", tz);
	timezones0.put("Pacific/Wake", tz);
	timezones0.put("Pacific/Wallis", tz);
	tz = new SimpleTimeZone
	  (12750 * 3600, "Pacific/Chatham",
	   Calendar.OCTOBER, 1, Calendar.SUNDAY, 2750 * 3600,
	   Calendar.MARCH, 3, Calendar.SUNDAY, 3750 * 3600);
	timezones0.put("Pacific/Chatham", tz);
	tz = new SimpleTimeZone(13000 * 3600, "Pacific/Enderbury");
	timezones0.put("Pacific/Enderbury", tz);
	timezones0.put("Pacific/Tongatapu", tz);
	tz = new SimpleTimeZone(14000 * 3600, "Pacific/Kiritimati");
	timezones0.put("Pacific/Kiritimati", tz);
      }
    return timezones0;
  }

  /**
   * Maps a time zone name (with optional GMT offset and daylight time
   * zone name) to one of the known time zones.  This method called
   * with the result of System.getProperty("user.timezone")
   * or getDefaultTimeZoneId().  Note that giving one of
   * the standard tz data names from ftp://elsie.nci.nih.gov/pub/ is
   * preferred.
   * The time zone name can be given as follows:
   * (standard zone name)[(GMT offset)[(DST zone name)[DST offset]]]
   *
   *

   * If only a (standard zone name) is given (no numbers in the
   * String) then it gets mapped directly to the TimeZone with that
   * name, if that fails null is returned.
   *

   * Alternately, a POSIX-style TZ string can be given, defining the time zone:
   * std offset dst offset,date/time,date/time
   * See the glibc manual, or the man page for tzset for details
   * of this format.
   *

   * A GMT offset is the offset to add to the local time to get GMT.
   * If a (GMT offset) is included (either in seconds or hours) then
   * an attempt is made to find a TimeZone name matching both the name
   * and the offset (that doesn't observe daylight time, if the
   * timezone observes daylight time then you must include a daylight
   * time zone name after the offset), if that fails then a TimeZone
   * with the given GMT offset is returned (whether or not the
   * TimeZone observes daylight time is ignored), if that also fails
   * the GMT TimeZone is returned.
   *

   * If the String ends with (GMT offset)(daylight time zone name)
   * then an attempt is made to find a TimeZone with the given name and
   * GMT offset that also observes (the daylight time zone name is not
   * currently used in any other way), if that fails a TimeZone with
   * the given GMT offset that observes daylight time is returned, if
   * that also fails the GMT TimeZone is returned.
   *

   * Examples: In Chicago, the time zone id could be "CST6CDT", but
   * the preferred name would be "America/Chicago".  In Indianapolis
   * (which does not have Daylight Savings Time) the string could be
   * "EST5", but the preferred name would be "America/Indianapolis".
   * The standard time zone name for The Netherlands is "Europe/Amsterdam",
   * but can also be given as "CET-1CEST".
   */
  static TimeZone getDefaultTimeZone(String sysTimeZoneId)
  {
    String stdName = null;
    String dstName;
    int stdOffs;
    int dstOffs;
    try
      {
	int idLength = sysTimeZoneId.length();

	int index = 0;
	int prevIndex;
	char c;

	// get std
	do
	  c = sysTimeZoneId.charAt(index++);
	while (c != '+' && c != '-' && c != ',' && c != ':'
	       && ! Character.isDigit(c) && c != '\0' && index < idLength);

	if (index >= idLength)
	  return (TimeZone)timezones().get(sysTimeZoneId);

	stdName = sysTimeZoneId.substring(0, --index);
	prevIndex = index;

	// get the std offset
	do
	  c = sysTimeZoneId.charAt(index++);
	while ((c == '-' || c == '+' || c == ':' || Character.isDigit(c))
	       && index < idLength);
	if (index < idLength)
	  index--;

	{ // convert the dst string to a millis number
	    String offset = sysTimeZoneId.substring(prevIndex, index);
	    prevIndex = index;

	    if (offset.charAt(0) == '+' || offset.charAt(0) == '-')
	      stdOffs = parseTime(offset.substring(1));
	    else
	      stdOffs = parseTime(offset);

	    if (offset.charAt(0) == '-')
	      stdOffs = -stdOffs;

	    // TZ timezone offsets are positive when WEST of the meridian.
	    stdOffs = -stdOffs;
	}

	// Done yet? (Format: std offset)
	if (index >= idLength)
	  {
	    // Do we have an existing timezone with that name and offset?
	    TimeZone tz = (TimeZone) timezones().get(stdName);
	    if (tz != null)
	      if (tz.getRawOffset() == stdOffs)
		return tz;

	    // Custom then.
	    return new SimpleTimeZone(stdOffs, stdName);
	  }

	// get dst
	do
	  c = sysTimeZoneId.charAt(index++);
	while (c != '+' && c != '-' && c != ',' && c != ':'
	       && ! Character.isDigit(c) && c != '\0' && index < idLength);

	// Done yet? (Format: std offset dst)
	if (index >= idLength)
	  {
	    // Do we have an existing timezone with that name and offset
	    // which has DST?
	    TimeZone tz = (TimeZone) timezones().get(stdName);
	    if (tz != null)
	      if (tz.getRawOffset() == stdOffs && tz.useDaylightTime())
		return tz;

	    // Custom then.
	    return new SimpleTimeZone(stdOffs, stdName);
	  }

	// get the dst offset
	dstName = sysTimeZoneId.substring(prevIndex, --index);
	prevIndex = index;
	do
	  c = sysTimeZoneId.charAt(index++);
	while ((c == '-' || c == '+' || c == ':' || Character.isDigit(c))
	       && index < idLength);
	if (index < idLength)
	  index--;

	{ // convert the dst string to a millis number
	    String offset = sysTimeZoneId.substring(prevIndex, index);
	    prevIndex = index;

	    if (offset.charAt(0) == '+' || offset.charAt(0) == '-')
	      dstOffs = parseTime(offset.substring(1));
	    else
	      dstOffs = parseTime(offset);

	    if (offset.charAt(0) == '-')
	      dstOffs = -dstOffs;

	    // TZ timezone offsets are positive when WEST of the meridian.
	    dstOffs = -dstOffs;
	}

	// Done yet? (Format: std offset dst offset)
	// FIXME: We don't support DST without a rule given. Should we?
	if (index >= idLength)
	  {
	    // Time Zone existing with same name, dst and offsets?
	    TimeZone tz = (TimeZone) timezones().get(stdName);
	    if (tz != null)
	      if (tz.getRawOffset() == stdOffs && tz.useDaylightTime()
	          && tz.getDSTSavings() == (dstOffs - stdOffs))
		return tz;

	    return new SimpleTimeZone(stdOffs, stdName);
	  }

	// get the DST rule
	if (sysTimeZoneId.charAt(index) == ','
	    || sysTimeZoneId.charAt(index) == ';')
	  {
	    index++;
	    int offs = index;
	    while (sysTimeZoneId.charAt(index) != ','
	           && sysTimeZoneId.charAt(index) != ';')
	      index++;
	    String startTime = sysTimeZoneId.substring(offs, index);
	    index++;
	    String endTime = sysTimeZoneId.substring(index);

	    index = startTime.indexOf('/');
	    int startMillis;
	    int endMillis;
	    String startDate;
	    String endDate;
	    if (index != -1)
	      {
		startDate = startTime.substring(0, index);
		startMillis = parseTime(startTime.substring(index + 1));
	      }
	    else
	      {
		startDate = startTime;
		// if time isn't given, default to 2:00:00 AM.
		startMillis = 2 * 60 * 60 * 1000;
	      }
	    index = endTime.indexOf('/');
	    if (index != -1)
	      {
		endDate = endTime.substring(0, index);
		endMillis = parseTime(endTime.substring(index + 1));
	      }
	    else
	      {
		endDate = endTime;
		// if time isn't given, default to 2:00:00 AM.
		endMillis = 2 * 60 * 60 * 1000;
	      }

	    int[] start = getDateParams(startDate);
	    int[] end = getDateParams(endDate);
	    return new SimpleTimeZone(stdOffs, stdName, start[0], start[1],
	                              start[2], startMillis, end[0], end[1],
	                              end[2], endMillis, (dstOffs - stdOffs));
	  }
      }

    // FIXME: Produce a warning here?
    catch (IndexOutOfBoundsException _)
      {
      }
    catch (NumberFormatException _)
      {
      }

    return null;
  }

  /**
   * Parses and returns the params for a POSIX TZ date field,
   * in the format int[]{ month, day, dayOfWeek }, following the
   * SimpleTimeZone constructor rules.
   */
  private static int[] getDateParams(String date)
  {
    int[] dayCount = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
    int month;

    if (date.charAt(0) == 'M' || date.charAt(0) == 'm')
      {
	int day;

	// Month, week of month, day of week
	month = Integer.parseInt(date.substring(1, date.indexOf('.')));
	int week = Integer.parseInt(date.substring(date.indexOf('.') + 1,
	                                           date.lastIndexOf('.')));
	int dayOfWeek = Integer.parseInt(date.substring(date.lastIndexOf('.')
	                                                + 1));
	if (week == 5)
	  day = -1; // last day of month is -1 in java, 5 in TZ
	else
	  // first day of week starting on or after.
	  day = (week - 1) * 7 + 1;

	dayOfWeek++; // Java day of week is one-based, Sunday is first day.
	month--; // Java month is zero-based.
	return new int[] { month, day, dayOfWeek };
      }

    // julian day, either zero-based 0<=n<=365 (incl feb 29)
    // or one-based 1<=n<=365 (no feb 29)
    int julianDay; // Julian day,

    if (date.charAt(0) != 'J' || date.charAt(0) != 'j')
      {
	julianDay = Integer.parseInt(date.substring(1));
	julianDay++; // make 1-based
	// Adjust day count to include feb 29.
	dayCount = new int[]
	           {
	             0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335
	           };
      }
    else
      // 1-based julian day
      julianDay = Integer.parseInt(date);

    int i = 11;
    while (i > 0)
      if (dayCount[i] < julianDay)
	break;
      else
	i--;
    julianDay -= dayCount[i];
    month = i;
    return new int[] { month, julianDay, 0 };
  }

  /**
   * Parses a time field hh[:mm[:ss]], returning the result
   * in milliseconds. No leading sign.
   */
  private static int parseTime(String time)
  {
    int millis = 0;
    int i = 0;

    while (i < time.length())
      if (time.charAt(i) == ':')
	break;
      else
	i++;
    millis = 60 * 60 * 1000 * Integer.parseInt(time.substring(0, i));
    if (i >= time.length())
      return millis;

    int iprev = ++i;
    while (i < time.length())
      if (time.charAt(i) == ':')
	break;
      else
	i++;
    if (i >= time.length())
      return millis;

    millis += 60 * 1000 * Integer.parseInt(time.substring(iprev, i));
    millis += 1000 * Integer.parseInt(time.substring(++i));
    return millis;
  }

  /**
   * Gets the time zone offset, for current date, modified in case of
   * daylight savings.  This is the offset to add to UTC to get the local
   * time.
   * @param era the era of the given date
   * @param year the year of the given date
   * @param month the month of the given date, 0 for January.
   * @param day the day of month
   * @param dayOfWeek the day of week
   * @param milliseconds the millis in the day (in local standard time)
   * @return the time zone offset in milliseconds.
   */
  public abstract int getOffset(int era, int year, int month,
				int day, int dayOfWeek, int milliseconds);

  /**
   * Get the time zone offset for the specified date, modified in case of
   * daylight savings.  This is the offset to add to UTC to get the local
   * time.
   * @param date the date represented in millisecends
   * since January 1, 1970 00:00:00 GMT.
   * @since 1.4
   */
  public int getOffset(long date)
  {
    return (inDaylightTime(new Date(date))
            ? getRawOffset() + getDSTSavings()
            : getRawOffset());
  }

  /**
   * Gets the time zone offset, ignoring daylight savings.  This is
   * the offset to add to UTC to get the local time.
   * @return the time zone offset in milliseconds.
   */
  public abstract int getRawOffset();

  /**
   * Sets the time zone offset, ignoring daylight savings.  This is
   * the offset to add to UTC to get the local time.
   * @param offsetMillis the time zone offset to GMT.
   */
  public abstract void setRawOffset(int offsetMillis);

  /**
   * Gets the identifier of this time zone. For instance, PST for
   * Pacific Standard Time.
   * @returns the ID of this time zone.
   */
  public String getID()
  {
    return ID;
  }

  /**
   * Sets the identifier of this time zone. For instance, PST for
   * Pacific Standard Time.
   * @param id the new time zone ID.
   * @throws NullPointerException if id is null
   */
  public void setID(String id)
  {
    if (id == null)
      throw new NullPointerException();

    this.ID = id;
  }

  /**
   * This method returns a string name of the time zone suitable
   * for displaying to the user.  The string returned will be the long
   * description of the timezone in the current locale.  The name
   * displayed will assume daylight savings time is not in effect.
   *
   * @return The name of the time zone.
   */
  public final String getDisplayName()
  {
    return (getDisplayName(false, LONG, Locale.getDefault()));
  }

  /**
   * This method returns a string name of the time zone suitable
   * for displaying to the user.  The string returned will be the long
   * description of the timezone in the specified locale. The name
   * displayed will assume daylight savings time is not in effect.
   *
   * @param locale The locale for this timezone name.
   *
   * @return The name of the time zone.
   */
  public final String getDisplayName(Locale locale)
  {
    return (getDisplayName(false, LONG, locale));
  }

  /**
   * This method returns a string name of the time zone suitable
   * for displaying to the user.  The string returned will be of the
   * specified type in the current locale.
   *
   * @param dst Whether or not daylight savings time is in effect.
   * @param style LONG for a long name, SHORT for
   * a short abbreviation.
   *
   * @return The name of the time zone.
   */
  public final String getDisplayName(boolean dst, int style)
  {
    return (getDisplayName(dst, style, Locale.getDefault()));
  }

  /**
   * This method returns a string name of the time zone suitable
   * for displaying to the user.  The string returned will be of the
   * specified type in the specified locale.
   *
   * @param dst Whether or not daylight savings time is in effect.
   * @param style LONG for a long name, SHORT for
   * a short abbreviation.
   * @param locale The locale for this timezone name.
   *
   * @return The name of the time zone.
   */
  public String getDisplayName(boolean dst, int style, Locale locale)
  {
    DateFormatSymbols dfs;
    try
      {
	dfs = new DateFormatSymbols(locale);

	// The format of the value returned is defined by us.
	String[][]zoneinfo = dfs.getZoneStrings();
	for (int i = 0; i < zoneinfo.length; i++)
	  {
	    if (zoneinfo[i][0].equals(getID()))
	      {
		if (!dst)
		  {
		    if (style == SHORT)
		      return (zoneinfo[i][2]);
		    else
		      return (zoneinfo[i][1]);
		  }
		else
		  {
		    if (style == SHORT)
		      return (zoneinfo[i][4]);
		    else
		      return (zoneinfo[i][3]);
		  }
	      }
	  }
      }
    catch (MissingResourceException e)
      {
      }

    return getDefaultDisplayName(dst);
  }

  private String getDefaultDisplayName(boolean dst)
  {
    int offset = getRawOffset();
    if (dst && this instanceof SimpleTimeZone)
      {
	// ugly, but this is a design failure of the API:
	// getDisplayName takes a dst parameter even though
	// TimeZone knows nothing about daylight saving offsets.
	offset += ((SimpleTimeZone) this).getDSTSavings();
      }

    StringBuffer sb = new StringBuffer(9);
    sb.append("GMT");

    offset = offset / (1000 * 60);
    int hours = Math.abs(offset) / 60;
    int minutes = Math.abs(offset) % 60;

    if (minutes != 0 || hours != 0)
      {
	sb.append(offset >= 0 ? '+' : '-');
	sb.append((char) ('0' + hours / 10));
	sb.append((char) ('0' + hours % 10));
	sb.append(':');
	sb.append((char) ('0' + minutes / 10));
	sb.append((char) ('0' + minutes % 10));
      }

    return sb.toString();
  }

  /**
   * Returns true, if this time zone uses Daylight Savings Time.
   */
  public abstract boolean useDaylightTime();

  /**
   * Returns true, if the given date is in Daylight Savings Time in this
   * time zone.
   * @param date the given Date.
   */
  public abstract boolean inDaylightTime(Date date);

  /**
   * Gets the daylight savings offset.  This is a positive offset in
   * milliseconds with respect to standard time.  Typically this
   * is one hour, but for some time zones this may be half an our.
   *
The default implementation returns 3600000 milliseconds
   * (one hour) if the time zone uses daylight savings time
   * (as specified by {@link #useDaylightTime()}), otherwise
   * it returns 0.
   * @return the daylight savings offset in milliseconds.
   * @since 1.4
   */
  public int getDSTSavings ()
  {
    return useDaylightTime () ? 3600000 : 0;
  }

  /**
   * Gets the TimeZone for the given ID.
   * @param ID the time zone identifier.
   * @return The time zone for the identifier or GMT, if no such time
   * zone exists.
   */
  // FIXME: XXX: JCL indicates this and other methods are synchronized.
  public static TimeZone getTimeZone(String ID)
  {
    // First check timezones hash
    TimeZone tz = (TimeZone) timezones().get(ID);
    if (tz != null)
      {
	if (tz.getID().equals(ID))
	  return tz;

	// We always return a timezone with the requested ID.
	// This is the same behaviour as with JDK1.2.
	tz = (TimeZone) tz.clone();
	tz.setID(ID);
	// We also save the alias, so that we return the same
	// object again if getTimeZone is called with the same
	// alias.
	timezones().put(ID, tz);
	return tz;
      }

    // See if the ID is really a GMT offset form.
    // Note that GMT is in the table so we know it is different.
    if (ID.startsWith("GMT"))
      {
	int pos = 3;
	int offset_direction = 1;

	if (ID.charAt(pos) == '-')
	  {
	    offset_direction = -1;
	    pos++;
	  }
	else if (ID.charAt(pos) == '+')
	  {
	    pos++;
	  }

	try
	  {
	    int hour, minute;

	    String offset_str = ID.substring(pos);
	    int idx = offset_str.indexOf(":");
	    if (idx != -1)
	      {
		hour = Integer.parseInt(offset_str.substring(0, idx));
		minute = Integer.parseInt(offset_str.substring(idx + 1));
	      }
	    else
	      {
		int offset_length = offset_str.length();
		if (offset_length <= 2)
		  {
		    // Only hour
		    hour = Integer.parseInt(offset_str);
		    minute = 0;
		  }
		else
		  {
		    // hour and minute, not separated by colon
		    hour = Integer.parseInt
		      (offset_str.substring(0, offset_length - 2));
		    minute = Integer.parseInt
		      (offset_str.substring(offset_length - 2));
		  }
	      }

	    return new SimpleTimeZone((hour * (60 * 60 * 1000) +
				       minute * (60 * 1000))
				      * offset_direction, ID);
	  }
	catch (NumberFormatException e)
	  {
	  }
      }

    // Finally, return GMT per spec
    return getTimeZone("GMT");
  }

  /**
   * Gets the available IDs according to the given time zone
   * offset.
   * @param rawOffset the given time zone GMT offset.
   * @return An array of IDs, where the time zone has the specified GMT
   * offset. For example {"Phoenix", "Denver"}, since both have
   * GMT-07:00, but differ in daylight savings behaviour.
   */
  public static String[] getAvailableIDs(int rawOffset)
  {
    int count = 0;
    Iterator iter = timezones().entrySet().iterator();
    while (iter.hasNext())
      {
	// Don't iterate the values, since we want to count
	// doubled values (aliases)
	Map.Entry entry = (Map.Entry) iter.next();
	if (((TimeZone) entry.getValue()).getRawOffset() == rawOffset)
	  count++;
      }

    String[] ids = new String[count];
    count = 0;
    iter = timezones().entrySet().iterator();
    while (iter.hasNext())
      {
	Map.Entry entry = (Map.Entry) iter.next();
	if (((TimeZone) entry.getValue()).getRawOffset() == rawOffset)
	  ids[count++] = (String) entry.getKey();
      }
    return ids;
  }

  /**
   * Gets all available IDs.
   * @return An array of all supported IDs.
   */
  public static String[] getAvailableIDs()
  {
    return (String[])
      timezones().keySet().toArray(new String[timezones().size()]);
  }

  /**
   * Returns the time zone under which the host is running.  This
   * can be changed with setDefault.
   *
   * @return A clone of the current default time zone for this host.
   * @see #setDefault
   */
  public static TimeZone getDefault()
  {
    return (TimeZone) defaultZone().clone();
  }

  public static void setDefault(TimeZone zone)
  {
    // Hmmmm. No Security checks?
    defaultZone0 = zone;
  }

  /**
   * Test if the other time zone uses the same rule and only
   * possibly differs in ID.  This implementation for this particular
   * class will return true if the raw offsets are identical.  Subclasses
   * should override this method if they use daylight savings.
   * @return true if this zone has the same raw offset
   */
  public boolean hasSameRules(TimeZone other)
  {
    return other.getRawOffset() == getRawOffset();
  }

  /**
   * Returns a clone of this object.  I can't imagine, why this is
   * useful for a time zone.
   */
  public Object clone()
  {
    try
      {
	return super.clone();
      }
    catch (CloneNotSupportedException ex)
      {
	return null;
      }
  }
}

redpajama_set_name: RedPajamaGithub


text:
package org.trimou.trimness.config;

import java.security.AccessController;
import java.security.PrivilegedAction;

/**
 *
 * @author Martin Kouba
 */
final class SecurityActions {

    /**
     *
     * @param key
     * @return {@link System#getProperty(String)}
     */
    static String getSystemProperty(final String key) {
        if (System.getSecurityManager() == null) {
            return System.getProperty(key);
        }
        return AccessController.doPrivileged(new PrivilegedAction<String>() {
            @Override
            public String run() {
                return System.getProperty(key);
            }
        });
    }

    /**
     *
     * @param key
     * @return {@link System#getProperty(String)}
     */
    static String getEnv(final String key) {
        if (System.getSecurityManager() == null) {
            return System.getProperty(key);
        }
        return AccessController.doPrivileged(new PrivilegedAction<String>() {
            @Override
            public String run() {
                return System.getenv(key);
            }
        });
    }

    /**
     *
     * @return the TCCL
     */
    static ClassLoader getContextClassLoader() {
        if (System.getSecurityManager() == null) {
            return Thread.currentThread().getContextClassLoader();
        }
        return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
            @Override
            public ClassLoader run() {
                return Thread.currentThread().getContextClassLoader();
            }
        });
    }

    /**
     *
     * @return the ClassLoader for the given class
     */
    static ClassLoader getClassLoader(final Class<?> clazz) {
        if (System.getSecurityManager() == null) {
            return clazz.getClassLoader();
        }
        return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
            @Override
            public ClassLoader run() {
                return clazz.getClassLoader();
            }
        });
    }

}


text:
/*
 * Author: Alexander Krause
 * modified by Felix Machaczek
 * Kiel University, Department of Computer Science, 24098 Kiel, Germany
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;

namespace ExplorVizGestureControl.General
{
    /*
     * The GestureTimer is basicaly a Timer implementation with a busy attribute, for getting to know
     * if the timer is currently counting down or not.
     */
    public class GestureTimer
    {
        #region Variables
        private Timer timer;
        public bool busy = false;
        #endregion

        #region Initialization
        public GestureTimer(double timeSpan)
        {
            timer = new Timer(timeSpan);
            timer.AutoReset = false;
            // Add the event handler for timer.Elapsed, to set the busy attribute on false. See OnElapsedTime()
            timer.Elapsed += new ElapsedEventHandler(OnElapsedTime);
            timer.Start();
            busy = true;
        }
        #endregion

        #region Function
        /*
         * The StartTimer function can start a new timer run, but also restart a currently running one.
         * In this case, busy is set to true.
         */
        public void StartTimer()
        {
            busy = true;
            timer.Stop();
            timer.Start();
        }

        public void StopTimer()
        {
            busy = false;
            timer.Stop();
        }

        /*
         * OnElapsedTime defines the event, triggered, if the timer has ran out. In this case, busy is set back to false.
        */
        private void OnElapsedTime(object sender, ElapsedEventArgs e)
        {
            busy = false;
            //Console.WriteLine("elapsed" + DateTime.Now.ToString());
        }

        public void ChangeTimerCycle(double timeSpan)
        {
            timer.Stop();
            timer.Interval = timeSpan;
            StartTimer();
        }
        #endregion

    }
}


text:
"""OSC Servers that receive UDP packets and invoke handlers accordingly.

Use like this:

dispatcher = dispatcher.Dispatcher()
# This will print all parameters to stdout.
dispatcher.map("/bpm", print)
server = ForkingOSCUDPServer((ip, port), dispatcher)
server.serve_forever()

or run the server on its own thread:
server = ForkingOSCUDPServer((ip, port), dispatcher)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.start()
...
server.shutdown()

Those servers are using the standard socketserver from the standard library:
http://docs.python.org/library/socketserver.html

Alternatively, the AsyncIOOSCUDPServer server can be integrated with an
asyncio event loop:

loop = asyncio.get_event_loop()
server = AsyncIOOSCUDPServer(server_address, dispatcher, loop)
server.serve()
loop.run_forever()

"""

import asyncio
import socketserver
import time

from pythonosc import osc_bundle
from pythonosc import osc_message
from pythonosc import osc_packet

def _call_handlers_for_packet(data, dispatcher):
  """
  This function calls the handlers registered to the dispatcher for
  every message it found in the packet.
  The process/thread granularity is thus the OSC packet, not the handler.

  If parameters were registered with the dispatcher, then the handlers are
  called this way:
    handler('/address that triggered the message',
            registered_param_list, osc_msg_arg1, osc_msg_arg2, ...)
  if no parameters were registered, then it is just called like this:
    handler('/address that triggered the message',
            osc_msg_arg1, osc_msg_arg2, osc_msg_param3, ...)
  """

  # Get OSC messages from all bundles or standalone message.
  try:
    packet = osc_packet.OscPacket(data)
    for timed_msg in packet.messages:
      now = time.time()
      handlers = dispatcher.handlers_for_address(
          timed_msg.message.address)
      if not handlers:
        continue
      # If the message is to be handled later, then so be it.
      if timed_msg.time > now:
        time.sleep(timed_msg.time - now)
      for handler in handlers:
        if handler.args:
          handler.callback(
              timed_msg.message.address, handler.args, *timed_msg.message)
        else:
          handler.callback(timed_msg.message.address, *timed_msg.message)
  except osc_packet.ParseError:
    pass

class _UDPHandler(socketserver.BaseRequestHandler):
  """Handles correct UDP messages for all types of server.

  Whether this will be run on its own thread, the server's or a whole new
  process depends on the server you instanciated, look at their documentation.

  This method is called after a basic sanity check was done on the datagram,
  basically whether this datagram looks like an osc message or bundle,
  if not the server won't even bother to call it and so no new
  threads/processes will be spawned.
  """
  def handle(self):
    _call_handlers_for_packet(self.request[0], self.server.dispatcher)

def _is_valid_request(request):
  """Returns true if the request's data looks like an osc bundle or message."""
  data = request[0]
  return (
      osc_bundle.OscBundle.dgram_is_bundle(data)
      or osc_message.OscMessage.dgram_is_message(data))

class OSCUDPServer(socketserver.UDPServer):
  """Superclass for different flavors of OSCUDPServer"""

  def __init__(self, server_address, dispatcher):
    super().__init__(server_address, _UDPHandler)
    self._dispatcher = dispatcher

  def verify_request(self, request, client_address):
    """Returns true if the data looks like a valid OSC UDP datagram."""
    return _is_valid_request(request)

  @property
  def dispatcher(self):
    """Dispatcher accessor for handlers to dispatch osc messages."""
    return self._dispatcher

class BlockingOSCUDPServer(OSCUDPServer):
  """Blocking version of the UDP server.

  Each message will be handled sequentially on the same thread.
  Use this is you don't care about latency in your message handling or don't
  have a multiprocess/multithread environment (really?).
  """

class ThreadingOSCUDPServer(socketserver.ThreadingMixIn, OSCUDPServer):
  """Threading version of the OSC UDP server.

  Each message will be handled in its own new thread.
  Use this when lightweight operations are done by each message handlers.
  """

class ForkingOSCUDPServer(socketserver.ForkingMixIn, OSCUDPServer):
  """Forking version of the OSC UDP server.

  Each message will be handled in its own new process.
  Use this when heavyweight operations are done by each message handlers
  and forking a whole new process for each of them is worth it.
  """

class AsyncIOOSCUDPServer():
  """Asyncio version of the OSC UDP Server.
  Each UDP message is handled by _call_handlers_for_packet, the same method as in the
  OSCUDPServer family of blocking, threading, and forking servers
  """

  def __init__(self, server_address, dispatcher, loop):
    """
    :param server_address: tuple of (IP address to bind to, port)
    :param dispatcher: a pythonosc.dispatcher.Dispatcher
    :param loop: an asyncio event loop
    """

    self._server_address = server_address
    self._dispatcher = dispatcher
    self._loop = loop

  class _OSCProtocolFactory(asyncio.DatagramProtocol):
    """OSC protocol factory which passes datagrams to _call_handlers_for_packet"""

    def __init__(self, dispatcher):
      self.dispatcher = dispatcher

    def datagram_received(self, data, unused_addr):
      _call_handlers_for_packet(data, self.dispatcher)

  def serve(self):
    """creates a datagram endpoint and registers it with our event loop"""
    listen = self._loop.create_datagram_endpoint(
      lambda: self._OSCProtocolFactory(self.dispatcher),
      local_addr=self._server_address)
    self._loop.run_until_complete(listen)

  @property
  def dispatcher(self):
    return self._dispatcher


text:
package com.nscg.app.model.domain;

/**
 * Created by liuyongfeng on 2017/5/19.
 */

public class AfterCompositeComponents {
    private long ResourceID;
    private long RelevantID;
    private String ResourceUrl;
    private String AttachmentUrl;
    private String ResourceRemark;

    public AfterCompositeComponents() {
        super();
        // TODO Auto-generated constructor stub
    }

    public long getResourceID() {
        return ResourceID;
    }

    public void setResourceID(long resourceID) {
        ResourceID = resourceID;
    }

    public long getRelevantID() {
        return RelevantID;
    }

    public void setRelevantID(long relevantID) {
        RelevantID = relevantID;
    }

    public String getResourceUrl() {
        return ResourceUrl;
    }

    public void setResourceUrl(String resourceUrl) {
        ResourceUrl = resourceUrl;
    }

    public String getAttachmentUrl() {
        return AttachmentUrl;
    }

    public void setAttachmentUrl(String attachmentUrl) {
        AttachmentUrl = attachmentUrl;
    }

    public String getResourceRemark() {
        return ResourceRemark;
    }

    public void setResourceRemark(String resourceRemark) {
        ResourceRemark = resourceRemark;
    }
}


text:
To deploy Minio on DC/OS, you can use a Universe package, or create a customized config file. We at Minio recently released an [official universe package](https://github.com/mesosphere/universe/tree/version-3.x/repo/packages/M/minio/0) to enable single click Minio deployment on a DC/OS cluster.

## 1. Prerequisites

- DC/OS 1.8 or later running on your cluster.
- [Marathon-LB](https://dcos.io/docs/1.8/usage/service-discovery/marathon-lb/usage/) installed and running.
- IP address of the public agent(s) where Marathon-LB or an available hostname configured to point to the public agent(s) where Marathon-LB is running.

## 2. Setting up Minio

You can install Minio Universe package using the DC/OS GUI or CLI.

### Minio installation on DC/OS GUI

Visit the DC/OS admin page, and click on `Universe` on the left menu bar. Then click on the `Packages` tab and search for Minio. Once you see the package, click the `Install Package` button on the right hand side. Then, enter configuration values like the storage and service type you'd like to use with your Minio instance. Finally enter the public Marathon-LB IP address under `networking >> public-agent`, and click `Review and Install`.

This completes the install process. Before you can access Minio server, get the access key and secret key from the Minio container logs. Click on `Services` and select Minio service in DC/OS admin page. Then go to the `logs` tab and copy the accesskey and secretkey.

### Minio installation on DC/OS CLI

To install Minio package via CLI, type

```bash
$ dcos package install minio
```

## 3. Uninstalling Minio

To uninstall Minio package via CLI, type

```bash
$ dcos package uninstall minio
```

### Explore Further
- [Minio Erasure Code QuickStart Guide](https://docs.minio.io/docs/minio-erasure-code-quickstart-guide)
- [DC/OS Project](https://docs.mesosphere.com/)


text:
from django import forms

from apps.webshop import models

class OrderForm(forms.ModelForm):
    class Meta:
        model = models.Order
        fields = ['quantity', 'size']