//-------------------------------------------------------------------------------
//  This package was automatically generated from EXPRESS (ISO STEP 10303 part11)
//  by a java generator build with the meta CASE tool Platypus 
//  (alain.plantec@univ-brest.fr)
// 
//  Please, be aware that any hand-made updating of this file can be lost!!. 
//-------------------------------------------------------------------------------

package CheddarBridge;
import java.util.*;
import step.core.*;
 
public class PartitionType extends ARINC_653_Object {
 
  private static String EntityName = "PARTITIONTYPE";
  private ArrayList<SamplingPortType> Sampling_Port_;
  private ArrayList<QueuingPortType> Queuing_Port_;
  private ArrayList<ProcessType> Process_;
  private ArrayList<PartitionExt_Type> PartitionExt_;
  private String PartitionIdentifier_;
  private String PartitionName_;
  private CriticalityType Criticality_;
  private Boolean SystemPartition_;
  private String EntryPoint_;

  public static String EntityName() { return EntityName; }
  public String entityName() { return EntityName(); }
  public boolean isInstanceOf(String entName) { return entName.equals(EntityName); }
  public boolean isKindOf(String entName) { return entName.equals(EntityName) ? true : super.isKindOf(entName); }

  public void initializeExplicitAttributes() {
    super.initializeExplicitAttributes();
    Sampling_Port_ = new ArrayList<SamplingPortType>();
    Queuing_Port_ = new ArrayList<QueuingPortType>();
    Process_ = new ArrayList<ProcessType>();
    PartitionExt_ = new ArrayList<PartitionExt_Type>();
    PartitionIdentifier_ = "";
    PartitionName_ = null;
    Criticality_ = CriticalityType.LEVEL_A;
    SystemPartition_ = false;
    EntryPoint_ = "";
  }

  public PartitionType () {
    initializeExplicitAttributes();
  }
  public PartitionType (step.core.StepCoreRepository _repo) {
    super(_repo);
    initializeExplicitAttributes();
  }
 
