welcome.java

High performance DB query

/*
 * @(#)$Id: Welcome.java,v 1.8 2004/07/02 23:59:20 huebsch Exp $
 *
 * Copyright (c) 2001-2004 Regents of the University of California.
 * All rights reserved.
 *
 * This file is distributed under the terms in the attached BERKELEY-LICENSE
 * file. If you do not find these files, copies can be found by writing to:
 * Computer Science Division, Database Group, Universite of California,
 * 617 Soda Hall #1776, Berkeley, CA 94720-1776. Attention: Berkeley License
 *
 * Copyright (c) 2003-2004 Intel Corporation. All rights reserved.
 *
 * This file is distributed under the terms in the attached INTEL-LICENSE file.
 * If you do not find these files, copies can be found by writing to:
 * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300,
 * Berkeley, CA, 94704.  Attention:  Intel License Inquiry.
 */


package overlay.location.can.payload;

import java.net.InetSocketAddress;
import overlay.location.can.Can;
import overlay.location.can.Neighbor;
import overlay.location.can.Neighborhood;
import overlay.location.can.Zone;
import services.network.Payload;
import util.FreeList;
import util.FreeListFactory;
import util.network.serialization.GenericByteBuffer;
import util.network.serialization.SerializationManager;
import util.network.serialization.SerializeArray;

/**
 * The class encapsulates a welcome message.  The welcome message notifies an
 * aspiring newcomer that it can, if it wants, take on a specific zone, along
 * with a list of neighbors from the current caretaker of that zone.
 */
public class Welcome extends CANMessage {

    public static long serialVersionUID =
        SerializationManager.getSerialUID(
            "overlay.location.can.payload.Welcome");
    private Zone zone;
    private int nextSplit;
    private Neighbor[][][] neighbors;
    private int size;
    private static FreeList freeList = new FreeList(new WelcomeFactory());

    /**
     * DeSerialize the object from the provided GenericByteBuffer.
     *
     * @param inputBuffer
     */
    public Welcome(GenericByteBuffer inputBuffer) {
        super(inputBuffer);

        this.zone = new Zone(inputBuffer);
        this.nextSplit = inputBuffer.getInt();
        neighbors = new Neighbor[Can.DIM][2][];

        for (int i = 0; i < Can.DIM; i++) {
            for (int j = 0; j < 2; j++) {
                Payload[] arr =
                    SerializeArray.deSerializeHomogenousPayload(inputBuffer);
                int arrSize = arr.length;

                neighbors[i][j] = new Neighbor[arrSize];

                for (int k = 0; k < arrSize; k++) {
                    neighbors[i][j][k] = (Neighbor) arr[k];
                }
            }
        }

        this.size = computeSize();
    }

    /**
     * Serialize the object into the provided GenericByteBuffer.
     *
     * @param outputBuffer
     * @return
     */
    public long serialize(GenericByteBuffer outputBuffer) {
        super.serialize(outputBuffer);
        zone.serialize(outputBuffer);
        outputBuffer.putInt(nextSplit);

        for (int i = 0; i < Can.DIM; i++) {
            for (int j = 0; j < 2; j++) {
                SerializeArray.serializeHomogenousPayload(outputBuffer,
                                                          neighbors[i][j]);
            }
        }

        return serialVersionUID;
    }

    /**
     * Constructor Welcome
     */
    protected Welcome() {
        neighbors = new Neighbor[Can.DIM][2][];
    }

    private void init(int messageID, InetSocketAddress owner, Zone zone,
                      int nextSplit, Neighborhood neighborhood) {
        super.init(messageID, owner);

        this.zone = zone;
        this.nextSplit = nextSplit;

        neighborhood.fillup(this.neighbors);

        this.size = computeSize();
    }

    private int computeSize() {
        int size = super.getSize() + SerializationManager.getPayloadSize(zone)
                   + Payload.INT_SIZE;

        for (int i = 0; i < Can.DIM; i++) {
            for (int j = 0; j < 2; j++) {
                if (neighbors[i][j] != null) {
                    for (int k = 0; k < neighbors[i][j].length; k++) {
                        size += SerializationManager.getPayloadSize(
                            neighbors[i][j][k]);
                    }
                }
            }
        }

        return size;
    }

    /**
     * Method getSize
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * Method getZone
     * @return
     */
    public Zone getZone() {
        return zone;
    }

    /**
     * Method getNeighborhood
     * @return
     */
    public Neighbor[][][] getNeighborhood() {
        return neighbors;
    }

    /**
     * Method getNextSplit
     * @return
     */
    public int getNextSplit() {
        return nextSplit;
    }

    /**
     * Allocate a new Welcome, given its sender, the proposed zone and proposed
     * neighborhood.  The neighborhood is not copied locally.
     *
     * @param messageID
     * @param source
     * @param zone
     * @param nextSplit
     * @param neighborhood
     * @return
     */
    public static Welcome allocate(int messageID, InetSocketAddress source,
                                   Zone zone, int nextSplit,
                                   Neighborhood neighborhood) {
        Welcome message = (Welcome) freeList.allocate();

        message.init(messageID, source, zone, nextSplit, neighborhood);

        return message;
    }

    /**
     * Method free
     *
     * @param message
     */
    public static void free(Welcome message) {
        freeList.free(message);
    }
}


/**
 * Class WelcomeFactory
 *
 */
class WelcomeFactory implements FreeListFactory {

    /**
     * Method create
     * @return
     */
    public Object create() {
        return new Welcome();
    }
}