mailbuff.java

JAVA邮件系统

public class MailBuff
{
	static public int INCREASE_SIZE = 10240;
	static byte GetNoCaseChar(byte code){
		if(code>=(byte)'a'&&code<=(byte)'z'){
			return (byte)(code - 'a'+'A');
		}
		if(code>=(byte)'A'&&code<=(byte)'Z'){
			return (byte)(code + 'a'-'A');
		}
		return code;
	}
	
	byte[] m_sBuff;
	int    m_sLength;   //alloced size;
	int    m_sSize;     //current size;
	int    m_nIncrease; //when need realloc
	int    m_nOffset;
	
	//function
	public MailBuff(){
		m_nIncrease = INCREASE_SIZE;
	};
	public MailBuff(int nAlloc,int nIncrease){
		m_sBuff = new byte[nAlloc];
		m_nIncrease=nIncrease;
		m_sLength = nAlloc;
		m_sSize = 0;
		m_nOffset =0;
	};
	
	//size can't be increase if m_nIncrease==0;
	public MailBuff(byte[] sData){
		m_sBuff = sData;
		m_sLength = sData.length ;
		m_sSize = m_sLength;
	};
	public MailBuff(byte[] sData,int nSize){
		m_sBuff = sData;
		m_sLength = sData.length ;
		m_sSize = nSize;
	};
	public MailBuff(MailBuff MailBuf){
		m_sBuff = MailBuf.getData();
		m_sLength = m_sBuff.length ;
		m_sSize = MailBuf.getSize();
		m_nOffset = MailBuf.getOffset ();
	};
	public MailBuff(MailBuff MailBuf,int nSize){
		m_sBuff = MailBuf.getData();
		m_sLength = m_sBuff.length ;
		m_sSize = nSize;
		m_nOffset = MailBuf.getOffset ();
	};
	public MailBuff(MailBuff MailBuf,int nOffset,int nSize){
		m_sBuff = MailBuf.getData();
		m_sLength = m_sBuff.length ;
		m_sSize = nSize;
		m_nOffset = nOffset;
	};
	public static MailBuff MakeMirror(byte[] sData){
		return new MailBuff(sData);
	}
	public static MailBuff MakeMirror(byte[] sData,int nSize){
		return new MailBuff(sData,nSize);
	}
	public MailBuff MakeMirror(int nSize){
		return new MailBuff(m_sBuff,nSize);
	}
	public MailBuff MakeMirror(int nOffset,int nSize){
		return new MailBuff(this ,nOffset,nSize);
	}
	
	//retrive data;
	public byte[] getData(){
		return m_sBuff;
	}
	public void setData(byte[] sdata){
		m_sBuff=sdata;
		m_sLength = sdata.length ;
		m_sSize = m_sLength;
	}
	public int getLength(){
		return m_sLength;
	}
	public boolean ResetLength(int nLength){
		byte[] sTemp;
		try{
			sTemp = new byte[nLength];
			int nCopy=nLength;
			if(nLength>m_sBuff.length )
				nCopy=m_sBuff.length;
			if( CopyBuffer(sTemp,m_sBuff,nCopy,0,0)==false )
				return false;
			
		}catch(Exception e){
			return false;
		}
		m_sBuff=sTemp;
		m_sLength = nLength;
		if(m_sSize>m_sLength)
			m_sSize = m_sLength;
		return true;
	}
	public int getSize(){
		return m_sSize;
	}
	public void setSize(int nSize){
		m_sSize =nSize;
		if(m_sSize>m_sLength)
			m_sSize=m_sLength ;
	}
	public int getOffset(){
		return m_nOffset;
	}
	public void setOffset(int nOff){
		m_nOffset =nOff;
		if(m_nOffset>m_sLength)
			m_nOffset=m_sLength ;
		m_sSize=m_sLength-m_nOffset;
	}
	public void Offset(int nOff){
		m_nOffset+= nOff;
		setSize(m_sSize-nOff);
	}

	public void SetIncrease(int nIncrease){
		m_nIncrease = nIncrease;
		if(m_nIncrease<0)
		   m_nIncrease=0;
	}
	