  public void setSamplingPort(ArrayList<SamplingPortType> _v) {
    if (_v == null) {
      Sampling_Port_ = null;
    } else {
      if (Sampling_Port_ == null) {
        Sampling_Port_ = new ArrayList<SamplingPortType>();
      } else {
        Sampling_Port_.clear();
      }
      Sampling_Port_.addAll(_v);
    }
  }
  public void samplingPortAdd (SamplingPortType _elem)  {
    if (Sampling_Port_ == null) {
      Sampling_Port_ = new ArrayList<SamplingPortType>();
    }
    Sampling_Port_.add(_elem);
  }
  public boolean samplingPortRemove(SamplingPortType _elem)  {
    if (Sampling_Port_ != null) {
      return Sampling_Port_.remove(_elem);
    }
    return false;
  }
  public boolean samplingPortRemoveAll(ArrayList<SamplingPortType> _v)  {
    if (Sampling_Port_ != null) {
      return Sampling_Port_.removeAll(_v);
    }
    return false;
  }
  public void samplingPortAddAll(ArrayList<SamplingPortType> _v)  {
    if (Sampling_Port_ == null) {
      Sampling_Port_ = new ArrayList<SamplingPortType>();
    }
    Sampling_Port_.addAll(_v);
  }
  public SamplingPortType  samplingPortSet (int _pos, SamplingPortType _elem)  {
    return Sampling_Port_.set(_pos, _elem);
  }
  public ArrayList<SamplingPortType> getSamplingPort() {
    return Sampling_Port_; 
  }
  public int samplingPortSize ()  {
    return Sampling_Port_ == null ?  0 : Sampling_Port_.size();
  }
  public SamplingPortType  samplingPortGet (int _pos)  {
    return Sampling_Port_.get(_pos);
  }
  public void setQueuingPort(ArrayList<QueuingPortType> _v) {
    if (_v == null) {
      Queuing_Port_ = null;
    } else {
      if (Queuing_Port_ == null) {
        Queuing_Port_ = new ArrayList<QueuingPortType>();
      } else {
        Queuing_Port_.clear();
      }
      Queuing_Port_.addAll(_v);
    }
  }
  public void queuingPortAdd (QueuingPortType _elem)  {
    if (Queuing_Port_ == null) {
      Queuing_Port_ = new ArrayList<QueuingPortType>();
    }
    Queuing_Port_.add(_elem);
  }
  public boolean queuingPortRemove(QueuingPortType _elem)  {
    if (Queuing_Port_ != null) {
      return Queuing_Port_.remove(_elem);
    }
    return false;
  }
  public boolean queuingPortRemoveAll(ArrayList<QueuingPortType> _v)  {
    if (Queuing_Port_ != null) {
      return Queuing_Port_.removeAll(_v);
    }
    return false;
  }
  public void queuingPortAddAll(ArrayList<QueuingPortType> _v)  {
    if (Queuing_Port_ == null) {
      Queuing_Port_ = new ArrayList<QueuingPortType>();
    }
    Queuing_Port_.addAll(_v);
  }
  public QueuingPortType  queuingPortSet (int _pos, QueuingPortType _elem)  {
    return Queuing_Port_.set(_pos, _elem);
  }
  public ArrayList<QueuingPortType> getQueuingPort() {
    return Queuing_Port_; 
  }
  public int queuingPortSize ()  {
    return Queuing_Port_ == null ?  0 : Queuing_Port_.size();
  }
  public QueuingPortType  queuingPortGet (int _pos)  {
    return Queuing_Port_.get(_pos);
  }
  public void setProcess(ArrayList<ProcessType> _v) {
    if (_v == null) {
      Process_ = null;
    } else {
      if (Process_ == null) {
        Process_ = new ArrayList<ProcessType>();
      } else {
        Process_.clear();
      }
      Process_.addAll(_v);
    }
  }
  public void processAdd (ProcessType _elem)  {
    if (Process_ == null) {
      Process_ = new ArrayList<ProcessType>();
    }
    Process_.add(_elem);
  }
  public boolean processRemove(ProcessType _elem)  {
    if (Process_ != null) {
      return Process_.remove(_elem);
    }
    return false;
  }
  public boolean processRemoveAll(ArrayList<ProcessType> _v)  {
    if (Process_ != null) {
      return Process_.removeAll(_v);
    }
    return false;
  }
  public void processAddAll(ArrayList<ProcessType> _v)  {
    if (Process_ == null) {
      Process_ = new ArrayList<ProcessType>();
    }
    Process_.addAll(_v);
  }
  public ProcessType  processSet (int _pos, ProcessType _elem)  {
    return Process_.set(_pos, _elem);
  }
  public ArrayList<ProcessType> getProcess() {
    return Process_; 
  }
  public int processSize ()  {
    return Process_ == null ?  0 : Process_.size();
  }
  public ProcessType  processGet (int _pos)  {
    return Process_.get(_pos);
  }
  public void setPartitionExt(ArrayList<PartitionExt_Type> _v) {
    if (_v == null) {
      PartitionExt_ = null;
    } else {
      if (PartitionExt_ == null) {
        PartitionExt_ = new ArrayList<PartitionExt_Type>();
      } else {
        PartitionExt_.clear();
      }
      PartitionExt_.addAll(_v);
    }
  }
  public void partitionExtAdd (PartitionExt_Type _elem)  {
    if (PartitionExt_ == null) {
      PartitionExt_ = new ArrayList<PartitionExt_Type>();
    }
    PartitionExt_.add(_elem);
  }
  public boolean partitionExtRemove(PartitionExt_Type _elem)  {
    if (PartitionExt_ != null) {
      return PartitionExt_.remove(_elem);
    }
    return false;
  }
  public boolean partitionExtRemoveAll(ArrayList<PartitionExt_Type> _v)  {
    if (PartitionExt_ != null) {
      return PartitionExt_.removeAll(_v);
    }
    return false;
  }
  public void partitionExtAddAll(ArrayList<PartitionExt_Type> _v)  {
    if (PartitionExt_ == null) {
      PartitionExt_ = new ArrayList<PartitionExt_Type>();
    }
    PartitionExt_.addAll(_v);
  }
  public PartitionExt_Type  partitionExtSet (int _pos, PartitionExt_Type _elem)  {
    return PartitionExt_.set(_pos, _elem);
  }
  public ArrayList<PartitionExt_Type> getPartitionExt() {
    return PartitionExt_; 
  }
  public int partitionExtSize ()  {
    return PartitionExt_ == null ?  0 : PartitionExt_.size();
  }
  public PartitionExt_Type  partitionExtGet (int _pos)  {
    return PartitionExt_.get(_pos);
  }
  public void setPartitionIdentifier ( String _v ) { PartitionIdentifier_ = _v; }
  public String getPartitionIdentifier() { return PartitionIdentifier_; }
  public void setPartitionName ( String _v ) { PartitionName_ = _v; }
  public String getPartitionName() { return PartitionName_; }
  public void setCriticality ( CriticalityType _v ) { Criticality_ = _v; }
  public CriticalityType getCriticality() { return Criticality_; }
  public void setSystemPartition ( Boolean _v ) { SystemPartition_ = _v; }
  public Boolean getSystemPartition() { return SystemPartition_; }
  public void setEntryPoint ( String _v ) { EntryPoint_ = _v; }
  public String getEntryPoint() { return EntryPoint_; }
  public void accept(CheddarBridge_AbstractVisitor visitor ) { visitor.accept((PartitionType) this); }
  public step.core.StepCoreObjectReaderWriter readerWriter() { return new PartitionTypeStepRW(); }

  public boolean replaceReferenceWith(StepCoreObject oldObj, StepCoreObject newObj) {
    boolean done = false;
    for (ListIterator<SamplingPortType> itori = getSamplingPort().listIterator(); itori.hasNext(); ) {
      if (itori.next() == oldObj ) {
        if (newObj == null) {
          itori.remove();
        } else {
          itori.set((SamplingPortType)newObj);
        }
        done = true;
      }
    }
    for (ListIterator<QueuingPortType> itori = getQueuingPort().listIterator(); itori.hasNext(); ) {
      if (itori.next() == oldObj ) {
        if (newObj == null) {
          itori.remove();
        } else {
          itori.set((QueuingPortType)newObj);
        }
        done = true;
      }
    }
    for (ListIterator<ProcessType> itori = getProcess().listIterator(); itori.hasNext(); ) {
      if (itori.next() == oldObj ) {
        if (newObj == null) {
          itori.remove();
        } else {
          itori.set((ProcessType)newObj);
        }
        done = true;
      }
    }
    for (ListIterator<PartitionExt_Type> itori = getPartitionExt().listIterator(); itori.hasNext(); ) {
      if (itori.next() == oldObj ) {
        if (newObj == null) {
          itori.remove();
        } else {
          itori.set((PartitionExt_Type)newObj);
        }
        done = true;
      }
    }
    if (super.replaceReferenceWith(oldObj, newObj)) {
      done = true;
    }
    return done;
  }
}