Add notation.

@param \Innova\CollecticielBundle\Entity\Notation $notation

@return Document
333979
public function addNotation(\Innova\CollecticielBundle\Entity\Notation $notation)
    {
        $this->notations[] = $notation;

        return $this;
    }
1342979
public function insert($document)
    {
        $class     = $this->dm->getClassMetadata(get_class($document));
        $changeset = $this->uow->getDocumentChangeSet($document);
        $qb        = $this->dm->createQueryBuilder($this->class->name);

        foreach ($class->propertyMetadata as $mapping) {
            $new = isset($changeset[$mapping->name][1]) ? $changeset[$mapping->name][1] : null;

            if (($new === null && !$mapping->nullable) || $mapping->isInverseSide) {
                continue;
            }

            if ($mapping->isMany()) {
                if ($mapping->strategy === PropertyMetadata::STORAGE_STRATEGY_ADD_TO_SET || $new->isEmpty()) {
                    continue;
                }

                $this->uow->unscheduleCollectionDeletion($new);
                $this->uow->unscheduleCollectionUpdate($new);
            }

            $qb->attr($mapping->name)->put($new);
        }

        //add a conditional preventing the resulting PutItem from overwriting
        //an existing record with the same primary key
        $class->createIdentifier($document)->addNotExistsToQueryCondition($qb->expr);

        $qb->getQuery()->execute();
    }
1236110
public function addCertification(\Librinfo\SeedBatchBundle\Entity\Certification $certifications)
    {
        $this->certifications[] = $certifications;

        return $this;
    }
841759
public function add(ExpressionContract $expression)
    {
        $this->checkType($expression);
        $this->constraints[$expression->name()] = $expression;
        return $this;
    }
481648
public function addAudience(string $audience): Builder
    {
        $audiences = $this->claims[Claims::AUDIENCE] ?? [];

        if (!\in_array($audience, $audiences)) {
            $audiences[] = $audience;
        }

        $this->claims[Claims::AUDIENCE] = $audiences;

        return $this;
    }
378233
public function addJs($asset)
    {
        return $this->addType(Assets::JS_COLLECTION, Assets::JS_TYPE, $asset, $this->unifyLegacyArguments(\func_get_args(), Assets::JS_TYPE));
    }
1240570
public function addDocument(\Innova\CollecticielBundle\Entity\Document $documents)
    {
        $this->documents[] = $documents;

        return $this;
    }
836404
public function add(DocumentInterface $document)
    {
        $this->documents[(string) $document->getIdentity()] = $document;

        return $this;
    }
951859
public function addSignatures(\AgentSIB\Diadoc\Api\Proto\Events\DocumentSignature $value)
    {
        if ($this->Signatures === null) {
            $this->Signatures = new \Protobuf\MessageCollection();
        }

        $this->Signatures->add($value);
    }
739471
public function addEntity($entity)
    {
        $this->collection[] = $entity;
        $this->setCount(count($this->collection));

        return $this;
    }
1318851
public function addExpression($expression)
    {
        if (!$this->expressions->contains($expression)) {
            $this->expressions[] = $expression;
        }

        return $this;
    }
186766
public function addCoordinate(Coordinate $coordinate)
    {
        $this->coordinates[] = $coordinate;
        $this->setNumber(count($this->coordinates));

        return $this;
    }
1113964
public function add(ExpressionContract $expression)
    {
        $this->typeCheck($expression);
        $this->applyRestrictions($expression);
        $this->_expressions[] = $expression;
        return $this;
    }
70074
private function parseEnumNotation($notation)
    {
        if (is_string($notation)) {
            $notation = json_decode(trim($notation, '<>'));

            if (json_last_error()) {
                return;
            }
        }

        return $notation;
    }
1107050
public function toCompliant($notation)
    {
        $chunks = explode(self::ROUTE_SYNTAX_SEPARATOR, $notation);

        // Save the action into a variable
        $action = $chunks[1];
        // Break what we have according to separators now
        $parts = explode(':', $chunks[0]);
        // Take a module and save it now
        $module = array_shift($parts);
        // It's time to build PSR-0 compliant path
        $path = sprintf('/%s/%s/%s', $module, self::ROUTE_CONTROLLER_DIR, implode('/', $parts));
        
        return array($path => $action);
    }
762230
public function addTosign($tosign)
    {
        if (!$this->getTosign()) {
            return $this->setTosign(array($tosign));
        } else {
            return $this->setTosign(
                array_merge($this->getTosign(), array($tosign))
            );
        }
    }
489004
public function addCondition(\Sulu\Bundle\ResourceBundle\Entity\Condition $conditions)
    {
        $this->conditions[] = $conditions;

        return $this;
    }