src/Entity/Navire.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\NavireRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=NavireRepository::class)
  12.  */
  13. class Navire
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", length=255, nullable=true)
  24.      */
  25.     private $titre;
  27.     /**
  28.      * @ORM\Column(type="text", nullable=true)
  29.      */
  30.     private $longdesc;
  32. //    /**
  33. //     * @ORM\ManyToOne(targetEntity=Technique::class, inversedBy="navire")
  34. //     * @ORM\JoinColumn(nullable=true)
  35. //     */
  36. //    private $technique;
  38.     /**
  39.      * @ORM\OneToMany(targetEntity=Pont::class, mappedBy="navire", orphanRemoval=true)
  40.      */
  41.     private $ponts;
  43.     /**
  44.      * @ORM\OneToMany(targetEntity=Imagesnavire::class, mappedBy="navire", orphanRemoval=true, cascade={"persist"})
  45.      */
  46.     private $imagesnavires;
  48.     /**
  49.      * @ORM\Column(type="text", nullable=true)
  50.      */
  51.     private $technique;
  53.     /**
  54.      * @ORM\OneToMany(targetEntity=Souscroisiere::class, mappedBy="navire")
  55.      */
  56.     private $souscroisiere;
  58.     public function __construct()
  59.     {
  60.         $this->ponts = new ArrayCollection();
  61.         $this->imagesnavires = new ArrayCollection();
  62.         $this->souscroisiere = new ArrayCollection();
  63.     }
  64.     public function __toString()
  65.     {
  66.         return (string) $this->titre;
  67.     }
  69.     public function getId(): ?int
  70.     {
  71.         return $this->id;
  72.     }
  74.     public function getTitre(): ?string
  75.     {
  76.         return $this->titre;
  77.     }
  79.     public function setTitre(?string $titre): self
  80.     {
  81.         $this->titre = $titre;
  83.         return $this;
  84.     }
  86.     public function getLongdesc(): ?string
  87.     {
  88.         return $this->longdesc;
  89.     }
  91.     public function setLongdesc(?string $longdesc): self
  92.     {
  93.         $this->longdesc = $longdesc;
  95.         return $this;
  96.     }
  98. //    public function getTechnique(): ?Technique
  99. //    {
  100. //        return $this->technique;
  101. //    }
  102. //
  103. //    public function setTechnique(?Technique $technique): self
  104. //    {
  105. //        $this->technique = $technique;
  106. //
  107. //        return $this;
  108. //    }
  110.     /**
  111.      * @return Collection<int, Pont>
  112.      */
  113.     public function getPonts(): Collection
  114.     {
  115.         return $this->ponts;
  116.     }
  118.     public function addPont(Pont $pont): self
  119.     {
  120.         if (!$this->ponts->contains($pont)) {
  121.             $this->ponts[] = $pont;
  122.             $pont->setNavire($this);
  123.         }
  125.         return $this;
  126.     }
  128.     public function removePont(Pont $pont): self
  129.     {
  130.         if ($this->ponts->removeElement($pont)) {
  131.             // set the owning side to null (unless already changed)
  132.             if ($pont->getNavire() === $this) {
  133.                 $pont->setNavire(null);
  134.             }
  135.         }
  137.         return $this;
  138.     }
  140.     /**
  141.      * @return Collection<int, Imagesnavire>
  142.      */
  143.     public function getImagesnavires(): Collection
  144.     {
  145.         return $this->imagesnavires;
  146.     }
  148.     public function addImagesnavire(Imagesnavire $imagesnavire): self
  149.     {
  150.         if (!$this->imagesnavires->contains($imagesnavire)) {
  151.             $this->imagesnavires[] = $imagesnavire;
  152.             $imagesnavire->setNavire($this);
  153.         }
  155.         return $this;
  156.     }
  158.     public function removeImagesnavire(Imagesnavire $imagesnavire): self
  159.     {
  160.         if ($this->imagesnavires->removeElement($imagesnavire)) {
  161.             // set the owning side to null (unless already changed)
  162.             if ($imagesnavire->getNavire() === $this) {
  163.                 $imagesnavire->setNavire(null);
  164.             }
  165.         }
  167.         return $this;
  168.     }
  170.     public function getTechnique(): ?string
  171.     {
  172.         return $this->technique;
  173.     }
  175.     public function setTechnique(?string $technique): self
  176.     {
  177.         $this->technique = $technique;
  179.         return $this;
  180.     }
  182.     /**
  183.      * @return Collection<int, Souscroisiere>
  184.      */
  185.     public function getSouscroisiere(): Collection
  186.     {
  187.         return $this->souscroisiere;
  188.     }
  190.     public function addSouscroisiere(Souscroisiere $souscroisiere): self
  191.     {
  192.         if (!$this->souscroisiere->contains($souscroisiere)) {
  193.             $this->souscroisiere[] = $souscroisiere;
  194.             $souscroisiere->setNavire($this);
  195.         }
  197.         return $this;
  198.     }
  200.     public function removeSouscroisiere(Souscroisiere $souscroisiere): self
  201.     {
  202.         if ($this->souscroisiere->removeElement($souscroisiere)) {
  203.             // set the owning side to null (unless already changed)
  204.             if ($souscroisiere->getNavire() === $this) {
  205.                 $souscroisiere->setNavire(null);
  206.             }
  207.         }
  209.         return $this;
  210.     }
  211. }