/**********************************************************************
    * ConnectionHeader.java
    * created on 04.03.2005 by netseeker
    * $Source: /cvsroot/ejoe/EJOE/src/de/netseeker/ejoe/ConnectionHeader.java,v $
    * $Date: 2006/02/04 14:16:35 $
    * $Revision: 1.17 $
    *********************************************************************/
   package de.netseeker.ejoe;
   
  import java.io.Serializable;
  import java.io.UnsupportedEncodingException;
  import java.nio.ByteBuffer;
  import java.nio.channels.SelectableChannel;
  import java.util.zip.Deflater;
  
  /***
   * A simple connection header contining informations about compression and
   * blocking/non-blocking io features.
   *
   * @author netseeker
   */
  public final class ConnectionHeader implements Serializable
  {
  	private static final long			serialVersionUID	= 3258131375298458928L;
  
  	private boolean[]					_header;
  
  	private transient ByteBuffer		_waitingBuffer;
  
  	private transient SelectableChannel	_channel;
  
  	private Object						_attachment;
  
  	private int							_compressionLevel	= Deflater.DEFAULT_COMPRESSION;
  
  	private String						_adapterClass;
  
  	/***
  	 *
  	 */
  	public ConnectionHeader()
  	{
  		_header = new boolean[] { false, false, false, false, false, false, false, false };
  	}
  
  	/***
  	 * @param channel
  	 */
  	public ConnectionHeader(SelectableChannel channel)
  	{
  		this();
  		this._channel = channel;
  	}
  
  	/***
  	 * @param channel
  	 * @param header
  	 */
  	public ConnectionHeader(SelectableChannel channel, byte header)
  	{
  		this._channel = channel;
  		fromBytes(header);
  	}
  
  	public boolean hasCompression()
  	{
  		return _header[0];
  	}
  
  	public void setCompression(boolean enable)
  	{
  		_header[0] = enable;
  	}
  
  	public void setCompressionLevel(int level)
  	{
  		this._compressionLevel = level;
  	}
  
  	public int getCompressionLevel()
  	{
  		return this._compressionLevel;
  	}
  
  	public boolean hasNonBlockingReadWrite()
  	{
  		return _header[1];
  	}
  
  	public void setNonBlockingReadWrite(boolean enable)
  	{
  		_header[1] = enable;
  	}
  
  	public boolean isConnected()
  	{
  		return _header[2];
  	}
  
 	public void setConnected(boolean enable)
 	{
 		_header[2] = enable;
 	}
 
 	public boolean isPersistent()
 	{
 		return _header[3];
 	}
 
 	public void setPersistent(boolean enable)
 	{
 		_header[3] = enable;
 	}
 
 	public boolean hasWaitingBuffer()
 	{
 		return this._waitingBuffer != null;
 	}
 
 	public ByteBuffer getWaitingBuffer()
 	{
 		return this._waitingBuffer;
 	}
 
 	public void setWaitingBuffer(ByteBuffer buf)
 	{
 		this._waitingBuffer = buf;
 	}
 
 	public void releaseWaitingBuffer()
 	{
 		if (this._waitingBuffer != null)
 		{
 			this._waitingBuffer = null;
 		}
 	}
 
 	public boolean hasAttachment()
 	{
 		return this._attachment != null;
 	}
 
 	public void setAttachment(Object attachment)
 	{
 		this._attachment = attachment;
 	}
 
 	public Object getAttachment()
 	{
 		return this._attachment;
 	}
 
 	public void releaseAttachment()
 	{
 		if (this._attachment != null)
 		{
 			this._attachment = null;
 		}
 	}
 
 	public void setChannel(SelectableChannel channel)
 	{
 		this._channel = channel;
 	}
 
 	public SelectableChannel getChannel()
 	{
 		return this._channel;
 	}
 
 	public void setAdapterName(String name)
 	{
 		if (name == null)
 		{
 			throw new NullPointerException("Name of the adapter class must not be null!");
 		}
 
 		this._adapterClass = name;
 	}
 
 	public String getAdapterName()
 	{
 		return this._adapterClass;
 	}
 
 	public byte toByte()
 	{
 		return bitsToByte(_header);
 	}
 
 	public void fromBytes(byte header)
 	{
 		_header = byteToBits(header);
 	}
 
 	public String toString()
 	{
 		StringBuffer buf = new StringBuffer();
 		for (int i = 0; i < _header.length; i++)
 		{
 			buf.append(_header[i] ? 1 : 0);
 		}
 
 		return buf.toString();
 	}
 
 	public ByteBuffer toByteBuffer()
 	{
 		byte[] adapterArr = null;
 		try
 		{
 			adapterArr = _adapterClass.getBytes("UTF8");
 		}
 		catch (UnsupportedEncodingException e)
 		{
 			//
 		}
 		int length = adapterArr.length;
 		ByteBuffer buf = ByteBuffer.allocateDirect(5 + length);
 		buf.put(toByte());
 		buf.putInt(length);
 		buf.put(adapterArr);
 		buf.flip();
 
 		return buf;
 	}
 
 	private final static byte bitsToByte(boolean[] bits)
 	{
 		int value = 0;
 		for (int i = 0; i < bits.length; i++)
 		{
 			if (bits[i] == true)
 			{
 				value = value | (1 << i);
 			}
 		}
 		return (byte) value;
 	}
 
 	private final static boolean[] byteToBits(byte b)
 	{
 		boolean[] bits = new boolean[8];
 		for (int i = 0; i < bits.length; i++)
 		{
 			bits[i] = ((b & (1 << i)) != 0);
 		}
 		return bits;
 	}
 }