UsecaseImpl.java

Go to the documentation of this file.

package com.arcle.rmt.superwaba.model.imp.rqml;

import superwaba.ext.xplat.io.Storable;
import superwaba.ext.xplat.io.DataStream;

import com.arcle.rmt.xplat.util.List;
import com.arcle.rmt.xplat.util.Iterator;
import com.arcle.rmt.superwaba.model.imp.*;
import com.arcle.rmt.rqml.*;

public class UsecaseImpl extends RQMLFirstClassImpl implements Usecase {

    public UsecaseImpl() {
        actors = createList();
        preconditions = createList();
        postconditions = createList();
        normalCourse = createNormalCourseImpl();
        comment = createCommentImpl();
        alternativeCourses = createList();
        exceptions = createList();
    }


    //-----------------------------------------------------------------------
    // Usecase Implementations

    public Actor createActor() {
        Actor act = createActorImpl();
        actors.add(act);
        return act;
    }

    public Precondition createPrecondition() {
        Precondition pre = createPreconditionImpl();
        preconditions.add(pre);
        return pre;
    }


    public Postcondition createPostcondition() {
        Postcondition post = createPostconditionImpl();
        postconditions.add(post);
        return post;
    }


    public AlternativeCourse createAlternativeCourse() {
        AlternativeCourse ac = createAlternativeCourseImpl();
        alternativeCourses.add(ac);
        return ac;
    }

    public com.arcle.rmt.rqml.Exception createException() {
        com.arcle.rmt.rqml.Exception ex = createExceptionImpl();
        exceptions.add(ex);
        return ex;
    }

    public Iterator getActors() {
        return actors.iterator();
    }

    public Iterator getPreconditions() {
        return preconditions.iterator();
    }

    public Iterator getPostconditions() {
        return postconditions.iterator();
    }

    public NormalCourse getNormalCourse() {
        return normalCourse;
    }

    public Iterator getAlternativeCourses() {
        return alternativeCourses.iterator();
    }


    public Iterator getExceptions() {
        return exceptions.iterator();
    }

    public Comment getComment() {
        return comment;
    }


    public Actor getActor() {
        if (actors.size() == 0) {
            return createActor();
        } else {
            return (Actor) actors.get(0);
        }
    }


    public Precondition getPrecondition() {
        if (preconditions.size() == 0) {
            return createPrecondition();
        } else {
            return (Precondition) preconditions.get(0);
        }
    }


    public Postcondition getPostcondition() {
        if (postconditions.size() == 0) {
            return createPostcondition();
        } else {
            return (Postcondition) postconditions.get(0);
        }
    }

    public com.arcle.rmt.rqml.Exception  getException() {
        if (exceptions.size() == 0) {
            return createException();
        } else {
            return (com.arcle.rmt.rqml.Exception) exceptions.get(0);
        }
    }

    public AlternativeCourse getAlternativeCourse() {
        if (alternativeCourses.size() == 0) {
            return createAlternativeCourse();
        } else {
            return (AlternativeCourse) alternativeCourses.get(0);
        }
    }


    //-----------------------------------------------------------------------
    // Member variables

    private List actors;
    private List preconditions;
    private List postconditions;
    private NormalCourseImpl normalCourse;
    private List alternativeCourses;
    private List exceptions;
    private CommentImpl comment;

    //-----------------------------------------------------------------------
    // Factory Methods

    public GenericMemento createMemento() {
        return new Memento(this);
    }

    protected ActorImpl createActorImpl() {
        return new ActorImpl();
    }

    protected PreconditionImpl createPreconditionImpl() {
        return new PreconditionImpl();
    }

    protected PostconditionImpl createPostconditionImpl() {
        return new PostconditionImpl();
    }

    protected NormalCourseImpl createNormalCourseImpl() {
        return new NormalCourseImpl();
    }

    protected AlternativeCourseImpl createAlternativeCourseImpl() {
        return new AlternativeCourseImpl();
    }


    protected ExceptionImpl createExceptionImpl() {
        return new ExceptionImpl();
    }

    protected CommentImpl createCommentImpl() {
        return new CommentImpl();
    }

    //-----------------------------------------------------------------------
    // Inner Classes

    protected static class Memento extends RQMLFirstClassImpl.Memento {
        public Memento(UsecaseImpl originator) {
            super(originator);
        }

        public Storable getInstance() {
            // This memento is not directly stored in the Catalog as an
            // object, so this factory method is not required.
            return null;
        }

        public void saveState(DataStream data) {
            super.saveState(data);
            final UsecaseImpl org = (UsecaseImpl) getOriginator();
            saveMementoable(org.normalCourse, data);
            saveMementoable(org.comment, data);

            saveList(org.actors, data);
            saveList(org.preconditions, data);
            saveList(org.postconditions, data);
            saveList(org.alternativeCourses, data);
            saveList(org.exceptions, data);

        }

        public void loadState(DataStream data) {
            super.loadState(data);
            final UsecaseImpl org = (UsecaseImpl) getOriginator();

            org.normalCourse = (NormalCourseImpl) loadMementoable(data,
                new MementoableFactory() {
                    public Mementoable createOriginator() {
                        return org.createNormalCourseImpl();
                    }
            });

            org.comment = (CommentImpl) loadMementoable(data,
                new MementoableFactory() {
                    public Mementoable createOriginator() {
                        return org.createCommentImpl();
                    }
            });

            org.actors = loadList(data, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return org.createActorImpl();
                }
            });

            org.preconditions = loadList(data, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return org.createPreconditionImpl();
                }
            });

            org.postconditions = loadList(data, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return org.createPostconditionImpl();
                }
            });

            org.alternativeCourses = loadList(data, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return org.createAlternativeCourseImpl();
                }
            });

            org.exceptions = loadList(data, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return org.createExceptionImpl();
                }
            });

        }


        public byte getID() {
            return DocumentImpl.USECASE_ID;
        }
    }
}

---