Append the contents of the other Path instance to this.

@param Path $other

@return void

@throws BuildException
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;
            }
        }
    }
164988
public function concat(Kwf_SourceMaps_SourceMap $other)
    {
        if ($this->_mappingsChanged) {
          $this->_generateMappings();
        }
        $missingLines = substr_count($this->_fileContents, "\n")-substr_count($this->_map->mappings, ";");
        if ($missingLines > 0) {
            $this->_map->mappings .= str_repeat(';', $missingLines);
        }
        if (!isset($this->_map->{'_x_org_koala-framework_last'})) {
            $this->_addLastExtension();
        }

        if (strlen($this->_fileContents) > 0) {
            if (substr($this->_fileContents, -1) != "\n") {
                $this->_fileContents .= "\n";
                $this->_map->mappings .= ';';
            }
        }

        $this->_fileContents .= $other->_fileContents;

        $data = $other->getMapContentsData();

        if ($this->_map->mappings) {
            $previousFileLast = $this->_map->{'_x_org_koala-framework_last'};
        } else {
            $previousFileLast = (object) array(
                'source' => 0,
                'originalLine' => 0,
                'originalColumn' => 0,
                'name' => 0,
            );
        }
        if (!$data->mappings) {
            $data->mappings = str_repeat(';', substr_count($other->_fileContents, "\n"));
            $data->{'_x_org_koala-framework_last'} = (object) array(
                'source' => -1,
                'originalLine' => $previousFileLast->originalLine,
                'originalColumn' => $previousFileLast->originalColumn,
                'name' => -1,
            );
        }
        $previousFileSourcesCount = count($this->_map->sources);
        $previousFileNamesCount = count($this->_map->names);
        if ($previousFileLast->source > $previousFileSourcesCount) {
            if ($previousFileSourcesCount != 0 && $previousFileLast->source != 0) {
                throw new Exception("Invalid last source, must not be higher than sources");
            }
        }

        if ($previousFileLast->name > $previousFileNamesCount) {
            if ($previousFileNamesCount != 0 && $previousFileLast->name != 0) {
                throw new Exception("Invalid last name, must not be higher than names");
            }
        }

        if ($data->sources) {
            foreach ($data->sources as $s) {
                $this->_map->sources[] = $s;
            }
        }
        if ($data->names) {
            foreach ($data->names as $n) {
                $this->_map->names[] = $n;
            }
        }

        $otherMappings = $data->mappings;

        $str = '';

        $otherMappingsEnd = strlen($otherMappings);
        $otherMappingsPos = 0;

        while ($otherMappingsPos < $otherMappingsEnd && $otherMappings[$otherMappingsPos] === ';') {
            $str .= $otherMappings[$otherMappingsPos];
            $otherMappingsPos++;
        }
        if ($otherMappingsPos < $otherMappingsEnd) {

            // Generated column.
            $str .= Kwf_SourceMaps_Base64VLQ::encode(Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos));
            if ($otherMappingsPos < $otherMappingsEnd && !($otherMappings[$otherMappingsPos] == ',' || $otherMappings[$otherMappingsPos] == ';')) {

                // Original source.
                $value = Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos);
                if ($previousFileSourcesCount) {
                    $absoluteValue = $value + $previousFileSourcesCount;
                    $value = $absoluteValue - $previousFileLast->source;
                }
                $str  .= Kwf_SourceMaps_Base64VLQ::encode($value);

                // Original line.
                $str  .= Kwf_SourceMaps_Base64VLQ::encode(Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos) - $previousFileLast->originalLine);

                // Original column.
                $str  .= Kwf_SourceMaps_Base64VLQ::encode(Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos) - $previousFileLast->originalColumn);

                // Original name.
                if ($otherMappingsPos < $otherMappingsEnd && !($otherMappings[$otherMappingsPos] == ',' || $otherMappings[$otherMappingsPos] == ';')) {
                    $value = Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos);
                    if ($previousFileNamesCount) {
                        $absoluteValue = $value + $previousFileNamesCount;
                        $value = $absoluteValue - $previousFileLast->name;
                    }
                    $str .= Kwf_SourceMaps_Base64VLQ::encode($value);
                } else if (!count($data->names)) {
                    //file doesn't have names at all, we don't have to adjust that offset
                } else {
                    //loop thru mappings until we find a block with name
                    while ($otherMappingsPos < $otherMappingsEnd) {
                        if ($otherMappings[$otherMappingsPos] === ';') {
                            $str .= $otherMappings[$otherMappingsPos];
                            $otherMappingsPos++;
                        } else if ($otherMappings[$otherMappingsPos] === ',') {
                            $str .= $otherMappings[$otherMappingsPos];
                            $otherMappingsPos++;
                        } else {
                            // Generated column.
                            $str .= Kwf_SourceMaps_Base64VLQ::encode(Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos));

                            if ($otherMappingsPos < $otherMappingsEnd && !($otherMappings[$otherMappingsPos] == ',' || $otherMappings[$otherMappingsPos] == ';')) {
                                // Original source.
                                $str .= Kwf_SourceMaps_Base64VLQ::encode(Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos));

                                // Original line.
                                $str .= Kwf_SourceMaps_Base64VLQ::encode(Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos));

                                // Original column.
                                $str .= Kwf_SourceMaps_Base64VLQ::encode(Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos));

                                if ($otherMappingsPos < $otherMappingsEnd && !($otherMappings[$otherMappingsPos] == ',' || $otherMappings[$otherMappingsPos] == ';')) {
                                    // Original name.
                                    $value = Kwf_SourceMaps_Base64VLQ::decodePos($otherMappings, $otherMappingsPos);
                                    if ($previousFileNamesCount) {
                                        $absoluteValue = $value + $previousFileNamesCount;
                                        $value = $absoluteValue - $previousFileLast->name;
                                    }
                                    $str .= Kwf_SourceMaps_Base64VLQ::encode($value);
                                    break;
                                }
                            }
                        }
                    }
                }
            }

        }

        $this->_map->mappings .= $str.substr($otherMappings, $otherMappingsPos);

        $this->_map->{'_x_org_koala-framework_last'} = (object) array(
            'source' => $previousFileSourcesCount + $data->{'_x_org_koala-framework_last'}->source,
            'name' => $previousFileNamesCount + $data->{'_x_org_koala-framework_last'}->name,
            'originalLine' => $data->{'_x_org_koala-framework_last'}->originalLine,
            'originalColumn' => $data->{'_x_org_koala-framework_last'}->originalColumn
        );
    }
