This function is provided for STL compatibility. It is equivalent to {@link append($value)}.

@param $value mixed
336782
public function push_back($value)
    {
        if ($this->isValidType($value) === false) {
            throw new MWrongTypeException("\$value", $this->getType(), $value);
        }

        $this->list[] = $value;
    }
354424
public function append($key, $value, $delimiter = ',')
    {
        $newValue = $value;
        if (isset($this->properties[$key]) && !empty($this->properties[$key])) {
            $newValue = $this->properties[$key] . $delimiter . $value;
        }
        $this->properties[$key] = $newValue;
    }
682814
public function add($value)
    {
        if (is_array($value)) {
            return $this->handleArray('add', $value);
        }
        if (is_null($value) || strlen($value) == 0) {
            return false;
        }
        if (false !== array_search($value, $this->values)) {
            return false;
        }
        $this->offsetSet(null, $value);
        return true;
    }
583482
public function add($value)
    {
        $mapping = $this->getMapping();

        $value = $this->getExpr()->value($value);
        $value->setMapping($mapping);

        return $this->getExpr()->addUpdate(new Add($this, $value));
    }
940325
public function pushValue($value)
    {
        $old = $this->value;
        if (!$this->stackable) {
            $this->setValue($value);
            return;
        }
        if (!is_array($this->value)) {
            $this->value = [$this->value, $value];
        } else {
            $f = false;
            foreach ($this->value as $k => $v) {
                if (!is_int($k)) {
                    $f = true;
                    break;
                }
            }
            if (!$f) {
                $this->value[] = $value;
            } else {
                $this->value = [$this->value, $value];
            }
        }
        $this->onUpdate($old);
    }
709296
public function append($value, $key = null): self
    {
        $this->generatorToArray();

        if ($key !== null) {
            if (
                isset($this->array[$key])
                &&
                \is_array($this->array[$key])
            ) {
                $this->array[$key][] = $value;
            } else {
                $this->array[$key] = $value;
            }
        } else {
            $this->array[] = $value;
        }

        return $this;
    }
306805
public function offsetSet($offset, $value)
	{
		if ($offset === null)
		{
			// $list[] = 'foo' maps to $list->append('foo')
			$this->append($value);
		}
		else
		{
			// Use the default implementation
			parent::offsetSet($offset, $value);
		}
	}
668754
public function append( $key, $value ) {

		if ( !$this->has( $key ) ) {
			$this->data[$key] = array();
		}

		if ( !is_array( $value ) ) {
			 $value = array( $value );
		}

		$this->data[$key] = array_merge(
			(array)$this->data[$key],
			$value
		);
	}
834355
function add($value) {
        if(!\in_array($value, $this->data, true)) {
            $this->data[] = $value;
        }
        
        return $this;
    }
894530
public function addInnList($value)
    {
        if ($this->InnList === null) {
            $this->InnList = new \Protobuf\ScalarCollection();
        }

        $this->InnList->add($value);
    }
1136191
public function writeVInt($value)
    {
        // We do not need to check if file position points to the end of "file".
        // Only append operation is supported now

        settype($value, 'integer');
        while ($value > 0x7F) {
            $this->_data .= chr(($value & 0x7F)|0x80);
            $value >>= 7;
        }
        $this->_data .= chr($value);

        $this->_position = strlen($this->_data);
    }
860692
public function setSlugAttribute($value)
    {
        array_set($this->attributes, $this->getSlugKey(), $this->makeSlug($value));
    }
1183006
protected function setValue($value)
    {
        if (!$this->validate($value)) {
            throw new \InvalidArgumentException(sprintf('%s is not a valid value', $value));
        }

        $this->value = $value;
    }
1057118
public function add($value)
    {
        if (! $this->checkType($value)) {
            throw new \UnexpectedValueException(
                sprintf(
                    self::$exceptionErrorMessage,
                    1,
                    __CLASS__,
                    'add',
                    $this->getType(),
                    $this->getItemType($value)
                )
            );
        }

        parent::add($value);

        return true;
    }
113818
public function addKeys($value)
    {
        if ($this->Keys === null) {
            $this->Keys = new \Protobuf\ScalarCollection();
        }

        $this->Keys->add($value);
    }
275401
public StrBuilder append(final boolean value) {
        if (value) {
            ensureCapacity(size + 4);
            buffer[size++] = 't';
            buffer[size++] = 'r';
            buffer[size++] = 'u';
            buffer[size++] = 'e';
        } else {
            ensureCapacity(size + 5);
            buffer[size++] = 'f';
            buffer[size++] = 'a';
            buffer[size++] = 'l';
            buffer[size++] = 's';
            buffer[size++] = 'e';
        }
        return this;
    }
1250224
public function setExpand($value)
    {
        $expand = StringHelper::booleanValue($value);
        if ($expand) {
            $this->flags = str_replace(' --style ' . $this->style, '', $this->flags);
            $this->flags .= ' --style expanded';
            $this->style = 'expanded';
        }
    }