	//append
	public boolean append(int n){
		return append(Integer.toString (n));
	}
	public boolean append(String src,int nOffset,int nLength ){
		if( src == null )
			return false;
		if(nOffset+nLength>src.length ())
			return false;
		return append(src.substring(nOffset,nOffset+nLength).getBytes ());
	}
	public boolean append(String src){
		if( src == null )
			return false;
		return append(src.getBytes ());
	}
	public boolean append(byte[] sAdd){
		if( sAdd == null )
			return false;
		return append (sAdd,0,sAdd.length );
	}
	public boolean append(byte[] sAdd,int nOffset,int length){
		if( sAdd == null )
			return false;
		if(sAdd == null )
			return false;
		if(nOffset+length>sAdd.length )
			return false;
		if(m_sLength-m_sSize < length &&m_nIncrease<=0 )
			return false;

		int nAlloc = m_sLength+m_nIncrease;
		if(m_sLength-m_sSize < length ){
			if(nAlloc -m_sSize<length)
				nAlloc = m_sSize+length+m_nIncrease;
			if(ResetLength(nAlloc)==false)
				return false;
		}
		if(CopyBuffer(m_sBuff,sAdd,length ,m_sSize,nOffset)==false)
			return false;
		m_sSize+=length ;
		return true;
	}
	
	//copy func.
	public static boolean CopyBuffer(byte[] Des, byte[]Src ,int nLength,int nOffsetDes,
									 int nOffsetSrc){
		if( Src==null||Des==null||nLength<0 )
			return false;
		if(Src.length < nOffsetSrc+nLength ||Des.length < nOffsetDes+nLength)
			return false;
		for(int i =0;i<nLength;i++)
			Des[i+nOffsetDes]=Src[i+nOffsetSrc];
		return true;
	}
	public boolean CopyBuffer(byte[] Des, int nLength,int nOffsetDes,
									 int nOffsetSrc){
		
		return CopyBuffer( Des, m_sBuff , nLength, nOffsetDes,
									  nOffsetSrc);
	}
	
	//find func
	static public int FindStrNocase(byte[] Src,String Des,int nSize,int nOffset){
		if( Src==null || Des == null )
			return -1;
		if( nOffset+nSize>Src.length )
			nSize = Src.length -nOffset;
		byte[] bDes = Des.getBytes();
		for(int i=nOffset;i<nOffset+nSize;i++ ){
			if( Src[i]==bDes[0]||Src[i]==GetNoCaseChar(bDes[0]) ){
				boolean same = true;
				for( int j=0;j<bDes.length ;j++ ){
					if(i+j>=Src.length)
						return -1;
					if( Src[i+j] != bDes[j]&&
						Src[i+j] != GetNoCaseChar(bDes[j]) ){
						same = false;
						break;
					}
				}
				if( same)
					return i; 
			}
		}
		return -1;
	}
	static public int FindStr(byte[] Src,String Des,int nSize,int nOffset){
		if( Src==null || Des == null )
			return -1;
		if( nOffset+nSize>Src.length )
			nSize = Src.length -nOffset;
		byte[] bDes = Des.getBytes();
		for(int i=nOffset;i<nSize+nOffset;i++ ){
			if( Src[i]==bDes[0] ){
				boolean same = true;
				for( int j=0;j<bDes.length ;j++ ){
					if(i+j>=Src.length)
						return -1;
					if( Src[i+j] != bDes[j] ){
						same = false;
						break;
					}
				}
				if( same)
					return i; 
			}
		}
		return -1;
	}
	static public int FindNumberInStr(byte[] sSrc ,int nSize, int nOffset){
		return FindAnyCharInStr(sSrc,"0123456789",nSize,nOffset );
	}
	static public int FindNotNumberInStr(byte[] sSrc ,int nSize,int nOffset){
		return FindNotAnyCharInStr(sSrc,"0123456789",nSize, nOffset );
	}
	static public int FindAnyCharInStr(byte[] sSrc , String  sDes ,int nSize, int nOffset){
		if( sSrc==null || sDes == null )
			return -1;
		if( nOffset+nSize>sSrc.length )
			nSize = sSrc.length -nOffset;
		char SrcCode;
		for(int i=nOffset;i<nOffset+nSize ;i++ ){
			SrcCode =(char) sSrc[i];
			for( int j=0;j<sDes.length ();j++ )
				if( SrcCode==sDes.charAt (j) )
					return i;
		}
		return -1;
	}
	static public int FindNotAnyCharInStr(byte[] sSrc , String  sDes ,int nSize, int nOffset){
		if( sSrc==null || sDes == null )
			return -1;
		if( nOffset+nSize>sSrc.length )
			nSize = sSrc.length -nOffset;
		char SrcCode;
		boolean Same=false;
		for(int i=nOffset;i<nSize+nOffset ;i++ ){
			Same=false;
			SrcCode =(char) sSrc[i];
			for( int j=0;j<sDes.length ();j++ )
				if( SrcCode==sDes.charAt (j) )
					Same=true;
			if(Same==false)
				return i;
				
		}
		return -1;
	}
	