763426
public function merge(self $other)
    {
        $new      = clone $this;
        $newWhere = $new->select->where;
        
        foreach ($other->select->where->getPredicates() as $pData) {
            $newWhere->addPredicate($pData[1], $pData[0]);
        }
        
        return $new;
    }
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;
        }
    }
585815
protected static function append($path)
	{

		if (is_dir($path))
		{

			$env = (is_admin()) ? 'admin' : 'front';

			// from common path
			static::requireFiles($path);

			// from environment path
			static::requireFiles($path."/{$env}");


			return true;

		}

		return false;

	}
907273
def add_path(self, path):
        
        abspath = os.path.abspath(path)
        self.children.append(_build_project_tree(abspath, self.followsymlinks, self.file_filter))
1022397
public function append($path, $data)
    {
        return $this->filesystem->append(
            $this->path($path),
            $data
        );
    }
1023803
private function addPath($path)
    {
        $path = $this->resolvePath($path);

        if ($this->validatePath($path)) {
            $this->paths[] = $path;
        }

        return $this;
    }
377259
public function add(Path $path) {
		$this->paths->set($path->getPath(), $path);
		return $this;
	}
979243
public function addViewPath($path)
    {
        $this->viewPath = (array) $this->viewPath;

        if (is_array($path)) {
            $this->viewPath = array_merge($path, $this->viewPath);
        }
        else {
            array_unshift($this->viewPath, $path);
        }
    }
1294527
public function add(string $path, array $values): void
    {
        $get = (array)$this->get($path);
        $this->set($path, $this->arrayMergeRecursiveDistinct($get, $values));
    }
241516
protected function addProperty($path)
    {
        $parts = explode('.', $path);
        $item = array_pop($parts);

        $nested = &$this->nested;
        foreach ($parts as $part) {
            if (!isset($nested[$part]) || !\is_array($nested[$part])) {
                $nested[$part] = [];
            }

            $nested = &$nested[$part];
        }

        if (!isset($nested[$item])) {
            $nested[$item] = $path;
        }
    }
1366965
public function addPath($path)
    {
        $paths = (array) $path;
        foreach ($paths as $path) {
            $this->paths[] = rtrim($path, "\\/") . DIRECTORY_SEPARATOR;
        }
    }
286790
public function addRoutesFile(string $path)
    {
        $datas = yaml_parse_file($path);

        $this->addRoutes($this->parseRoutesFiles($datas));
    }
400996
public function add(self $other): self
    {
        return self::from($this->value + $other->value);
    }
836831
public function append($other, $p)
    {
        if ($this->isReference()) {
            throw new BuildException("Cannot append to a reference");
        }

        $incl = $other->getIncludePatterns($p);
        if ($incl !== null) {
            foreach ($incl as $incl_name) {
                $o = $this->createInclude();
                $o->setName($incl_name);
            }
        }

        $excl = $other->getExcludePatterns($p);
        if ($excl !== null) {
            foreach ($excl as $excl_name) {
                $o = $this->createExclude();
                $o->setName($excl_name);
            }
        }
    }
661645
public function append(string ...$parts): self
    {
        array_unshift($parts, $this->path);

        return self::make(...$parts);
    }