elge.engine.pools
Class ClassLoadInfo

java.lang.Object
  |
  +--elge.engine.pools.ClassLoadInfo

All Implemented Interfaces:

Comparator

public class ClassLoadInfo

extends Object

implements Comparator

Field Summary

protected int	AVAIBLE
protected int	CLASS
protected static ClassLoadInfo	cli
protected Object[]	data
protected int	NAME
protected int	PARENT
protected int	SHOW
protected int	SOURCE
protected int	TEMPLATES

Constructor Summary

ClassLoadInfo()

ClassLoadInfo(Class cls)

ClassLoadInfo(ClassPool parent, String source, String forname)

ClassLoadInfo(String forname)

ClassLoadInfo(String source, String forname)

Method Summary

Object	addTemplate()
int	compare(Object o1, Object o2) Compares its two arguments for order.
void	delTemplate(int row) remove the template...
Boolean	getAvaible()
ClassPool	getClassPool()
Object	getCol(int col)
Class	getLoadedClass()
String	getName()
static Comparator	getNameComparator()
Boolean	getShow()
String	getSource()
Vector	getTemplates()
Object	getTemplateValueAt(int row, int col) Returns information from the template vector.
void	setAvaible(Boolean av)
protected void	setClassPool(ClassPool parent)
void	setCol(Object value, int col)
void	setLoadedClass(Class cls)
void	setName(String name)
void	setShow(Boolean sh)
void	setSource(String source)
void	setTemplates(Vector vec)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Comparator

equals

Field Detail

data

protected Object[] data

cli

protected static ClassLoadInfo cli

SOURCE

protected final int SOURCE

See Also:

Constant Field Values

NAME

protected final int NAME

See Also:

Constant Field Values

AVAIBLE

protected final int AVAIBLE

See Also:

Constant Field Values

SHOW

protected final int SHOW

See Also:

Constant Field Values

CLASS

protected final int CLASS

See Also:

Constant Field Values

TEMPLATES

protected final int TEMPLATES

See Also:

Constant Field Values

PARENT

protected final int PARENT

See Also:

Constant Field Values

Constructor Detail

ClassLoadInfo

public ClassLoadInfo()

ClassLoadInfo

public ClassLoadInfo(Class cls)

ClassLoadInfo

public ClassLoadInfo(String forname)

ClassLoadInfo

public ClassLoadInfo(String source,
                     String forname)

ClassLoadInfo

public ClassLoadInfo(ClassPool parent,
                     String source,
                     String forname)

Method Detail

getNameComparator

public static Comparator getNameComparator()

getSource

public String getSource()

setSource

public void setSource(String source)

getName

public String getName()

setName

public void setName(String name)

getAvaible

public Boolean getAvaible()

setAvaible

public void setAvaible(Boolean av)

getShow

public Boolean getShow()

setShow

public void setShow(Boolean sh)

getLoadedClass

public Class getLoadedClass()

setLoadedClass

public void setLoadedClass(Class cls)

getTemplates

public Vector getTemplates()

setTemplates

public void setTemplates(Vector vec)

getClassPool

public ClassPool getClassPool()

setClassPool

protected void setClassPool(ClassPool parent)

addTemplate

public Object addTemplate()

delTemplate

public void delTemplate(int row)

remove the template...

getTemplateValueAt

public Object getTemplateValueAt(int row,
                                 int col)

Returns information from the template vector.

getCol

public Object getCol(int col)

setCol

public void setCol(Object value,
                   int col)

compare

public int compare(Object o1,
                   Object o2)

Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

The implementor must ensure that sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.)

The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0.

Finally, the implementer must ensure that compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z.

It is generally the case, but not strictly required that (compare(x, y)==0) == (x.equals(y)). Generally speaking, any comparator that violates this condition should clearly indicate this fact. The recommended language is "Note: this comparator imposes orderings that are inconsistent with equals."

Specified by:

compare in interface Comparator

Parameters:

o1 - the first object to be compared.

o2 - the second object to be compared.

Returns:

a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

Throws:

ClassCastException - if the arguments' types prevent them from being compared by this Comparator.