FileDocCategorySizeDatePackage
RoleList.javaAPI DocJava SE 6 API10270Tue Jun 10 00:26:18 BST 2008javax.management.relation

RoleList

public class RoleList extends ArrayList
A RoleList represents a list of roles (Role objects). It is used as parameter when creating a relation, and when trying to set several roles in a relation (via 'setRoles()' method). It is returned as part of a RoleResult, to provide roles successfully retrieved.
since
1.5

Fields Summary
private transient boolean
typeSafe
private transient boolean
tainted
private static final long
serialVersionUID
Constructors Summary
public RoleList()
Constructs an empty RoleList.


    //
    // Constructors
    //

             
      
	super();
public RoleList(int initialCapacity)
Constructs an empty RoleList with the initial capacity specified.

param
initialCapacity initial capacity

	super(initialCapacity);
public RoleList(List list)
Constructs a {@code RoleList} containing the elements of the {@code List} specified, in the order in which they are returned by the {@code List}'s iterator. The {@code RoleList} instance has an initial capacity of 110% of the size of the {@code List} specified.

param
list the {@code List} that defines the initial contents of the new {@code RoleList}.
exception
IllegalArgumentException if the {@code list} parameter is {@code null} or if the {@code list} parameter contains any non-Role objects.
see
ArrayList#ArrayList(java.util.Collection)

        // Check for null parameter
        //
        if (list == null)
            throw new IllegalArgumentException("Null parameter");

        // Check for non-Role objects
        //
        checkTypeSafe(list);

        // Build the List<Role>
        //
        super.addAll(list);
Methods Summary
public booleanadd(java.lang.Object o)

        if (!tainted)
            tainted = isTainted(o);
        if (typeSafe)
            checkTypeSafe(o);
        return super.add(o);
public voidadd(int index, java.lang.Object element)

        if (!tainted)
            tainted = isTainted(element);
        if (typeSafe)
            checkTypeSafe(element);
        super.add(index, element);
public voidadd(javax.management.relation.Role role)
Adds the Role specified as the last element of the list.

param
role the role to be added.
exception
IllegalArgumentException if the role is null.


	if (role == null) {
	    String excMsg = "Invalid parameter";
	    throw new IllegalArgumentException(excMsg);
	}
	super.add(role);
public voidadd(int index, javax.management.relation.Role role)
Inserts the role specified as an element at the position specified. Elements with an index greater than or equal to the current position are shifted up.

param
index The position in the list where the new Role object is to be inserted.
param
role The Role object to be inserted.
exception
IllegalArgumentException if the role is null.
exception
IndexOutOfBoundsException if accessing with an index outside of the list.


	if (role == null) {
	    String excMsg = "Invalid parameter";
	    throw new IllegalArgumentException(excMsg);
	}

	super.add(index, role);
public booleanaddAll(java.util.Collection c)

        if (!tainted)
            tainted = isTainted(c);
        if (typeSafe)
            checkTypeSafe(c);
        return super.addAll(c);
public booleanaddAll(int index, java.util.Collection c)

        if (!tainted)
            tainted = isTainted(c);
        if (typeSafe)
            checkTypeSafe(c);
        return super.addAll(index, c);
public booleanaddAll(javax.management.relation.RoleList roleList)
Appends all the elements in the RoleList specified to the end of the list, in the order in which they are returned by the Iterator of the RoleList specified.

param
roleList Elements to be inserted into the list (can be null)
return
true if this list changed as a result of the call.
exception
IndexOutOfBoundsException if accessing with an index outside of the list.
see
ArrayList#addAll(Collection)


	if (roleList == null) {
	    return true;
	}

	return (super.addAll(roleList));
public booleanaddAll(int index, javax.management.relation.RoleList roleList)
Inserts all of the elements in the RoleList specified into this list, starting at the specified position, in the order in which they are returned by the Iterator of the RoleList specified.

param
index Position at which to insert the first element from the RoleList specified.
param
roleList Elements to be inserted into the list.
return
true if this list changed as a result of the call.
exception
IllegalArgumentException if the role is null.
exception
IndexOutOfBoundsException if accessing with an index outside of the list.
see
ArrayList#addAll(int, Collection)


	if (roleList == null) {
	    // Revisit [cebro] Localize message
	    String excMsg = "Invalid parameter.";
	    throw new IllegalArgumentException(excMsg);
	}

	return (super.addAll(index, roleList));
public java.util.ListasList()
Return a view of this list as a {@code List}. Changes to the returned value are reflected by changes to the original {@code RoleList} and vice versa.

return
a {@code List} whose contents reflect the contents of this {@code RoleList}.

If this method has ever been called on a given {@code RoleList} instance, a subsequent attempt to add an object to that instance which is not a {@code Role} will fail with an {@code IllegalArgumentException}. For compatibility reasons, a {@code RoleList} on which this method has never been called does allow objects other than {@code Role}s to be added.

throws
IllegalArgumentException if this {@code RoleList} contains an element that is not a {@code Role}.
since
1.6

        if (!typeSafe) {
            if (tainted)
                checkTypeSafe(this);
            typeSafe = true;
        }
	return (List<Role>) (List) this;
private static voidcheckTypeSafe(java.lang.Object o)
IllegalArgumentException if o is a non-Role object.

        try {
            o = (Role) o;
        } catch (ClassCastException e) {
            throw new IllegalArgumentException(e);
        }
private static voidcheckTypeSafe(java.util.Collection c)
IllegalArgumentException if c contains any non-Role objects.

        try {
            Role r;
            for (Object o : c)
                r = (Role) o;
        } catch (ClassCastException e) {
            throw new IllegalArgumentException(e);
        }
private static booleanisTainted(java.lang.Object o)
Returns true if o is a non-Role object.

        try {
            checkTypeSafe(o);
        } catch (IllegalArgumentException e) {
            return true;
        }
        return false;
private static booleanisTainted(java.util.Collection c)
Returns true if c contains any non-Role objects.

        try {
            checkTypeSafe(c);
        } catch (IllegalArgumentException e) {
            return true;
        }
        return false;
public java.lang.Objectset(int index, java.lang.Object element)

        if (!tainted)
            tainted = isTainted(element);
        if (typeSafe)
            checkTypeSafe(element);
        return super.set(index, element);
public voidset(int index, javax.management.relation.Role role)
Sets the element at the position specified to be the role specified. The previous element at that position is discarded.

param
index The position specified.
param
role The value to which the role element should be set.
exception
IllegalArgumentException if the role is null.
exception
IndexOutOfBoundsException if accessing with an index outside of the list.


	if (role == null) {
	    // Revisit [cebro] Localize message
	    String excMsg = "Invalid parameter.";
	    throw new IllegalArgumentException(excMsg);
	}

	super.set(index, role);