public RoleUnresolvedList() 
{
        super();
}

Constructs an empty RoleUnresolvedList.

 public RoleUnresolvedList(int initialCapacity) 
{
        super(initialCapacity);
}

Constructs an empty RoleUnresolvedList with the initial capacity specified.

Parameters:

initialCapacity - initial capacity

 public RoleUnresolvedList(List<RoleUnresolved> list) throws IllegalArgumentException 
{
        // Check for null parameter
        //
        if (list == null)
            throw new IllegalArgumentException("Null parameter");
        // Check for non-RoleUnresolved objects
        //
        checkTypeSafe(list);
        // Build the List< RoleUnresolved >
        //
        super.addAll(list);
}

Constructs a {@code RoleUnresolvedList} containing the elements of the {@code List} specified, in the order in which they are returned by the {@code List}'s iterator. The {@code RoleUnresolvedList} instance has an initial capacity of 110% of the size of the {@code List} specified.

Parameters:

list - the {@code List} that defines the initial contents of the new {@code RoleUnresolvedList}.

Throws:

IllegalArgumentException - if the {@code list} parameter is {@code null} or if the {@code list} parameter contains any non-RoleUnresolved objects.

Also see:

ArrayList#ArrayList(java.util.Collection)
exception: IllegalArgumentException - if the {@code list} parameter is {@code null} or if the {@code list} parameter contains any non-RoleUnresolved objects.

 public  void add(RoleUnresolved role) throws IllegalArgumentException 
{
        if (role == null) {
            String excMsg = "Invalid parameter";
            throw new IllegalArgumentException(excMsg);
        }
        super.add(role);
}

Adds the RoleUnresolved specified as the last element of the list.

 public boolean add(Object o) 
{
        if (!tainted)
            tainted = isTainted(o);
        if (typeSafe)
            checkTypeSafe(o);
        return super.add(o);
}

 public  void add(int index,
    RoleUnresolved role) throws IllegalArgumentException, IndexOutOfBoundsException 
{
        if (role == null) {
            String excMsg = "Invalid parameter";
            throw new IllegalArgumentException(excMsg);
        }
        super.add(index, role);
}

Inserts the unresolved role specified as an element at the position specified. Elements with an index greater than or equal to the current position are shifted up.

 public  void add(int index,
    Object element) 
{
        if (!tainted)
            tainted = isTainted(element);
        if (typeSafe)
            checkTypeSafe(element);
        super.add(index, element);
}

 public boolean addAll(RoleUnresolvedList roleList) throws IndexOutOfBoundsException 
{
        if (roleList == null) {
            return true;
        }
        return (super.addAll(roleList));
}

Appends all the elements in the RoleUnresolvedList specified to the end of the list, in the order in which they are returned by the Iterator of the RoleUnresolvedList specified.

 public boolean addAll(Collection<?> c) 
{
        if (!tainted)
            tainted = isTainted(c);
        if (typeSafe)
            checkTypeSafe(c);
        return super.addAll(c);
}

 public boolean addAll(int index,
    RoleUnresolvedList roleList) throws IllegalArgumentException, IndexOutOfBoundsException 
{
        if (roleList == null) {
            String excMsg = "Invalid parameter";
            throw new IllegalArgumentException(excMsg);
        }
        return (super.addAll(index, roleList));
}

Inserts all of the elements in the RoleUnresolvedList specified into this list, starting at the specified position, in the order in which they are returned by the Iterator of the RoleUnresolvedList specified.

 public boolean addAll(int index,
    Collection<?> c) 
{
        if (!tainted)
            tainted = isTainted(c);
        if (typeSafe)
            checkTypeSafe(c);
        return super.addAll(index, c);
}

 public List<RoleUnresolved> asList() 
{
        if (!typeSafe) {
            if (tainted)
                checkTypeSafe(this);
            typeSafe = true;
        }
        return Util.cast(this);
}

Return a view of this list as a {@code List}. Changes to the returned value are reflected by changes to the original {@code RoleUnresolvedList} and vice versa.

 public  void set(int index,
    RoleUnresolved role) throws IllegalArgumentException, IndexOutOfBoundsException 
{
        if (role == null) {
            String excMsg = "Invalid parameter";
            throw new IllegalArgumentException(excMsg);
        }
        super.set(index, role);
}

Sets the element at the position specified to be the unresolved role specified. The previous element at that position is discarded.

 public Object set(int index,
    Object element) 
{
        if (!tainted)
            tainted = isTainted(element);
        if (typeSafe)
            checkTypeSafe(element);
        return super.set(index, element);
}