leave.java

High performance DB query

/*
 * @(#)$Id: Leave.java,v 1.9 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;

/**
 * Class Leave
 *
 */
public class Leave extends CANMessage {

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

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

        this.zone = new Zone(inputBuffer);
        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];
                }
            }
        }
    }

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

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

        return serialVersionUID;
    }

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

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

        this.zone = zone;

        neighborhood.fillup(this.neighbors);

        // figure out the size of the neighbor table
        int count = 0;

        for (int i = 0; i < Can.DIM; i++) {
            count += this.neighbors[i][0].length + this.neighbors[i][1].length;
        }

        // compute the size of the message once and store
        this.size =
            super.getSize()
            + (count * SerializationManager.getPayloadSize(this.neighbors[0][0][0]))
            + SerializationManager.getPayloadSize(zone);
    }

    /**
     * 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 allocate
     *
     * @param messageID
     * @param source
     * @param zone
     * @param neighborhood
     * @return
     */
    public static Leave allocate(int messageID, InetSocketAddress source,
                                 Zone zone, Neighborhood neighborhood) {
        Leave message = (Leave) freeList.allocate();

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

        return message;
    }

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


/**
 * Class LeaveFactory
 *
 */
class LeaveFactory implements FreeListFactory {

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