DocumentImpl.java

Go to the documentation of this file.

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


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

import com.arcle.rmt.xplat.util.List;
import com.arcle.rmt.superwaba.util.VectorListAdapter;
import com.arcle.rmt.superwaba.model.Document;
import com.arcle.rmt.superwaba.framework.Model;
import com.arcle.rmt.rqml.*;
import com.arcle.rmt.superwaba.model.imp.rqml.*;

public class DocumentImpl implements Document, Mementoable, Model {
    //-----------------------------------------------------------------------
    // General

    public DocumentImpl() {
        requirements = createList();
        assumptions = createList();
        stakeholders = createList();
        issues = createList();
        taxonomies = createList();
        lexicons = createList();
        contexts = createList();
        projects = createList();
        usecases = createList();
    }

    //-----------------------------------------------------------------------
    // Project

    public Project createProject() {
        Project elem = createProjectImpl();
        projects.add(elem);
        elem.setID("prj-" + projects.size());
        return elem;
    }


    public int getProjectCount() {
        return projects.size();
    }


    public Project getProjectAt(int index) {
        return (Project) projects.get(index);
    }


    public boolean deleteProject(int index) {
        projects.remove(index);
        return true;
    }

    public boolean deleteProject(Project elem) {
        return projects.remove(elem);
    }

    //-----------------------------------------------------------------------
    // Requirement

    public Requirement createRequirement() {
        Requirement elem = createRequirementImpl();
        requirements.add(elem);
        elem.setID("req-" + requirements.size());
        return elem;
    }

    public int getRequirementCount() {
        return requirements.size();
    }


    public Requirement getRequirementAt(int index) {
        return (Requirement) requirements.get(index);
    }


    public boolean deleteRequirement(int index) {
        requirements.remove(index);
        return true;
    }

    public boolean deleteRequirement(Requirement req) {
        return requirements.remove(req);
    }

    //-----------------------------------------------------------------------
    // Stakeholder

    public Stakeholder createStakeholder() {
        Stakeholder elem = createStakeholderImpl();
        stakeholders.add(elem);
        elem.setID("st-" + stakeholders.size());
        return elem;
    }


    public int getStakeholderCount() {
        return stakeholders.size();
    }


    public Stakeholder getStakeholderAt(int index) {
        return (Stakeholder) stakeholders.get(index);
    }


    public boolean deleteStakeholder(int index) {
        stakeholders.remove(index);
        return true;
    }

    public boolean deleteStakeholder(Stakeholder elem) {
        return stakeholders.remove(elem);
    }


    //-----------------------------------------------------------------------
    // Use-Case

    public Usecase createUsecase() {
        Usecase elem = createUsecaseImpl();
        usecases.add(elem);
        elem.setID("uc-" + usecases.size());
        return elem;
    }

    public int getUsecaseCount() {
        return usecases.size();
    }


    public Usecase getUsecaseAt(int index) {
        return (Usecase) usecases.get(index);
    }


    public boolean deleteUsecase(int index) {
        usecases.remove(index);
        return true;
    }

    public boolean deleteUsecase(Usecase uc) {
        return usecases.remove(uc);
    }


    //-----------------------------------------------------------------------
    // Assumption

    public Assumption createAssumption() {
        Assumption elem= createAssumptionImpl();
        assumptions.add(elem);
        elem.setID("as-" + assumptions.size());
        return elem;
    }


    public int getAssumptionCount() {
        return assumptions.size();
    }

    public Assumption getAssumptionAt(int index) {
        return (Assumption) assumptions.get(index);
    }

    public boolean deleteAssumption(int index) {
        assumptions.remove(index);
        return true;
    }

    public boolean deleteAssumption(Assumption asm) {
        return assumptions.remove(asm);
    }

    //-----------------------------------------------------------------------
    // Issue


    public Issue createIssue() {
        Issue elem = createIssueImpl();
        issues.add(elem);
        elem.setID("iss-" + issues.size());
        return elem;
    }

    public int getIssueCount() {
        return issues.size();
    }


    public Issue getIssueAt(int index) {
        return (Issue) issues.get(index);
    }


    public boolean deleteIssue(int index) {
        issues.remove(index);
        return true;
    }

    public boolean deleteIssue(Issue elem) {
        return issues.remove(elem);
    }

    //-----------------------------------------------------------------------
    // Taxonomy


