Append a new path to all paths.

@param   string $appended Path to append.

@return  PathCollection  Return this object to support chaining.

@since  2.0
336895
public function appendAll($appended)
    {
        foreach ($this->storage as &$path) {
            $path->append($appended);
        }

        return $this;
    }
346558
public function addPluginPath($path, $prepend = false)
  {
    $paths = (is_array($path)) ? $path : array($path);

    foreach ( $paths as $pluginPath )
    {
      if ( $realPluginPath = realpath( $pluginPath ) )
      {
        if ( $prepend )
        {
          array_unshift( $this->pluginPaths, $realPluginPath );
        }
        else
        {
          $this->pluginPaths[] = $realPluginPath;
        }
      }
    }

    return $this;
  }
5599
public function add($prefix, $paths, $prepend = false) {
		if (!$prefix) {
			if ($prepend) {
				$this->fallbackDirs = array_merge(
					(array) $paths,
					$this->fallbackDirs
				);
			}
			else {
				$this->fallbackDirs = array_merge(
					$this->fallbackDirs,
					(array) $paths
				);
			}

			return;
		}

		if (!isset($this->prefixes[$prefix])) {
			$this->prefixes[$prefix] = (array) $paths;
			return;
		}

		if ($prepend) {
			$this->prefixes[$prefix] = array_merge(
				(array) $paths,
				$this->prefixes[$prefix]
			);
		}
		else {
			$this->prefixes[$prefix] = array_merge(
				$this->prefixes[$prefix],
				(array) $paths
			);
		}
	}
928312
public function append($fields)
    {
        if (is_array($fields)) {
            foreach ($fields as $key => $value) {
                $this->column($key, $value);
            }
        } else {
            foreach ($fields->fields() as $name) {
                $this->column($name, $fields->column($name));
            }
        }
        return $this;
    }
764278
public function append(Path $other)
    {
        if ($other === null) {
            return;
        }
        $l = $other->listPaths();
        foreach ($l as $path) {
            if (!in_array($path, $this->elements, true)) {
                $this->elements[] = $path;
            }
        }
    }
1327985
public function append(self $other) : self
    {
        $path = clone $this;
        $path->operations = array_merge($this->operations, $other->operations);
        return $path;
    }
477020
public function append($path)
    {
        //argument 1 must be a string
        $argument = Argument::i()->test(1, 'string');

        //each argument will be a path
        $paths = func_get_args();

        //for each path
        foreach ($paths as $i => $path) {
            //check for type errors
            $argument->test($i + 1, $path, 'string');
            //add to path
            $this->data .= $this->format($path);
        }

        return $this;
    }
225302
public function append($path) {
		if ($path instanceof Path) {
			$path = $path->getPathname();
		}
		
		if (!$this->hasTrailingSeparator()) {
			$this->addTrailingSeparator();
		}
		
		return new Path($this->getPathname()->append($path));
	}
398229
public function addAppends($appends)
	{
		if (is_string($appends)) {
			$appends = func_get_args();
		}

		$this->appends = array_merge($this->appends, $appends);

		return $this;
	}
49706
public function removeAppends($appends)
	{
		if (is_string($appends)) {
			$appends = func_get_args();
		}

		$this->appends = array_diff($this->appends, $appends);

		return $this;
	}
304245
public function append($path, $data)
	{
		if ($this->exists($path))
		{
			return $this->write($path, $this->read($path) . $data);
		}

		return $this->write($path, $data);
	}
216699
public function AppendExternal ($path = '', $async = FALSE, $defer = FALSE, $doNotMinify = FALSE) {
		return $this->Append($path, $async, $defer, $doNotMinify, TRUE);
	}
110987
public function appendHeaders(array $headers = [])
    {
        // Append headers.
        $this->headers = collect($this->headers)->merge($headers)->all();

        // Return calling object.
        return $this;
    }
995762
protected function insertIntoInternal($append)
    {
        $this->checkNode(false);
        if ($this->owner->{$this->keyAttribute} !== null) {
            $path = $this->convertPathFromPgToPhp($this->node->{$this->pathAttribute});
            $path[] = $this->node->{$this->keyAttribute};
            $this->owner->{$this->pathAttribute} = $this->convertPathFromPhpToPg($path);
        }
        if ($this->positionAttribute !== null) {
            $to = $this->node->getChildren()->orderBy(null);
            $to = $append ? $to->max($this->positionAttribute) : $to->min($this->positionAttribute);
            if (
                !$this->owner->getIsNewRecord() && (int)$to == $this->owner->{$this->positionAttribute}
                && !$this->owner->getDirtyAttributes([$this->pathAttribute])
            ) {
            } elseif ($to !== null) {
                $to += $append ? $this->step : -$this->step;
            } else {
                $to = 0;
            }
            $this->owner->{$this->positionAttribute} = $to;
        }
    }
862541
public function append($append = [], $override = false)
    {
        $this->append = $override ? $append : array_merge($this->append, $append);

        return $this;
    }
727334
public function append($options)
    {
        $options = self::unbox($options);

        if(is_array($options) || $options instanceof \Traversable)
        {
            foreach($options as $key => $value)
            {
                if(!is_numeric($key))
                {
                    if(array_key_exists($key, $this->__options))
                    {
                        if(!empty($value) && ($this->__options[$key] instanceof ObjectConfigInterface)) {
                            $this->__options[$key] = $this->__options[$key]->append($value);
                        }
                    }
                    else $this->set($key, $value);
                }
                else
                {
                    if (!in_array($value, $this->__options, true)) {
                        $this->__options[] = $value;
                    }
                }
            }
        }

        return $this;
    }
1098435
public function Append ($path = '', $async = FALSE, $defer = FALSE, $doNotMinify = FALSE, $external = FALSE) {
		$item = $this->_completeItem($path, $async, $defer, $doNotMinify, $external);
		$actialGroupItems = & $this->_getScriptsGroupContainer($this->actualGroupName);
		array_push($actialGroupItems, $item);
		return $this;
	}