getter or setter of the Semantic-UI variable
@param Semantic $semantic
@return Semantic
485995
public function semantic(Semantic $semantic=NULL) {
		if ($semantic!==NULL) {
			$this->_semantic=$semantic;
			$semantic->setJs($this);
			$ui=$this->ui();
			if (isset($ui)) {
				$this->conflict();
			}
		}
		return $this->_semantic;
	}
1301094
public function get($abstract)
    {
        /**
         * @todo validate that $abstract is a string
         */

        if (!isset($this->definitions[$abstract])) {

            $this->definitions[$abstract] = new Definition($this);
        }

        return $this->definitions[$abstract];
    }
577198
public function getRepository(string $name): RepositoryInterface
    {
        if (isset($this->repositories[$name])) {
            return $this->repositories[$name];
        }

        throw new \LogicException(sprintf('Unknown repository "%s"', $name));
    }
612019
protected function resolveGetter(\ReflectionProperty $property)
    {
        $name  = $property->getName();
        $class = $property->getDeclaringClass();

        foreach (['get', 'is'] as $prefix)
        {
            $getter = $prefix . ucfirst($name);

            if ($class->hasMethod($getter) && $class->getMethod($getter)->isPublic()) {
                return $getter;
            }
        }

        throw new \LogicException(sprintf(
            'Getter-method for the property "%s" cannot be resolved automatically. ' .
            'Probably there is no get%2$s() or is%2$s() method or it is not public.',
            $name, ucfirst($name)
        ));
    }
944652
public function setGenus(\Librinfo\VarietiesBundle\Entity\Genus $genus = null)
    {
        $this->genus = $genus;

        return $this;
    }
326498
public function setUri($uri)
	{
		if (filter_var($uri, FILTER_VALIDATE_URL)) {
			$this->uri = $uri;
		} else {
			throw new RuntimeException('Invalid URI setted.');
		}
		
		return $this;
	}
713901
public function getSet($root)
    {
        $child = ucfirst(AnInflector::pluralize($this->getChild()->name));
        $parent = $this->getJunctionAlias().'.'.$this->_child_key;
        $filters = $this->getQueryFilters();
        $filters['where'] = array($parent => $root);
        $options = array(
            'repository' => $this->getTargetRepository(),
            'query' => $filters,
            'root' => $root,
            'property' => $this->getChildKey(),
            'target_property' => $this->getTargetChildKey(),
            'child' => $this->getChildRepository(),
        );

        $set = AnService::get('anahita:domain.entityset.decorator.manytomany', $options);

        return $set;
    }
40588
function SemanticPopupDisplay(SemanticPopupDisplayLink)
  {
    return {

      restrict: 'A',

      scope: {
        /* Required */
        smPopupDisplay: '@',
        /* Optional */
        smPopupDisplaySettings: '=',
        smPopupDisplayOnInit: '=',
        /* Events */
        smPopupDisplayOnCreate: '=',
        smPopupDisplayOnRemove: '=',
        smPopupDisplayOnShow: '=',
        smPopupDisplayOnVisible: '=',
        smPopupDisplayOnHide: '=',
        smPopupDisplayOnHidden: '='
      },

      link: SemanticPopupDisplayLink
    };
  }
1271596
static private function getPropertyDef(string $property, Fedora $fedora): OntologyProperty {
        if (!isset(self::$cache[$property])) {
            self::$cache[$property] = new OntologyProperty($property, $fedora);
        }
        return self::$cache[$property];
    }
126103
public function setEnable($enable)
    {
        $properties = $this->getProperty();
        $properties['enable'] = (boolean) $enable;
        $this->getConfig()->setSection('bundle', $properties, true);

        return $this;
    }
755967
private function setNewVersionNumber()
  {
    $valid = false;
    while (!$valid)
    {
      echo "Enter new Semantic Version: ";

      $line               = fgets(STDIN);
      $this->myNewVersion = $this->validateSemanticVersion($line);
      $valid              = ($this->myNewVersion);

      if (!$valid)
      {
        $this->logInfo("%s is not a valid Semantic Version", trim($line, "\n"));
      }
    }
  }
308542
public function initializeNewContent($contentType, $language, $isLinkedToSite, $isStatusable)
    {
        if (true === $isStatusable) {
            $initialStatus = $this->statusRepository->findOneByInitial();
        } else {
            $initialStatus = $this->statusRepository->findOneByOutOfWorkflow();
        }

        $contentClass = $this->contentClass;
        /** @var ContentInterface $content */
        $content = new $contentClass();
        $content->setLanguage($language);
        $content->setSiteId($this->contextManager->getSiteId());
        $content->setContentType($contentType);
        $content->setLinkedToSite($isLinkedToSite);
        $content->setStatus($initialStatus);
        $content->setVersion($this->uniqueIdGenerator->generateUniqueId());
        $content->setCreatedBy($this->tokenStorage->getToken()->getUser()->getUsername());

        return $content;
    }
1043226
public function setDefinition($definition) {
        if ($definition instanceof Definition) {
            $this->definition = $definition;
        }
        else {
            $this->definition->setDefinition($definition);
        }

        $this->consoleDefinitionMerged = false;

        return $this;
    }
291717
public function setValue($value) {
		if(is_array($this->content)){
			foreach ($this->content as $i=>$content){
				if(is_string($content)){
					$this->content[$i]=$value;
					return $this;
				}
			}
		}
		$this->content=$value;
		return $this;
	}
514663
public function setValue($value)
	{
		$value = (int) $value;
		$value = parent::setValue($value);
		return $value;
	}
971841
public Concept setConceptForObjectInstance() throws SemanticModelException
    {
        Concept foundConcept = null;
        if (null != getObject() && getObject() instanceof Instance && null != subjectInstance)
        {
            SemanticAxiom semanticAxiom = subjectInstance.getConcept().semanticAxiom();
            if (semanticAxiom instanceof Concept)
            {
                Property foundProperty = ((Concept) semanticAxiom).getProperty(name);
                if (null != foundProperty && foundProperty.getObject() instanceof SemanticAxiom)
                {
                    SemanticAxiom axiomForPropertyObject = ((SemanticAxiom) foundProperty.getObject()).semanticAxiom();
                    if (axiomForPropertyObject instanceof Concept)
                    {
                        foundConcept = (Concept) axiomForPropertyObject;
                    }
                }
            }
            Instance objectInstance = (Instance) getObject();
            objectInstance.setConcept(foundConcept);
        }
        return foundConcept;
    }
1083250
public function setOptionalPolicy($value): self
    {
        if (!in_array($value, self::optionalPolicies(), true)) {
            throw new DomainException(sprintf(self::UNEXPECTED_POLICY, implode(', ', self::optionalPolicies())));
        }

        return $this->setAttribute('optionalPolicy', $value);
    }