luya\web\jsonld\EventTrait

Complexity

Total Complexity

54

Size/Duplication

Total Lines	614
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	0

Importance

Changes

0

54 Methods

Rating	Name	Duplication	Size	Complexity
A	getAbout()	0	4	1
A	setAbout()	0	5	1
A	getActor()	0	4	1
A	setActor()	0	5	1
A	getAttendee()	0	4	1
A	setAttendee()	0	5	1
A	getComposer()	0	4	1
A	setComposer()	0	5	1
A	getContributor()	0	4	1
A	setContributor()	0	5	1
A	getDirector()	0	4	1
A	setDirector()	0	5	1
A	getDoorTime()	0	4	1
A	setDoorTime()	0	5	1
A	getDuration()	0	4	1
A	setDuration()	0	5	1
A	getEndDate()	0	4	1
A	setEndDate()	0	5	1
A	getFunder()	0	4	1
A	setFunder()	0	5	1
A	getInLanguage()	0	4	1
A	setInLanguage()	0	5	1
A	isAccessibleForFree()	0	4	1
A	setIsAccessibleForFree()	0	5	1
A	getLocation()	0	4	1
A	setLocation()	0	5	1
A	getMaximumAttendeeCapacity()	0	4	1
A	setMaximumAttendeeCapacity()	0	4	1
A	getOrganizer()	0	4	1
A	setOrganizer()	0	5	1
A	getPerformer()	0	4	1
A	setPerformer()	0	5	1
A	getPreviousStartDate()	0	4	1
A	setPreviousStartDate()	0	5	1
A	getRecordedIn()	0	4	1
A	setRecordedIn()	0	5	1
A	getRemainingAttendeeCapacity()	0	4	1
A	setRemainingAttendeeCapacity()	0	5	1
A	getSponsor()	0	4	1
A	setSponsor()	0	5	1
A	getStartDate()	0	4	1
A	setStartDate()	0	5	1
A	getSubEvent()	0	4	1
A	setSubEvent()	0	4	1
A	getSuperEvent()	0	4	1
A	setSuperEvent()	0	5	1
A	getTranslator()	0	4	1
A	setTranslator()	0	5	1
A	getTypicalAgeRange()	0	4	1
A	setTypicalAgeRange()	0	5	1
A	getWorkFeatured()	0	4	1
A	setWorkFeatured()	0	5	1
A	getWorkPerformed()	0	4	1
A	setWorkPerformed()	0	5	1

<?php

namespace luya\web\jsonld;

/**
 * JsonLd - Event trait
 *
 * @see http://schema.org/Event
 *
 * @author Alex Schmid
 * @since 1.0.0
 */
trait EventTrait
{
    private $_about;

    /**
     * @return Thing
     */
    public function getAbout()
    {
        return $this->_about;
    }

    /**
     * The subject matter of the content.
     * Inverse property: subjectOf.
     *
     * @param Thing $about
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setAbout($about)
    {
        $this->_about = $about;
        return $this;
    }

    private $_actor;

    /**
     * @return Person
     */
    public function getActor()
    {
        return $this->_actor;
    }

    /**
     * An actor, e.g. in tv, radio, movie, video games etc., or in an event.
     * Actors can be associated with individual items or with a series, episode, clip. Supersedes actors.
     *
     * @param Person $actor
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setActor($actor)
    {
        $this->_actor = $actor;
        return $this;
    }

    private $_attendee;

    /**
     * @return Organization|Person
     */
    public function getAttendee()
    {
        return $this->_attendee;
    }

    /**
     * A person or organization attending the event. Supersedes attendees.
     *
     * @param Organization|Person $attendee
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setAttendee($attendee)
    {
        $this->_attendee = $attendee;
        return $this;
    }

    private $_composer;

    /**
     * @return Organization|Person
     */
    public function getComposer()
    {
        return $this->_composer;
    }

    /**
     * The person or organization who wrote a composition, or who is the composer of a work performed at some event.
     *
     * @param Organization|Person $composer
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setComposer($composer)
    {
        $this->_composer = $composer;
        return $this;
    }

    private $_contributor;

    /**
     * @return Organization|Person
     */
    public function getContributor()
    {
        return $this->_contributor;
    }

    /**
     * A secondary contributor to the CreativeWork or Event.
     *
     * @param Organization|Person $contributor
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setContributor($contributor)
    {
        $this->_contributor = $contributor;
        return $this;
    }

    private $_director;

    /**
     * @return Person
     */
    public function getDirector()
    {
        return $this->_director;
    }

