/*This code was generated using the UMPLE modeling language!
 Date of generation: 2008/07/29 14:51:25*/
/*This class drives: MutualExclusionReason, MutualExclusionReason, PrerequisiteReason, PrerequisiteReason*/

package University.core;

import java.util.*;
import University.*;
import University.json.*;

public class Course {
  //Class datatypes

  //Class association variables
  private List<MutualExclusionReason> mutualyExclusiveFirstEnds;

  private List<MutualExclusionReason> mutualyExclusiveSecondEnds;

  private List<PrerequisiteReason> successorReasons;

  private List<PrerequisiteReason> prerequisiteReasons;

  //Registry of our system.
  UniversityRegistry registry = UniversityRegistry.getInstance();

  //Constructor
  public Course() {
    mutualyExclusiveFirstEnds = new ArrayList<MutualExclusionReason>();
    registry.add(mutualyExclusiveFirstEnds);

    mutualyExclusiveSecondEnds = new ArrayList<MutualExclusionReason>();
    registry.add(mutualyExclusiveSecondEnds);

    successorReasons = new ArrayList<PrerequisiteReason>();
    registry.add(successorReasons);

    prerequisiteReasons = new ArrayList<PrerequisiteReason>();
    registry.add(prerequisiteReasons);

  }

  public List<MutualExclusionReason> getMutualyExclusiveFirstEnds() {
    return mutualyExclusiveFirstEnds;
  }

  public List<MutualExclusionReason> getMutualyExclusiveSecondEnds() {
    return mutualyExclusiveSecondEnds;
  }

  public List<PrerequisiteReason> getSuccessorReasons() {
    return successorReasons;
  }

  public List<PrerequisiteReason> getPrerequisiteReasons() {
    return prerequisiteReasons;
  }

  public MutualExclusionReason addMutualyExclusiveFirstEnd() {
    MutualExclusionReason newMutualExclusionReason;
    newMutualExclusionReason = new MutualExclusionReason(this, this);
    if (!mutualyExclusiveFirstEnds.contains(newMutualExclusionReason)) {
      registry.add(newMutualExclusionReason);
      mutualyExclusiveFirstEnds.add(newMutualExclusionReason);
    }
    return newMutualExclusionReason;
  }

  public MutualExclusionReason addMutualyExclusiveFirstEnd(
    MutualExclusionReason aMutualyExclusiveFirstEnd) {
    if (!mutualyExclusiveFirstEnds.contains(aMutualyExclusiveFirstEnd))
      mutualyExclusiveFirstEnds.add(aMutualyExclusiveFirstEnd);
    return aMutualyExclusiveFirstEnd;
  }

  public MutualExclusionReason addMutualyExclusiveSecondEnd() {
    MutualExclusionReason newMutualExclusionReason;
    newMutualExclusionReason = new MutualExclusionReason(this, this);
    if (!mutualyExclusiveSecondEnds.contains(newMutualExclusionReason)) {
      registry.add(newMutualExclusionReason);
      mutualyExclusiveSecondEnds.add(newMutualExclusionReason);
    }
    return newMutualExclusionReason;
  }

  public MutualExclusionReason addMutualyExclusiveSecondEnd(
    MutualExclusionReason aMutualyExclusiveSecondEnd) {
    if (!mutualyExclusiveSecondEnds.contains(aMutualyExclusiveSecondEnd))
      mutualyExclusiveSecondEnds.add(aMutualyExclusiveSecondEnd);
    return aMutualyExclusiveSecondEnd;
  }

  public PrerequisiteReason addSuccessorReason() {
    PrerequisiteReason newPrerequisiteReason;
    newPrerequisiteReason = new PrerequisiteReason(this, this);
    if (!successorReasons.contains(newPrerequisiteReason)) {
      registry.add(newPrerequisiteReason);
      successorReasons.add(newPrerequisiteReason);
    }
    return newPrerequisiteReason;
  }

  public PrerequisiteReason addSuccessorReason(
    PrerequisiteReason aSuccessorReason) {
    if (!successorReasons.contains(aSuccessorReason))
      successorReasons.add(aSuccessorReason);
    return aSuccessorReason;
  }

  public PrerequisiteReason addPrerequisiteReason() {
    PrerequisiteReason newPrerequisiteReason;
    newPrerequisiteReason = new PrerequisiteReason(this, this);
    if (!prerequisiteReasons.contains(newPrerequisiteReason)) {
      registry.add(newPrerequisiteReason);
      prerequisiteReasons.add(newPrerequisiteReason);
    }
    return newPrerequisiteReason;
  }

  public PrerequisiteReason addPrerequisiteReason(
    PrerequisiteReason aPrerequisiteReason) {
    if (!prerequisiteReasons.contains(aPrerequisiteReason))
      prerequisiteReasons.add(aPrerequisiteReason);
    return aPrerequisiteReason;
  }

  public void delete() {
    //Delete all many ends first.
    for (MutualExclusionReason aMutualExclusionReason : mutualyExclusiveFirstEnds) {
      aMutualExclusionReason.delete();
    }
    mutualyExclusiveFirstEnds.clear();

    //Delete all many ends first.
    for (MutualExclusionReason aMutualExclusionReason : mutualyExclusiveSecondEnds) {
      aMutualExclusionReason.delete();
    }
    mutualyExclusiveSecondEnds.clear();

    //Delete all many ends first.
    for (PrerequisiteReason aPrerequisiteReason : successorReasons) {
      aPrerequisiteReason.delete();
    }
    successorReasons.clear();

    //Delete all many ends first.
    for (PrerequisiteReason aPrerequisiteReason : prerequisiteReasons) {
      aPrerequisiteReason.delete();
    }
    prerequisiteReasons.clear();

  }

  public void deleteMutualyExclusiveFirstEnd(
    MutualExclusionReason aMutualExclusionReason) {

    if (mutualyExclusiveFirstEnds.contains(aMutualExclusionReason)) {
      mutualyExclusiveFirstEnds.remove(aMutualExclusionReason);

      //registry.removeObj(registry.getKey(aMutualExclusionReason));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public void deleteMutualyExclusiveSecondEnd(
    MutualExclusionReason aMutualExclusionReason) {

    if (mutualyExclusiveSecondEnds.contains(aMutualExclusionReason)) {
      mutualyExclusiveSecondEnds.remove(aMutualExclusionReason);

      //registry.removeObj(registry.getKey(aMutualExclusionReason));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public void deleteSuccessorReason(PrerequisiteReason aPrerequisiteReason) {

    if (successorReasons.contains(aPrerequisiteReason)) {
      successorReasons.remove(aPrerequisiteReason);

      //registry.removeObj(registry.getKey(aPrerequisiteReason));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public void deletePrerequisiteReason(PrerequisiteReason aPrerequisiteReason) {

    if (prerequisiteReasons.contains(aPrerequisiteReason)) {
      prerequisiteReasons.remove(aPrerequisiteReason);

      //registry.removeObj(registry.getKey(aPrerequisiteReason));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public boolean areManyEndsNull() {
    if (mutualyExclusiveFirstEnds.size() == 0
      && mutualyExclusiveSecondEnds.size() == 0 && successorReasons.size() == 0
      && prerequisiteReasons.size() == 0) {
      return true;
    } else
      return false;
  }

  /***********************************
   * Returns the attribute list along with the  
   * class ID in JSON format.
   ***********************************/
  public JSONObject getAttributes() throws JSONException {
    JSONObject obj = new JSONObject();
    obj.put("CLASS_ID", registry.getKey(this));
    return obj;
  }

}