source: PSPA/Interface_Web/trunk/pspaWT/sources/controler/include/sector.h @ 474

#ifndef SECTOR_SEEN
#define SECTOR_SEEN

#include <vector>
#include <string>

#include "nomDeLogiciel.h"
#include "sectorParameters.h"
#include "particleBeam.h"


class sectionToExecute;
class abstractElement;
class dataManager;

class sector
{
  public :
  
  sector(dataManager*, std::string name = "sector default name");
  virtual ~sector();
  /**
   Set if this sector is reflected
   */
  inline void setReflected(bool r) { reflected_ = r;};
  /**
   Get if this sector is reflected
   */
  inline bool getReflected() { return reflected_;};

  /**
   Set the original sector from where this sector is reflected/duplicated
   */
  inline void setDuplicatedFrom(sector* s) { duplicatedFrom_ = s;};
  /**
   Get the original sector from where this sector is reflected/duplicated. Return NULL if not
   */
  inline sector* getDuplicatedFrom() { return duplicatedFrom_;};


  /**
   Set the repetition number
   */
  inline void setRepetitionNumber(unsigned int n) { repetitionNumber_ = n;};
  /**
   Get the repetition number
   */
  inline unsigned int getRepetitionNumber() { return repetitionNumber_;};

  /**
   Set the name
   */
  inline void setName(std::string name) { name_ = name;};
  /**
   Get the name
   */
  inline std::string getName() { return name_;};
  
  /**
   Return the vector of sectionToExecute of this
   */
  inline std::vector <sectionToExecute*> getSectionsToExecute() { return sectionToExecute_;};
  
  /**
   Add a sectionToExecute
   */
  inline void addSectionToExecute(sectionToExecute* s) {
    if (s) sectionToExecute_.push_back(s);
  };
  
  /** Add an element after another one. Will put it in the same sectionToExecuteList. If the element after is NULL
   it will create a new sectionToExecute and put it inside.
   if the previous element is NULL, it will try to add at the beginning of the first section
   */
  void addElementAfter(abstractElement*,abstractElement*);
  
  /** Add an element after another one. Will put it in the same sectionToExecuteList. If the element after is NULL
   it will create a new sectionToExecute and put it inside.
   if the previous element is NULL, it will try to add at the beginning of the first section
   @return : the new element
   */
  abstractElement* addElementAfter(nomdElements::typedElement, abstractElement* );

    /**
 set the specific software for the given sectionToExecute number
 */
  bool setSoftware(nomDeLogiciel, unsigned int sectionToExecuteNumber);

  void clearSectionToExecute();
  /** Clear a specific jobList */
  void clearSectionToExecute(int a);

  inline sectorParameters getSectorParameters() {
    return sectorParam_;
  }

  inline particleBeam* getParticleBeam() {
    return currentBeam_;
  }
  
  inline void setParticleBeam(particleBeam* part) {
    currentBeam_ = part;
  }
  
private:

  std::vector <sectionToExecute*> sectionToExecute_;
  particleBeam* currentBeam_;

  std::string name_;
  bool reflected_;
  sector* duplicatedFrom_;
  unsigned int repetitionNumber_;
  dataManager* dataManager_;
  sectorParameters sectorParam_; //xx
};
#endif