	//
	static int GetFirstNumber(byte[] sSrc,int nSize,int nOffset ){
		if( sSrc==null )
			return -1;
		if( nOffset+nSize>sSrc.length )
			nSize = sSrc.length -nOffset;
		int nBegin,nEnd;
		nBegin = FindNumberInStr(sSrc,nSize,nOffset);
		if( nBegin ==-1 )
			return -1;
		nOffset = nBegin;
		nEnd = FindNotNumberInStr(sSrc,nSize,nOffset);
		if( nEnd ==-1 )
			nEnd = sSrc.length ;
		String sTemp = new String( sSrc , nBegin , nEnd-nBegin );
		Integer integ =new Integer(sTemp);
		return integ.intValue ();
	}
	static int GetSecondNumber(byte[] sSrc,int nSize,int nOffset ){
		if( sSrc==null )
			return -1;
		if( nOffset+nSize>sSrc.length )
			nSize = sSrc.length -nOffset;
		int nBegin,nEnd;
		nBegin = FindNumberInStr(sSrc,nSize,nOffset);
		if( nBegin ==-1 )
			return -1;
		nOffset = nBegin;
		nEnd = FindNotNumberInStr(sSrc,nSize,nOffset);
		nOffset = nEnd;
		if( nEnd ==-1 )
			return -1 ;
		nBegin = FindNumberInStr(sSrc,nSize,nOffset);
		if( nBegin ==-1 )
			return -1;
		nOffset = nBegin;
		nEnd = FindNotNumberInStr(sSrc,nSize,nOffset);
		if( nEnd ==-1 )
			nEnd = sSrc.length ;
		String sTemp = new String( sSrc , nBegin , nEnd-nBegin );
		Integer integ =new Integer(sTemp);
		return integ.intValue ();
	}

	/*****************************/
 	//no static;
	public int FindStrNocase(String Des,int nOffset){
		return FindStrNocase(getData(),Des,getSize(),nOffset+m_nOffset);
	}
	public int FindStr(String Des,int nOffset){
		return FindStr(getData(),Des,getSize(),nOffset+m_nOffset);
	}
	public int FindAnyCharInStr( String  sDes , int nOffset){
		return FindAnyCharInStr(getData(),sDes,getSize(),nOffset+m_nOffset);
	}
	public int FindNotAnyCharInStr( String  sDes , int nOffset){
		return FindNotAnyCharInStr( getData(), sDes ,getSize(), nOffset+m_nOffset);
	}

	public int FindNumberInStr( int nOffset){
		return FindNumberInStr(getData(),getSize(),nOffset+m_nOffset );
	}
	public int FindNotNumberInStr(int nOffset){
		return FindNotNumberInStr(getData(),getSize(),nOffset +m_nOffset);
	}
	
	//
	public boolean BeginWithKeyword(String str){
		int nKey = FindStrNocase(str,0);
		if( nKey < 0 )
			return false;
		return nKey<=FindKeyWord(0);
	}
	
	public int GetFirstNumber(int nOffset ){
		return GetFirstNumber( getData(),getSize(),nOffset+m_nOffset);
	}
	public int GetSecondNumber(int nOffset ){
		return GetSecondNumber (getData(),getSize(),nOffset+m_nOffset);
	}
	public int FindLineEnd(int nOffset){
		return FindStr("\r\n",nOffset);
	}
	public int FindNextLineBegin(int nOffset){
		return FindNotAnyCharInStr("\r\n",nOffset);
	}
	public int FindKeyWord(int nOffset){
		return FindNotAnyCharInStr("\t\r\n :=;",nOffset);
	}
	public int FindKeyWordSplit(int nOffset){
		return FindAnyCharInStr("\t\r\n :=;",nOffset);
	}
	public int FindBoundarySplit(int nOffset){
		return FindAnyCharInStr("\t\r\n ",nOffset);
	}
	
}