    public Taxonomy createTaxonomy() {
        Taxonomy elem = createTaxonomyImpl();
        taxonomies.add(elem);
        elem.setID("tax-" + taxonomies.size());
        return elem;
    }


    public int getTaxonomyCount() {
        return taxonomies.size();
    }


    public Taxonomy getTaxonomyAt(int index) {
        return (Taxonomy) taxonomies.get(index);
    }


    public boolean deleteTaxonomy(int index) {
        taxonomies.remove(index);
        return true;
    }

    public boolean deleteTaxonomy(Taxonomy elem) {
        return taxonomies.remove(elem);
    }

    //-----------------------------------------------------------------------
    // Context

    public Context createContext() {
        Context elem = createContextImpl();
        contexts.add(elem);
        elem.setID("ctx-" + contexts.size());
        return elem;
    }


    public int getContextCount() {
        return contexts.size();
    }


    public Context getContextAt(int index) {
        return (Context) contexts.get(index);
    }


    public boolean deleteContext(int index) {
        contexts.remove(index);
        return true;
    }

    public boolean deleteContext(Context elem) {
        return contexts.remove(elem);
    }

    //-----------------------------------------------------------------------
    // Lexicon


    public Lexicon createLexicon() {
        Lexicon elem = createLexiconImpl();
        lexicons.add(elem);
        elem.setID("lex-" + lexicons.size());
        return elem;
    }


    public int getLexiconCount() {
        return lexicons.size();
    }


    public Lexicon getLexiconAt(int index) {
        return (Lexicon) lexicons.get(index);
    }


    public boolean deleteLexicon(int index) {
        lexicons.remove(index);
        return true;
    }

    public boolean deleteLexicon(Lexicon elem) {
        return lexicons.remove(elem);
    }


    //-----------------------------------------------------------------------
    // Group

    //-----------------------------------------------------------------------
    // Trace


    //-----------------------------------------------------------------------
    // Mementoable Implementation

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


    public void setMemento(GenericMemento m) {
        DocumentImpl originator = (DocumentImpl) m.getOriginator();
        if (originator != this) {
            // must be a placeholder originator
            shallowClone(originator);
        }
    }


    //-----------------------------------------------------------------------
    // Public Access Methods

    public void setTitle(String title) {
        _title = title;
    }

    public String getTitle() {
        return _title;
    }

    public void setDeleted() {
        _isDeleted = true;
    }

    public boolean isDeleted() {
        return _isDeleted;
    }


    //-----------------------------------------------------------------------
    // Protected Utility Methods


    protected void shallowClone(DocumentImpl other) {
        requirements = other.requirements;
        _title = other._title;
    }


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

    protected RequirementImpl createRequirementImpl() {
        return new RequirementImpl();
    }

    protected AssumptionImpl createAssumptionImpl() {
        return new AssumptionImpl();
    }


    protected StakeholderImpl createStakeholderImpl() {
        return new StakeholderImpl();
    }

    protected IssueImpl createIssueImpl() {
        return new IssueImpl();
    }

    protected TaxonomyImpl createTaxonomyImpl() {
        return new TaxonomyImpl();
    }

    protected LexiconImpl createLexiconImpl() {
        return new LexiconImpl();
    }

    protected ContextImpl createContextImpl() {
        return new ContextImpl();
    }

    protected ProjectImpl createProjectImpl() {
        return new ProjectImpl();
    }

    protected UsecaseImpl createUsecaseImpl() {
        return new UsecaseImpl();
    }


    protected List createList() {
        return new VectorListAdapter();
    }


    //-----------------------------------------------------------------------
    // First-Class Element IDs

    public static final byte DOCUMENT_ID    = 0x01;

    public static final byte PROJECT_ID     = 0x02;

    public static final byte REQUIREMENT_ID = 0x03;

    public static final byte STAKEHOLDER_ID = 0x04;

    public static final byte USECASE_ID     = 0x05;

    public static final byte ASSUMPTION_ID  = 0x06;

    public static final byte ISSUE_ID       = 0x07;

    public static final byte TAXONOMY_ID    = 0x08;

    public static final byte CONTEXT_ID     = 0x09;

    public static final byte LEXICON_ID     = 0x0A;

    public static final byte GROUP_ID       = 0x0B;

    public static final byte TRACE_ID       = 0x0C;

    //-----------------------------------------------------------------------
    // Nested Element IDs


    public static final byte NAME_ID        = 0x10;

