spmd/split/SinglePartitionInfo.java

package appl.parallel.spmd.split;

import java.io.Serializable;

import appl.data.DataLoader;
import appl.parallel.data.PartitionDataHandler;

// fuer Doku
import javax.activation.DataHandler;
import appl.parallel.client.DataServer;
import appl.parallel.data.XuluClientLoader;

/**
 * This class collects the metadata of a partitioning
 * The following information is encapsulated in a SinglePartitionInfo Object:
 * <ul>
 * <li>
 * The <b>ID</b>of the {@link SplittableResource SplittableResource}
 * </li>
 * <li>The <b>baseResourceName</b> of the resource (given by the parallel programmer)</li>
 * <li>The <b>{@link DataHandler}</b>, which loads the data of the partition. This is a very important aspect.
 * The handler defines how the data is actually loaded. It may for example be loaded
 * from a {@link DataServer} using a {@link XuluClientLoader}, but it may also be used
 * to load data from local disk, databases etc. without communication with the client.
 * The {@link DataHandler} is also responsible for writing the the data back to the source
 * </li>
 * <li>
 * The <b>{@link SplitMap}</b> which represents the current partitioning.
 * </li>
 * <li>
 * A <b>splitmap position</b>, which identifies the partition number in the split.
 * </li>
 *
 * @author Dominik Appl
 *
 *
 */
public class SinglePartitionInfo implements Serializable, PartitionInfo{

        private final int baseResourceID;
    private final PartitionDataHandler handler;
    private final SplitMap splitMap;
    private final int splitMapPos;
    private final String baseResourceName;

    /**
     * The constructor.
     *
     * @param baseResourceID the root id (see {@link DataPartition#getRootID()})
     * @param baseResourceName the name of the resource (given by parallel programmer)
     * @param handler {@link PartitionDataHandler}
     *                  which is responsible for loading and unloading
     * @param splitMap splitmap describing the partitioning
     * @param splitMapPos the position inside the splitmap
     */
    public SinglePartitionInfo(int baseResourceID, String baseResourceName, PartitionDataHandler handler, SplitMap splitMap, int splitMapPos){
        this.baseResourceID = baseResourceID;
        this.baseResourceName = baseResourceName;
        this.handler = handler;
        this.splitMap = splitMap;
        this.splitMapPos = splitMapPos;
    }

    /**
         * @return the baseResourceID
         */
        public int getBaseResourceID() {
                return baseResourceID;
        }
    /**
         * @return the handler
         */
        public PartitionDataHandler getPartitionDataHandler() {
                return handler;
        }
    /* (non-Javadoc)
         * @see appl.parallel.spmd.split.PartitionInfo#getSplitMap()
         */
        public SplitMap getSplitMap() {
                return splitMap;
        }
    /* (non-Javadoc)
         * @see appl.parallel.spmd.split.PartitionInfo#getSplitMapPos()
         */
        public int getSplitMapPos() {
                return splitMapPos;
        }

    /* (non-Javadoc)
         * @see appl.parallel.spmd.split.PartitionInfo#getBaseResourceName()
         */
        public String getBaseResourceName() {
                return baseResourceName;
        }

        public PartitionInfo clone(int newRootID){
                PartitionDataHandler clonedHandler = handler.clone();
                clonedHandler.setRootID(newRootID);
                return new SinglePartitionInfo(newRootID,
                                this.baseResourceName,clonedHandler,this.splitMap,
                                this.splitMapPos);
        }

}
1	package appl.parallel.spmd.split;
2
3	import java.io.Serializable;
4
5	import appl.data.DataLoader;
6	import appl.parallel.data.PartitionDataHandler;
7
8	// fuer Doku
9	import javax.activation.DataHandler;
10	import appl.parallel.client.DataServer;
11	import appl.parallel.data.XuluClientLoader;
12
13	/**
14	* This class collects the metadata of a partitioning
15	* The following information is encapsulated in a SinglePartitionInfo Object:
16	* <ul>
17	* <li>
18	* The <b>ID</b>of the {@link SplittableResource SplittableResource}
19	* </li>
20	* <li>The <b>baseResourceName</b> of the resource (given by the parallel programmer)</li>
21	* <li>The <b>{@link DataHandler}</b>, which loads the data of the partition. This is a very important aspect.
22	* The handler defines how the data is actually loaded. It may for example be loaded
23	* from a {@link DataServer} using a {@link XuluClientLoader}, but it may also be used
24	* to load data from local disk, databases etc. without communication with the client.
25	* The {@link DataHandler} is also responsible for writing the the data back to the source
26	* </li>
27	* <li>
28	* The <b>{@link SplitMap}</b> which represents the current partitioning.
29	* </li>
30	* <li>
31	* A <b>splitmap position</b>, which identifies the partition number in the split.
32	* </li>
33	*
34	* @author Dominik Appl
35	*
36	*
37	*/
38	public class SinglePartitionInfo implements Serializable, PartitionInfo{
39
40	private final int baseResourceID;
41	private final PartitionDataHandler handler;
42	private final SplitMap splitMap;
43	private final int splitMapPos;
44	private final String baseResourceName;
45
46	/**
47	* The constructor.
48	*
49	* @param baseResourceID the root id (see {@link DataPartition#getRootID()})
50	* @param baseResourceName the name of the resource (given by parallel programmer)
51	* @param handler {@link PartitionDataHandler}
52	* which is responsible for loading and unloading
53	* @param splitMap splitmap describing the partitioning
54	* @param splitMapPos the position inside the splitmap
55	*/
56	public SinglePartitionInfo(int baseResourceID, String baseResourceName, PartitionDataHandler handler, SplitMap splitMap, int splitMapPos){
57	this.baseResourceID = baseResourceID;
58	this.baseResourceName = baseResourceName;
59	this.handler = handler;
60	this.splitMap = splitMap;
61	this.splitMapPos = splitMapPos;
62	}
63
64	/**
65	* @return the baseResourceID
66	*/
67	public int getBaseResourceID() {
68	return baseResourceID;
69	}
70	/**
71	* @return the handler
72	*/
73	public PartitionDataHandler getPartitionDataHandler() {
74	return handler;
75	}
76	/* (non-Javadoc)
77	* @see appl.parallel.spmd.split.PartitionInfo#getSplitMap()
78	*/
79	public SplitMap getSplitMap() {
80	return splitMap;
81	}
82	/* (non-Javadoc)
83	* @see appl.parallel.spmd.split.PartitionInfo#getSplitMapPos()
84	*/
85	public int getSplitMapPos() {
86	return splitMapPos;
87	}
88
89	/* (non-Javadoc)
90	* @see appl.parallel.spmd.split.PartitionInfo#getBaseResourceName()
91	*/
92	public String getBaseResourceName() {
93	return baseResourceName;
94	}
95
96	public PartitionInfo clone(int newRootID){
97	PartitionDataHandler clonedHandler = handler.clone();
98	clonedHandler.setRootID(newRootID);
99	return new SinglePartitionInfo(newRootID,
100	this.baseResourceName,clonedHandler,this.splitMap,
101	this.splitMapPos);
102	}
103
104	}