jumpoutgoingmessage.java

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

/*
 * %W% %E%
 *
 * Copyright  1990-2006 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation. 
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt). 
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA 
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions. 
 */

package com.sun.jump.message;

import java.io.IOException;
import com.sun.jump.os.JUMPOSInterface;

/**
 * <code>JUMPOutgoingMessage</code> encapsulates a message that is filled in
 * with data.
 */
public abstract class JUMPOutgoingMessage extends JUMPMessage {
    private static final int MESSAGE_DATA_INITIAL_SIZE = 512;
    protected JUMPMessagable sender;
    /* offset just past header in message, for sanity checking by native
       side */
    protected int headerOffset;

    /**
     * Creates a new instance of JUMPOutgoingMessage 
     */
    protected JUMPOutgoingMessage(JUMPMessagable sender, 
				  String type,
				  String returnType,
				  int responseId) {
        this.sender = sender;
        this.type = type;
	this.returnType = returnType;
        this.responseId = responseId;
	this.messageDataBytes = new byte[MESSAGE_DATA_INITIAL_SIZE];
	this.messageDataOffset = MESSAGE_DATA_OFFSET;
	composeHeader();
	messageMarkOffset = messageDataOffset;
    }
    
    // used for deserializing the message
    protected JUMPOutgoingMessage() {
	super();
    }
    
    private void composeHeader() {
	/* Here we leave room for the header. The native layer will
	   fill some of this in */
	addInt(0);   // Room for message id
	addInt(this.responseId);    
	addInt(serializeMessagable(sender));   // Sender id
	addUTF(this.returnType); // Add return type 
	addUTF(this.type); // And add type
	//
	// Remember this offset so the native side can sanity check
	//
	this.headerOffset = messageDataOffset;
	
	// User data follows
    }

    //
    // Make sure we can accommodate n more bytes.
    //
    private void ensureCapacity(int n) {
	// NOTE: This assumes that requiredCapacity and newCapacity
	// will not overflow an int, which should be reasonable.
	int requiredCapacity = messageDataOffset + n;
	if (requiredCapacity > messageDataBytes.length) {
	    int newCapacity = messageDataBytes.length * 2;
	    if (newCapacity < requiredCapacity) {
		newCapacity = requiredCapacity;
	    }

	    byte[] newData = new byte[newCapacity];
	    System.arraycopy(messageDataBytes, 0,
			     newData, 0, messageDataOffset);
	    messageDataBytes = newData;
	}
    }

    /**
     * Add integer to message data
     */
    public void addInt(int i) {
	ensureCapacity(4);
	// Add int at messageDataOffset, big endian
	messageDataBytes[messageDataOffset+0] = (byte)(i >>> 24);
	messageDataBytes[messageDataOffset+1] = (byte)(i >>> 16);
	messageDataBytes[messageDataOffset+2] = (byte)(i >>>  8);
	messageDataBytes[messageDataOffset+3] = (byte)(i >>>  0);
	messageDataOffset += 4;
    }

    public void addLong(long l) {
	ensureCapacity(8);
	// Add int at messageDataOffset, big endian
	messageDataBytes[messageDataOffset+0] = (byte)(l >>> 56);
	messageDataBytes[messageDataOffset+1] = (byte)(l >>> 48);
	messageDataBytes[messageDataOffset+2] = (byte)(l >>> 40);
	messageDataBytes[messageDataOffset+3] = (byte)(l >>> 32);
	messageDataBytes[messageDataOffset+4] = (byte)(l >>> 24);
	messageDataBytes[messageDataOffset+5] = (byte)(l >>> 16);
	messageDataBytes[messageDataOffset+6] = (byte)(l >>> 8);
	messageDataBytes[messageDataOffset+7] = (byte)(l >>> 0);
	messageDataOffset += 8;
    }

    public void addByte(byte b) {
	ensureCapacity(1);
	// Add byte at messageDataOffset
	messageDataBytes[messageDataOffset] = b;
	messageDataOffset += 1;
    }

    private byte[] getBytes(String s) {
	char[] val = s.toCharArray();
	byte[] dst = new byte[val.length + 1]; // Leave room for null termination
	for (int i = 0; i < val.length; i++) {
            dst[i] = (byte)val[i];
        }
	return dst;
    }

    public void addUTF(String s) {
	//
	// FIXME
	// Add string in Java-modified utf-8
	// This code assumes ASCII (and so does the native layer)
	// Example implementation in DataOutputStream.writeUTF().
	//
	if (s == null) {
	    addByteArray(null);
	} else {
	    addByteArray(getBytes(s));
	}
    }

    public void addByteArray(byte[] barr) {
	if (barr == null) {
	    addInt(-1);
	    return;
	}
	addInt(barr.length);
	ensureCapacity(barr.length); // the bytes+length
	System.arraycopy(barr, 0, messageDataBytes, messageDataOffset,
			 barr.length);
	messageDataOffset += barr.length;
    }

    public void addUTFArray(String[] arr) {
	if (arr == null) {
	    addInt(-1);
	    return;
	}
	addInt(arr.length);
	for (int i = 0; i < arr.length; i++) {
	    addUTF(arr[i]);
	}
    }

    public byte[] serialize() {
	return messageDataBytes;
    }

    protected abstract int serializeMessagable(JUMPMessagable messagable);

    // This should not be happening for an outgoing message constructed
    // with a sender
    protected void readMessageSender(int id) {
    }
	
}