data sreucture : sequence

import java.util.List;

public interface Sequence {



//general

public int size();
public boolean isEmpty();
//List
public Position first()throws EmptyCountinerException;
public Position last()throws EmptyCountinerException;
public Position before(Position p)
throws InvalidPositionException,BoundaryViolationException;
public Position after(Position p)
throws InvalidPositionException,BoundaryViolationException;
public Position insertBefore(Position p,Object element)
throws InvalidPositionException;
public Position insertafter(Position p,Object element)
throws InvalidPositionException;
public Position insertFirst(Object element);
public Position insertLast(Object element);
public Position remove(Position p)
throws InvalidPositionException;
public Object replaceElement(Position p,Object element)
throws InvalidPositionException;
public void swapElement(Position a,Position b)
throws InvalidPositionException;
//victor
public Object elemAtRank(int r);
public Object replaceAtRank(int r,Object e);
public void insertAtRank(int r,Object e);
public Object removeAtRank(int r);
//sequence
public Position atRank(int rank)throws BoundaryViolationException;
public int rankOf(Position position)throws InvalidPositionException;
}



class EmptyCountinerException extends RuntimeException{
public EmptyCountinerException(String Empty){
super(Empty);
}
}


class BoundaryViolationException extends RuntimeException{
public BoundaryViolationException(String f){
super(f);
}
}


class InvalidPositionException extends RuntimeException{
public InvalidPositionException(String InvalidPosition){
super( InvalidPosition);
}
}

import java.util.Vector;

public Object element(Position s) throws InvalidPositionException;



}

public interface Position{

import java.util.ArrayList;

public class vector implements Sequence{

int r=0;

Vector v=new Vector();

public Position p[]=new Position[v.size()];
public Position P;

public int size(){

return v.size();

}

public boolean isEmpty(){

return v.isEmpty();
}

public Position first(){

return p[v.indexOf(v.firstElement())];
}

public Position last(){
return p[v.indexOf(v.lastElement())];

}
public Position before(Position n){
Position s=n;
Object N=P.element(s);

return p[v.indexOf(N)-1];

}
public Position after(Position n){
Position s=n;
Object N=P.element(s);

return p[v.indexOf(N)+1];

}

public Position insertBefore(Position n,Object ele){
Position s=n;
Object N=P.element(s);
Object el=ele;
for(int i=v.size();i>=v.indexOf(N);i--)
p[i+1]=p;
r=v.indexOf(N);
v.add(r-1,el);


return p[v.indexOf(v.get(r-1))];


}

public Position insertafter(Position n,Object ele){

Position s=n;
Object N=P.element(s);
Object el=ele;
for(int i=v.size();i>=v.indexOf(N);i--)
p[i+1]=p;
r=v.indexOf(N);
v.add(r+1,el);


return p[v.indexOf(v.get(r+1))];


}


public Position insertFirst(Object ele){

Object N=ele;
v.add(0,N);



return p[v.indexOf(v.get(0))];
}

public Position insertLast(Object ele){

Object N=ele;
v.add(size(),N);
return p[v.indexOf(v.get(size()))];

}
public Position remove(Position n){
Position s=n;
Object N=P.element(s);
for(int i=v.indexOf(N);i<v.size();i++)
p=p[i+1];
r=v.indexOf(N);
v.remove(r);


return s;
}
public Object replaceElement(Position n,Object ele){
Position s=n;
Object N=ele;
Object C=P.element(s);
r=v.indexOf(C);
v.set(r,N);
return N;
}
public void swapElement(Position a,Position b){
Position c=a;
Position s=b;
Object C=P.element(c);
Object S=P.element(s);
r=v.indexOf(C);
v.set(r,S);
r=v.indexOf(S);
v.set(r,C);

}
public Object elemAtRank(int n){
r=n;
return v.get(r);
}
public Object replaceAtRank(int n,Object e){
r=n;
Object N=e;
v.set(r,N);
return N;

}
public void insertAtRank(int n,Object e){
r=n;
Object N=e;
v.add(r,N);

}
public Object removeAtRank(int n){
r=n;
Object Old=v.get(r);
v.remove(r);
return Old;
}
public Position atRank(int rank){
r=rank;

return p[v.indexOf(v.get(r))];
}

public int rankOf(Position position){
Position s=position;
Object N=P.element(s);
r=v.indexOf(N);
return r;
}

}

import java.util.Vector;