memory.java

这是一个分布式通信程序框架源程序

        return theData;
    }

    /**
     * Extracts a double data item.
     * @see #getBoolean()
     */
    public double getDouble() throws ReadingOutOfBoundException
    {
        if(dataFetchOffset+ 8 > highWaterMark) dataFetchOffset = 0;

        double theData = getDouble(dataAddress+dataFetchOffset);
        dataFetchOffset += 8;
        return theData;
    }

    /**
     * Extracts a String data item.
     * @see #getBoolean()
     * @todo, add a maximum size parameter to the native getString method.
     */
    public String getString() throws ReadingOutOfBoundException
    {
        if(dataFetchOffset >= highWaterMark)
			dataFetchOffset = 0;
        String theData = getString(dataAddress+dataFetchOffset, 0);
        dataFetchOffset += theData.length()+1;
        return theData;
    }

	public String getString(int max_size) throws ReadingOutOfBoundException
    {
        if(dataFetchOffset >= highWaterMark)
			dataFetchOffset = 0;
        String theData = getString(dataAddress+dataFetchOffset, 0);
        dataFetchOffset += max_size;
        return theData;
    }


    /**
     * Extracts a boolean array.
     * The data is extracted starting at the current value of the dataFetchOffset.
     * The dataFetchOffset is updated after the operation.
     * @param length Number of array elements to be extracted.
     * @return The extracted array.
     * @throws ReadingOutOfBoundException This exception is thrown if an attempts made to read an area that has
     * not been written to.
     * @see #setDataFetchOffset
     * @see #getDataFetchOffset
     */
    public boolean[] getBooleanArray(int length) throws ReadingOutOfBoundException
    {
        int size = length*1;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();

        boolean[] array = new boolean[length];
        copyIntoBooleanArray(dataAddress+dataFetchOffset, array, 0, length);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }


	public boolean[] getBooleanArray() throws ReadingOutOfBoundException
	{
		int size = getDataSize();
		size -= dataFetchOffset;
		if(size<0) throw new ReadingOutOfBoundException();
		if(dataFetchOffset+size > highWaterMark) highWaterMark = 0;

		boolean[] array = new boolean[size];
		copyIntoBooleanArray(dataAddress+dataFetchOffset, array, 0, size);
		dataFetchOffset = dataFetchOffset + size;
		return array;
	}
     /**
     * Extracts a char array.
     * @see #getBooleanArray(int)
     */
    public char[] getCharArray(int length) throws ReadingOutOfBoundException
    {
        int size = length*2;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();

        char[] array = new char[length];
        copyIntoCharArray(dataAddress+dataFetchOffset, array, 0, length);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

    /**
     * Extracts a byte array.
     * @see #getBooleanArray(int)
     */
    public byte[] getByteArray(int length) throws ReadingOutOfBoundException
    {
        int size = length*1;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();

        byte[] array = new byte[length];
        copyIntoByteArray(dataAddress+dataFetchOffset, array, 0, length);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

	public byte[] getByteArray() throws ReadingOutOfBoundException
	{
		int size = getDataSize();
		size -= dataFetchOffset;
		if(size<0) throw new ReadingOutOfBoundException();
		if(dataFetchOffset+size > highWaterMark) highWaterMark = 0;

		byte[] array = new byte[size];
		copyIntoByteArray(dataAddress+dataFetchOffset, array, 0, size);
		dataFetchOffset = dataFetchOffset + size;
		return array;
	}
 
     /**
     * Extracts a short array.
     * @see #getBooleanArray(int)
     */
    public short[] getShortArray(int length) throws ReadingOutOfBoundException
    {
        int size = length*2;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();

        short[] array = new short[length];
        copyIntoShortArray(dataAddress+dataFetchOffset, array, 0, length);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

	public short[] getShortArray() throws ReadingOutOfBoundException
	{
		int size = getDataSize();
		size -= dataFetchOffset;
		if(size<0) throw new ReadingOutOfBoundException();
		if(dataFetchOffset+size > highWaterMark) highWaterMark = 0;

		short[] array = new short[size/2];
		copyIntoShortArray(dataAddress+dataFetchOffset, array, 0, size/2);
		dataFetchOffset = dataFetchOffset + size;
		return array;
	}
 
    /**
     * Extracts a int array.
     * @see #getBooleanArray(int)
     */
    public int[] getIntArray(int length) throws ReadingOutOfBoundException
    {
        int size = length*4;
        if(size<0) throw new ReadingOutOfBoundException();
		if(dataFetchOffset+size > highWaterMark) highWaterMark = 0;

        int[] array = new int[length];
        copyIntoIntArray(dataAddress+dataFetchOffset, array, 0, length);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

    public int[] getIntArray() throws ReadingOutOfBoundException
    {
		int size = getDataSize();
		size -= dataFetchOffset;
		if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();

        int[] array = new int[size/4];
        copyIntoIntArray(dataAddress+dataFetchOffset, array, 0, size/4);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }
    /**
     * Extracts a long array.
     * @see #getBooleanArray(int)
     */
    public long[] getLongArray(int length) throws ReadingOutOfBoundException
    {
        int size = length*8;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();

        long[] array = new long[length];
        copyIntoLongArray(dataAddress+dataFetchOffset, array, 0, length);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

	public long[] getLongArray() throws ReadingOutOfBoundException
	{
		int size = getDataSize();
		size -= dataFetchOffset;
		if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
		
		long[] array = new  long[size/8];
		copyIntoLongArray (dataAddress+dataFetchOffset, array, 0, size/8);
		dataFetchOffset = dataFetchOffset + size;
		return array;
	}

    /**
     * Extracts a float array.
     * @see #getBooleanArray(int)
     */
    public float[] getFloatArray(int length) throws ReadingOutOfBoundException
    {
        int size = length*4;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();

        float[] array = new   float[length];
        copyIntoFloatArray  (dataAddress+dataFetchOffset, array, 0, length);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

    public float[] getFloatArray() throws ReadingOutOfBoundException
    {
        int size = getDataSize();
		size -= dataFetchOffset;
        if(size<0) throw new ReadingOutOfBoundException();
		if(dataFetchOffset+size > highWaterMark) highWaterMark = 0;

		float[] array = new float[size/4];
        copyIntoFloatArray(dataAddress+dataFetchOffset, array, 0, size/4);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

	/**
     * Extracts a double array.
     * @see #getBooleanArray(int)
     */
    public double[] getDoubleArray(int length) throws ReadingOutOfBoundException
    {
        int size = length*8;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();

        double[] array = new  double[length];
        copyIntoDoubleArray (dataAddress+dataFetchOffset, array, 0, length);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

    public double[] getDoubleArray() throws ReadingOutOfBoundException
    {
        int size = getDataSize();
		size -= dataFetchOffset;
		if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
		
        double[] array = new  double[size/8];
        copyIntoDoubleArray (dataAddress+dataFetchOffset, array, 0, size/8);
        dataFetchOffset = dataFetchOffset + size;
        return array;
    }

public String[] getStringArray() throws ReadingOutOfBoundException
{
	String str;
	String array[];
	int len = 0, i, offset;
	int size = getDataSize();
	size -= dataFetchOffset;
	if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
	
	offset = dataFetchOffset;
	while(size > 0)
	{	
		str = getString(dataAddress+dataFetchOffset, 0);
		dataFetchOffset += str.length()+1;
		size -= str.length()+1;
		len++; 	
	}
	array = new String[len];
	dataFetchOffset = offset;
	for(i = 0; i < len; i++)
	{
		array[i] = getString(dataAddress+dataFetchOffset, 0);
		dataFetchOffset += array[i].length()+1;
	}
	return array;
}

public String[] getStringArray(int num) throws ReadingOutOfBoundException
{
	String array[];
	int i;
	int size = getDataSize();
	size -= dataFetchOffset;
	if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
	
	array = new String[num];
	for(i = 0; i < num; i++)
	{
		array[i] = getString(dataAddress+dataFetchOffset, 0);
		dataFetchOffset += array[i].length()+1;
		if(dataFetchOffset > highWaterMark) throw new ReadingOutOfBoundException();
	}
	return array;
}

    /**
     * Extracts data into an existing boolean array.
     * The data is extracted starting at the current value of the dataFetchOffset.
     * The dataFetchOffset is updated after the operation.
     * @param array Target array of the extracted data.
     * @param arrayOffset The offset into the target array.
     * @param length Number of array elements to be extracted.
     * @throws ReadingOutOfBoundException This exception is thrown if an attempts made to read an area that has
     * not been written to.
     * @see #setDataFetchOffset
     * @see #getDataFetchOffset
     */
    public void copyIntoBooleanArray(boolean[] array, int arrayOffset, int length) throws ReadingOutOfBoundException
    {
        int size = length*1;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
        copyIntoBooleanArray(dataAddress+dataFetchOffset, array, arrayOffset, length);
        dataFetchOffset = dataFetchOffset + size;
        return;
    }

    /**
     * Extracts data into an existing char array.
     * @see #copyIntoBooleanArray(boolean[], int, int)
     */
    public void copyIntoCharArray(char[] array, int arrayOffset, int length) throws ReadingOutOfBoundException
    {
        int size = length*2;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
        copyIntoCharArray   (dataAddress+dataFetchOffset, array, arrayOffset, length);
        dataFetchOffset = dataFetchOffset + size;
        return;
    }

    /**
     * Extracts data into an existing byte array.
     * @see #copyIntoBooleanArray(boolean[], int, int)
     */
    public void copyIntoByteArray(byte[] array, int arrayOffset, int length) throws ReadingOutOfBoundException
    {
        int size = length*1;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
        copyIntoByteArray   (dataAddress+dataFetchOffset, array, arrayOffset, length);
        dataFetchOffset = dataFetchOffset + size;
        return;
    }

    /**
     * Extracts data into an existing short array.
     * @see #copyIntoBooleanArray(boolean[], int, int)
     */
    public void copyIntoShortArray(short[] array, int arrayOffset, int length) throws ReadingOutOfBoundException
    {
        int size = length*2;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
        copyIntoShortArray  (dataAddress+dataFetchOffset, array, arrayOffset, length);
        dataFetchOffset = dataFetchOffset + size;
        return;
    }

    /**
     * Extracts data into an existing int array.
     * @see #copyIntoBooleanArray(boolean[], int, int)
     */
    public void copyIntoIntArray(int[] array, int arrayOffset, int length) throws ReadingOutOfBoundException
    {
        int size = length*4;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
        copyIntoIntArray(dataAddress+dataFetchOffset, array, arrayOffset, length);
        dataFetchOffset = dataFetchOffset + size;
        return;
    }

    /**
     * Extracts data into an existing long array.
     * @see #copyIntoBooleanArray(boolean[], int, int)
     */
    public void copyIntoLongArray(long[] array, int arrayOffset, int length) throws ReadingOutOfBoundException
    {
        int size = length*8;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
        copyIntoLongArray(dataAddress+dataFetchOffset, array, arrayOffset, length);
        dataFetchOffset = dataFetchOffset + size;
        return;
    }

    /**
     * Extracts data into an existing float array.
     * @see #copyIntoBooleanArray(boolean[], int, int)
     */
    public void copyIntoFloatArray(float[] array, int arrayOffset, int length) throws ReadingOutOfBoundException
    {
        int size = length*4;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
        copyIntoFloatArray(dataAddress+dataFetchOffset, array, arrayOffset, length);
        dataFetchOffset = dataFetchOffset + size;
        return;
    }
    /**
     * Extracts data into an existing double array.
     * @see #copyIntoBooleanArray(boolean[], int, int)
     */
    public void copyIntoDoubleArray(double[] array, int arrayOffset, int length) throws ReadingOutOfBoundException
    {
        int size = length*8;
        if(size<0 || dataFetchOffset+size > highWaterMark) throw new ReadingOutOfBoundException();
        copyIntoDoubleArray(dataAddress+dataFetchOffset, array, arrayOffset, length);
        dataFetchOffset = dataFetchOffset + size;
        return;
    }
    
	public int getSize()
	{
		int size = getDataSize();
		size -= dataFetchOffset;
		return size;
	}
}