    public static final byte DESCRIPTION_ID = 0x11;

    public static final byte RATIONALE_ID   = 0x12;

    public static final byte DEFINITION_ID  = 0x13;

    public static final byte TEXTUAL_DATA_ID = 0x14;

    public static final byte ORIGIN_ID = 0x15;

    public static final byte PRODUCT_ID = 0x16;

    public static final byte PROBLEM_ID = 0x17;

    public static final byte SCOPE_ID = 0x18;

    public static final byte VISION_ID = 0x19;

    public static final byte ACTOR_ID = 0x1A;

    public static final byte PRECONDITION_ID = 0x1B;

    public static final byte POSTCONDITION_ID = 0x1C;

    public static final byte NORMAL_COURSE_ID = 0x1D;

    public static final byte ALTERNATIVE_COURSE_ID = 0X1E;

    public static final byte EXCEPTION_ID = 0X1F;

    public static final byte ACTORACTION_ID = 0x20;

    public static final byte SYSTEMRESPONSE_ID = 0X21;

    public static final byte COMMENT_ID = 0x22;

    //-----------------------------------------------------------------------
    // Instance variables

    private List requirements;

    private List assumptions;

    private List stakeholders;

    private List issues;

    private List taxonomies;

    private List lexicons;

    private List contexts;

    private List projects;

    private List usecases;

    private String _title;

    private boolean _isDeleted = false;

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

    protected static class Memento extends GenericMemento {
        public Memento(DocumentImpl originator) {
            super(originator);
        }

        //--------------------------------------------------------------------
        // implementation methods for GenericMemento

        public byte getID() {
            return DOCUMENT_ID;
        }

        public Storable getInstance() {
            // creates a blank originator to serve as temporary data
            // storage.
            DocumentImpl originator = createDocumentImpl();
            return new Memento(originator);
        }

        public void saveState(DataStream data) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            data.writeString(org._title);

            saveRequirements(data);
            saveAssumptions(data);
            saveStakeholders(data);
            saveIssues(data);
            saveTaxonomies(data);
            saveContexts(data);
            saveProjects(data);
            saveUsecases(data);
            saveLexicons(data);
        }

        public void loadState(DataStream data) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org._title = data.readString();

            loadRequirements(data);
            loadAssumptions(data);
            loadStakeholders(data);
            loadIssues(data);
            loadTaxonomies(data);
            loadContexts(data);
            loadProjects(data);
            loadUsecases(data);
            loadLexicons(data);
        }

        //--------------------------------------------------------------------
        // Own Protected Methods

        //----

        protected void saveRequirements(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.requirements, stream);
        }

        protected void loadRequirements(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.requirements = loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createRequirementImpl();
                }
            });
        }

        //----

        protected void saveAssumptions(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.assumptions, stream);
        }

        protected void loadAssumptions(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.assumptions = loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createAssumptionImpl();
                }
            });
        }

        //----

        protected void saveStakeholders(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.stakeholders, stream);
        }

        protected void loadStakeholders(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.stakeholders = loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createStakeholderImpl();
                }
            });
        }

        //----

        protected void saveIssues(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.issues, stream);
        }

        protected void loadIssues(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.issues = loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createIssueImpl();
                }
            });
        }

        //----

        protected void saveTaxonomies(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.taxonomies, stream);
        }

        protected void loadTaxonomies(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.taxonomies = loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createTaxonomyImpl();
                }
            });
        }

        //----

        protected void saveLexicons(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.lexicons, stream);
        }

        protected void loadLexicons(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.lexicons= loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createLexiconImpl();
                }
            });
        }

        //----
        protected void saveContexts(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.contexts, stream);
        }

        protected void loadContexts(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.contexts = loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createContextImpl();
                }
            });
        }

        //----
        protected void saveProjects(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.projects, stream);
        }

        protected void loadProjects(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.projects = loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createProjectImpl();
                }
            });
        }

        //----
        protected void saveUsecases(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            saveList(org.usecases, stream);
        }

        protected void loadUsecases(DataStream stream) {
            final DocumentImpl org = (DocumentImpl) getOriginator();
            org.usecases = loadList(stream, new MementoableFactory() {
                public Mementoable createOriginator() {
                    return (Mementoable) org.createUsecaseImpl();
                }
            });
        }

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

        protected DocumentImpl createDocumentImpl() {
            return new DocumentImpl();
        }
    }
}

---