    /**
     * A director of e.g. tv, radio, movie, video gaming etc. content, or of an event.
     * Directors can be associated with individual items or with a series, episode, clip.
     * Supersedes directors.
     *
     * @param Person $director
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setDirector($director)
    {
        $this->_director = $director;
        return $this;
    }

    private $_doorTime;

    /**
     * @return DateTime
     */
    public function getDoorTime()
    {
        return $this->_doorTime;
    }

    /**
     * The time admission will commence.
     *
     * @param DateTime $doorTime
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setDoorTime($doorTime)
    {
        $this->_doorTime = $doorTime;
        return $this;
    }

    private $_duration;

    /**
     * @return Duration
     */
    public function getDuration()
    {
        return $this->_duration;
    }

    /**
     * The duration of the item (movie, audio recording, event, etc.) in ISO 8601 date format.
     *
     * @param Duration $duration
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setDuration($duration)
    {
        $this->_duration = $duration;
        return $this;
    }

    private $_endDate;

    /**
     * @return Date|DateTime
     */
    public function getEndDate()
    {
        return $this->_endDate;
    }

    /**
     * The end date and time of the item (in ISO 8601 date format).
     *
     * @param Date|DateTime $endDate
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setEndDate($endDate)
    {
        $this->_endDate = $endDate;
        return $this;
    }

    private $_funder;

    /**
     * @return Organization|Person
     */
    public function getFunder()
    {
        return $this->_funder;
    }

    /**
     * A person or organization that supports (sponsors) something through some kind of financial contribution.
     *
     * @param Organization|Person $funder
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setFunder($funder)
    {
        $this->_funder = $funder;
        return $this;
    }

    private $_inLanguage;

    /**
     * @return Language|Text
     */
    public function getInLanguage()
    {
        return $this->_inLanguage;
    }

    /**
     * The language of the content or performance or used in an action.
     * Please use one of the language codes from the IETF BCP 47 standard. See also availableLanguage.
     * Supersedes language.
     *
     * @param Language|Text $inLanguage
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setInLanguage($inLanguage)
    {
        $this->_inLanguage = $inLanguage;
        return $this;
    }

    private $_isAccessibleForFree;

    /**
     * @return bool
     */
    public function isAccessibleForFree()
    {
        return $this->_isAccessibleForFree;
    }

    /**
     * A flag to signal that the item, event, or place is accessible for free. Supersedes free.
     *
     * @param bool $isAccessibleForFree
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setIsAccessibleForFree($isAccessibleForFree)
    {
        $this->_isAccessibleForFree = $isAccessibleForFree;
        return $this;
    }

    private $_location;

    /**
     * @return Place|PostalAddress|string
     */
    public function getLocation()
    {
        return $this->_location;
    }

    /**
     * The location of for example where the event is happening, an organization is located,
     * or where an action takes place.
     *
     * @param Place|PostalAddress|string $location
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setLocation($location)
    {
        $this->_location = $location;
        return $this;
    }

    private $_maximumAttendeeCapacity;

    /**
     * @return int
     */
    public function getMaximumAttendeeCapacity()
    {
        return $this->_maximumAttendeeCapacity;
    }

    /**
     * The total number of individuals that may attend an event or venue.
     *
     * @param int $maximumAttendeeCapacity
     */
    public function setMaximumAttendeeCapacity($maximumAttendeeCapacity)
    {
        $this->_maximumAttendeeCapacity = $maximumAttendeeCapacity;
    }

    private $_organizer;

    /**
     * @return Organization|Person
     */
    public function getOrganizer()
    {
        return $this->_organizer;
    }

    /**
     * An organizer of an Event.
     *
     * @param Organization|Person $organizer
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setOrganizer($organizer)
    {
        $this->_organizer = $organizer;
        return $this;
    }

    private $_performer;

    /**
     * @return Organization|Person
     */
    public function getPerformer()
    {
        return $this->_performer;
    }

    /**
     * A performer at the event—for example, a presenter, musician, musical group or actor.
     * Supersedes performers.
     *
     * @param Organization|Person $performer
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setPerformer($performer)
    {
        $this->_performer = $performer;
        return $this;
    }

    private $_previousStartDate;

    /**
     * @return string
     */
    public function getPreviousStartDate()
    {
        return $this->_previousStartDate;
    }

    /**
     * Used in conjunction with eventStatus for rescheduled or cancelled events.
     * This property contains the previously scheduled start date.
     * For rescheduled events, the startDate property should be used for the newly scheduled start date.
     * In the (rare) case of an event that has been postponed and rescheduled multiple times,
     * this field may be repeated.
     *
     * @param DateValue $previousStartDate
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setPreviousStartDate(DateValue $previousStartDate)
    {
        $this->_previousStartDate = $previousStartDate;
        return $this;
    }

    private $_recordedIn;

    /**
     * @return CreativeWork
     */
    public function getRecordedIn()
    {
        return $this->_recordedIn;
    }

