src/Entity/Bonnet.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\BonnetRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: BonnetRepository::class)]
  11. class Bonnet implements \Stringable
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column(type: 'integer')]
  16.     private $id;
  18.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  19.     private $name;
  21.     #[ORM\OneToMany(targetEntity: TableauMesure::class, mappedBy: 'bonnet')]
  22.     private $tableauMesures;
  24.     #[ORM\OneToMany(targetEntity: FicheControlePreserie::class, mappedBy: 'bonnet')]
  25.     private $ficheControlePreseries;
  27.     #[ORM\OneToMany(targetEntity: DonneeReference::class, mappedBy: 'bonnet')]
  28.     private $donneeReferences;
  30.     #[ORM\OneToMany(targetEntity: FicheQualite::class, mappedBy: 'bonnet')]
  31.     private $ficheQualites;
  33.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelierAuditeur::class, mappedBy: 'bonnet')]
  34.     private $ficheQualiteAtelierAuditeurs;
  36.     #[ORM\OneToMany(targetEntity: FicheQualiteAtelier::class, mappedBy: 'bonnet')]
  37.     private $ficheQualiteAteliers;
  39.     #[ORM\OneToMany(targetEntity: FicheQualiteCent::class, mappedBy: 'bonnet')]
  40.     private $ficheQualiteCents;
  42.     #[ORM\OneToMany(targetEntity: FicheReparation::class, mappedBy: 'bonnet')]
  43.     private $ficheReparations;
  45.     #[ORM\OneToMany(targetEntity: DerogationSynthese::class, mappedBy: 'bonnet')]
  46.     private $derogationSyntheses;
  48.     #[ORM\OneToMany(targetEntity: Derogation::class, mappedBy: 'bonnet')]
  49.     private $derogations;
  51.     #[ORM\OneToMany(targetEntity: Lancement::class, mappedBy: 'bonnet')]
  52.     private $lancements;
  54.     #[ORM\OneToMany(targetEntity: JdeCout::class, mappedBy: 'bonnet')]
  55.     private $jdeCouts;
  57.     public function __construct()
  58.     {
  59.         $this->tableauMesures = new ArrayCollection();
  60.         $this->ficheControlePreseries = new ArrayCollection();
  61.         $this->donneeReferences = new ArrayCollection();
  62.         $this->ficheQualites = new ArrayCollection();
  63.         $this->ficheQualiteAtelierAuditeurs = new ArrayCollection();
  64.         $this->ficheQualiteAteliers = new ArrayCollection();
  65.         $this->ficheQualiteCents = new ArrayCollection();
  66.         $this->ficheReparations = new ArrayCollection();
  67.         $this->derogationSyntheses = new ArrayCollection();
  68.         $this->derogations = new ArrayCollection();
  69.         $this->lancements = new ArrayCollection();
  70.         $this->jdeCouts = new ArrayCollection();
  71.     }
  73.     public function getId(): ?int
  74.     {
  75.         return $this->id;
  76.     }
  78.     public function getName(): ?string
  79.     {
  80.         return $this->name;
  81.     }
  83.     public function setName(?string $name): self
  84.     {
  85.         $this->name = $name;
  87.         return $this;
  88.     }
  90.     /**
  91.      * @return Collection|TableauMesure[]
  92.      */
  93.     public function getTableauMesures(): Collection
  94.     {
  95.         return $this->tableauMesures;
  96.     }
  98.     public function addTableauMesure(TableauMesure $tableauMesure): self
  99.     {
  100.         if (!$this->tableauMesures->contains($tableauMesure)) {
  101.             $this->tableauMesures[] = $tableauMesure;
  102.             $tableauMesure->setBonnet($this);
  103.         }
  105.         return $this;
  106.     }
  108.     public function removeTableauMesure(TableauMesure $tableauMesure): self
  109.     {
  110.         if ($this->tableauMesures->removeElement($tableauMesure)) {
  111.             // set the owning side to null (unless already changed)
  112.             if ($tableauMesure->getBonnet() === $this) {
  113.                 $tableauMesure->setBonnet(null);
  114.             }
  115.         }
  117.         return $this;
  118.     }
  119.     public function __toString(): string
  120.     {
  121.         return (string) $this->name;
  122.     }
  124.     /**
  125.      * @return Collection|FicheControlePreserie[]
  126.      */
  127.     public function getFicheControlePreseries(): Collection
  128.     {
  129.         return $this->ficheControlePreseries;
  130.     }
  132.     public function addFicheControlePreseries(FicheControlePreserie $ficheControlePreseries): self
  133.     {
  134.         if (!$this->ficheControlePreseries->contains($ficheControlePreseries)) {
  135.             $this->ficheControlePreseries[] = $ficheControlePreseries;
  136.             $ficheControlePreseries->setBonnet($this);
  137.         }
  139.         return $this;
  140.     }
  142.     public function removeFicheControlePreseries(FicheControlePreserie $ficheControlePreseries): self
  143.     {
  144.         if ($this->ficheControlePreseries->removeElement($ficheControlePreseries)) {
  145.             // set the owning side to null (unless already changed)
  146.             if ($ficheControlePreseries->getBonnet() === $this) {
  147.                 $ficheControlePreseries->setBonnet(null);
  148.             }
  149.         }
  151.         return $this;
  152.     }
  154.     /**
  155.      * @return Collection|DonneeReference[]
  156.      */
  157.     public function getDonneeReferences(): Collection
  158.     {
  159.         return $this->donneeReferences;
  160.     }
  162.     public function addDonneeReference(DonneeReference $donneeReference): self
  163.     {
  164.         if (!$this->donneeReferences->contains($donneeReference)) {
  165.             $this->donneeReferences[] = $donneeReference;
  166.             $donneeReference->setBonnet($this);
  167.         }
  169.         return $this;
  170.     }
  172.     public function removeDonneeReference(DonneeReference $donneeReference): self
  173.     {
  174.         if ($this->donneeReferences->removeElement($donneeReference)) {
  175.             // set the owning side to null (unless already changed)
  176.             if ($donneeReference->getBonnet() === $this) {
  177.                 $donneeReference->setBonnet(null);
  178.             }
  179.         }
  181.         return $this;
  182.     }
  184.     /**
  185.      * @return Collection|FicheQualite[]
  186.      */
  187.     public function getFicheQualites(): Collection
  188.     {
  189.         return $this->ficheQualites;
  190.     }
  192.     public function addFicheQualite(FicheQualite $ficheQualite): self
  193.     {
  194.         if (!$this->ficheQualites->contains($ficheQualite)) {
  195.             $this->ficheQualites[] = $ficheQualite;
  196.             $ficheQualite->setBonnet($this);
  197.         }
  199.         return $this;
  200.     }
  202.     public function removeFicheQualite(FicheQualite $ficheQualite): self
  203.     {
  204.         if ($this->ficheQualites->removeElement($ficheQualite)) {
  205.             // set the owning side to null (unless already changed)
  206.             if ($ficheQualite->getBonnet() === $this) {
  207.                 $ficheQualite->setBonnet(null);
  208.             }
  209.         }
  211.         return $this;
  212.     }
  214.     /**
  215.      * @return Collection|FicheQualiteAtelierAuditeur[]
  216.      */
  217.     public function getFicheQualiteAtelierAuditeurs(): Collection
  218.     {
  219.         return $this->ficheQualiteAtelierAuditeurs;
  220.     }
  222.     public function addFicheQualiteAtelierAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeur): self
  223.     {
  224.         if (!$this->ficheQualiteAtelierAuditeurs->contains($ficheQualiteAtelierAuditeur)) {
  225.             $this->ficheQualiteAtelierAuditeurs[] = $ficheQualiteAtelierAuditeur;
  226.             $ficheQualiteAtelierAuditeur->setBonnet($this);
  227.         }
  229.         return $this;
  230.     }
  232.     public function removeFicheQualiteAtelierAuditeur(FicheQualiteAtelierAuditeur $ficheQualiteAtelierAuditeur): self
  233.     {
  234.         if ($this->ficheQualiteAtelierAuditeurs->removeElement($ficheQualiteAtelierAuditeur)) {
  235.             // set the owning side to null (unless already changed)
  236.             if ($ficheQualiteAtelierAuditeur->getBonnet() === $this) {
  237.                 $ficheQualiteAtelierAuditeur->setBonnet(null);
  238.             }
  239.         }
  241.         return $this;
  242.     }
  244.     /**
  245.      * @return Collection|FicheQualiteAtelier[]
  246.      */
  247.     public function getFicheQualiteAteliers(): Collection
  248.     {
  249.         return $this->ficheQualiteAteliers;
  250.     }
  252.     public function addFicheQualiteAtelier(FicheQualiteAtelier $ficheQualiteAtelier): self
  253.     {
  254.         if (!$this->ficheQualiteAteliers->contains($ficheQualiteAtelier)) {
  255.             $this->ficheQualiteAteliers[] = $ficheQualiteAtelier;
  256.             $ficheQualiteAtelier->setBonnet($this);
  257.         }
  259.         return $this;
  260.     }
  262.     public function removeFicheQualiteAtelier(FicheQualiteAtelier $ficheQualiteAtelier): self
  263.     {
  264.         if ($this->ficheQualiteAteliers->removeElement($ficheQualiteAtelier)) {
  265.             // set the owning side to null (unless already changed)
  266.             if ($ficheQualiteAtelier->getBonnet() === $this) {
  267.                 $ficheQualiteAtelier->setBonnet(null);
  268.             }
  269.         }
  271.         return $this;
  272.     }
  274.     /**
  275.      * @return Collection|FicheQualiteCent[]
  276.      */
  277.     public function getFicheQualiteCents(): Collection
  278.     {
  279.         return $this->ficheQualiteCents;
  280.     }
  282.     public function addFicheQualiteCent(FicheQualiteCent $ficheQualiteCent): self
  283.     {
  284.         if (!$this->ficheQualiteCents->contains($ficheQualiteCent)) {
  285.             $this->ficheQualiteCents[] = $ficheQualiteCent;
  286.             $ficheQualiteCent->setBonnet($this);
  287.         }
  289.         return $this;
  290.     }
  292.     public function removeFicheQualiteCent(FicheQualiteCent $ficheQualiteCent): self
  293.     {
  294.         if ($this->ficheQualiteCents->removeElement($ficheQualiteCent)) {
  295.             // set the owning side to null (unless already changed)
  296.             if ($ficheQualiteCent->getBonnet() === $this) {
  297.                 $ficheQualiteCent->setBonnet(null);
  298.             }
  299.         }
  301.         return $this;
  302.     }
  304.     /**
  305.      * @return Collection<int, FicheReparation>
  306.      */
  307.     public function getFicheReparations(): Collection
  308.     {
  309.         return $this->ficheReparations;
  310.     }
  312.     public function addFicheReparation(FicheReparation $ficheReparation): self
  313.     {
  314.         if (!$this->ficheReparations->contains($ficheReparation)) {
  315.             $this->ficheReparations[] = $ficheReparation;
  316.             $ficheReparation->setBonnet($this);
  317.         }
  319.         return $this;
  320.     }
  322.     public function removeFicheReparation(FicheReparation $ficheReparation): self
  323.     {
  324.         if ($this->ficheReparations->removeElement($ficheReparation)) {
  325.             // set the owning side to null (unless already changed)
  326.             if ($ficheReparation->getBonnet() === $this) {
  327.                 $ficheReparation->setBonnet(null);
  328.             }
  329.         }
  331.         return $this;
  332.     }
  334.     /**
  335.      * @return Collection<int, DerogationSynthese>
  336.      */
  337.     public function getDerogationSyntheses(): Collection
  338.     {
  339.         return $this->derogationSyntheses;
  340.     }
  342.     public function addDerogationSynthesis(DerogationSynthese $derogationSynthesis): self
  343.     {
  344.         if (!$this->derogationSyntheses->contains($derogationSynthesis)) {
  345.             $this->derogationSyntheses[] = $derogationSynthesis;
  346.             $derogationSynthesis->setBonnet($this);
  347.         }
  349.         return $this;
  350.     }
  352.     public function removeDerogationSynthesis(DerogationSynthese $derogationSynthesis): self
  353.     {
  354.         if ($this->derogationSyntheses->removeElement($derogationSynthesis)) {
  355.             // set the owning side to null (unless already changed)
  356.             if ($derogationSynthesis->getBonnet() === $this) {
  357.                 $derogationSynthesis->setBonnet(null);
  358.             }
  359.         }
  361.         return $this;
  362.     }
  364.     /**
  365.      * @return Collection<int, Derogation>
  366.      */
  367.     public function getDerogations(): Collection
  368.     {
  369.         return $this->derogations;
  370.     }
  372.     public function addDerogation(Derogation $derogation): self
  373.     {
  374.         if (!$this->derogations->contains($derogation)) {
  375.             $this->derogations[] = $derogation;
  376.             $derogation->setBonnet($this);
  377.         }
  379.         return $this;
  380.     }
  382.     public function removeDerogation(Derogation $derogation): self
  383.     {
  384.         if ($this->derogations->removeElement($derogation)) {
  385.             // set the owning side to null (unless already changed)
  386.             if ($derogation->getBonnet() === $this) {
  387.                 $derogation->setBonnet(null);
  388.             }
  389.         }
  391.         return $this;
  392.     }
  394.     /**
  395.      * @return Collection<int, Lancement>
  396.      */
  397.     public function getLancements(): Collection
  398.     {
  399.         return $this->lancements;
  400.     }
  402.     public function addLancement(Lancement $lancement): self
  403.     {
  404.         if (!$this->lancements->contains($lancement)) {
  405.             $this->lancements[] = $lancement;
  406.             $lancement->setBonnet($this);
  407.         }
  409.         return $this;
  410.     }
  412.     public function removeLancement(Lancement $lancement): self
  413.     {
  414.         if ($this->lancements->removeElement($lancement)) {
  415.             // set the owning side to null (unless already changed)
  416.             if ($lancement->getBonnet() === $this) {
  417.                 $lancement->setBonnet(null);
  418.             }
  419.         }
  421.         return $this;
  422.     }
  424.     /**
  425.      * @return Collection<int, JdeCout>
  426.      */
  427.     public function getJdeCouts(): Collection
  428.     {
  429.         return $this->jdeCouts;
  430.     }
  432.     public function addJdeCout(JdeCout $jdeCout): self
  433.     {
  434.         if (!$this->jdeCouts->contains($jdeCout)) {
  435.             $this->jdeCouts[] = $jdeCout;
  436.             $jdeCout->setBonnet($this);
  437.         }
  439.         return $this;
  440.     }
  442.     public function removeJdeCout(JdeCout $jdeCout): self
  443.     {
  444.         if ($this->jdeCouts->removeElement($jdeCout)) {
  445.             // set the owning side to null (unless already changed)
  446.             if ($jdeCout->getBonnet() === $this) {
  447.                 $jdeCout->setBonnet(null);
  448.             }
  449.         }
  451.         return $this;
  452.     }
  453. }