    /**
     * The CreativeWork that captured all or part of this Event.
     * Inverse property: recordedAt
     *
     * @param CreativeWork $recordedIn
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setRecordedIn(CreativeWork $recordedIn)
    {
        $this->_recordedIn = $recordedIn;
        return $this;
    }

    private $_remainingAttendeeCapacity;

    /**
     * @return int
     */
    public function getRemainingAttendeeCapacity()
    {
        return $this->_remainingAttendeeCapacity;
    }

    /**
     * The number of attendee places for an event that remain unallocated.
     *
     * @param int $remainingAttendeeCapacity
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setRemainingAttendeeCapacity($remainingAttendeeCapacity)
    {
        $this->_remainingAttendeeCapacity = $remainingAttendeeCapacity;
        return $this;
    }

    private $_sponsor;

    /**
     * @return Organization|Person
     */
    public function getSponsor()
    {
        return $this->_sponsor;
    }

    /**
     * A person or organization that supports a thing through a pledge, promise, or financial contribution.
     * e.g. a sponsor of a Medical Study or a corporate sponsor of an event.
     *
     * @param Organization|Person $sponsor
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setSponsor($sponsor)
    {
        $this->_sponsor = $sponsor;
        return $this;
    }

    private $_startDate;

    /**
     * @return Date|DateTime
     */
    public function getStartDate()
    {
        return $this->_startDate;
    }

    /**
     * The start date and time of the item (in ISO 8601 date format).
     *
     * @param DateTimeValue $startDate
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setStartDate(DateTimeValue $startDate)
    {
        $this->_startDate = $startDate;
        return $this;
    }

    private $_subEvent;

    /**
     * @return Event
     */
    public function getSubEvent()
    {
        return $this->_subEvent;
    }

    /**
     * An Event that is part of this event.
     * For example, a conference event includes many presentations, each of which is a subEvent of the conference.
     * Supersedes subEvents.
     * Inverse property: superEvent.
     *
     * @param Event $subEvent
     */
    public function setSubEvent(Event $subEvent)
    {
        $this->_subEvent = $subEvent;
    }

    private $_superEvent;

    /**
     * @return Event
     */
    public function getSuperEvent()
    {
        return $this->_superEvent;
    }

    /**
     * An event that this event is a part of.
     * For example, a collection of individual music performances might each have a music festival as their superEvent.
     * Inverse property: subEvent.
     *
     * @param Event $superEvent
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setSuperEvent(Event $superEvent)
    {
        $this->_superEvent = $superEvent;
        return $this;
    }

    private $_translator;

    /**
     * @return Organization|Person
     */
    public function getTranslator()
    {
        return $this->_translator;
    }

    /**
     * Organization or person who adapts a creative work to different languages, regional differences
     * and technical requirements of a target market, or that translates during some event.
     *
     * @param Organization|Person $translator
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setTranslator($translator)
    {
        $this->_translator = $translator;
        return $this;
    }

    private $_typicalAgeRange;

    /**
     * @return string
     */
    public function getTypicalAgeRange()
    {
        return $this->_typicalAgeRange;
    }

    /**
     * The typical expected age range, e.g. '7-9', '11-'.
     *
     * @param string $typicalAgeRange
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setTypicalAgeRange($typicalAgeRange)
    {
        $this->_typicalAgeRange = $typicalAgeRange;
        return $this;
    }

    private $_workFeatured;

    /**
     * @return CreativeWork
     */
    public function getWorkFeatured()
    {
        return $this->_workFeatured;
    }

    /**
     * A work featured in some event, e.g. exhibited in an ExhibitionEvent.
     * Specific subproperties are available for workPerformed (e.g. a play),
     * or a workPresented (a Movie at a ScreeningEvent).
     *
     * @param CreativeWork $workFeatured
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setWorkFeatured(CreativeWork $workFeatured)
    {
        $this->_workFeatured = $workFeatured;
        return $this;
    }

    private $_workPerformed;

    /**
     * @return CreativeWork
     */
    public function getWorkPerformed()
    {
        return $this->_workPerformed;
    }

    /**
     * A work performed in some event, for example a play performed in a TheaterEvent.
     *
     * @param CreativeWork $workPerformed
     * @return EventTrait

The return type EventTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function setWorkPerformed(CreativeWork $workPerformed)
    {
        $this->_workPerformed = $workPerformed;
        return $this;
    }
}