addMatcher
Add a new matcher to the stack.

@return self $this
547379
public function addMatcher(UrlMatcherInterface $matcher)
    {
        $this->debug(sprintf('addMatcher: Adding matcher %s', get_class($matcher)));
        $this->matchers->push($matcher);
        return($this);
    }
142742
public function add(\Caridea\Validate\Rule ...$rules): self
    {
        $this->rules = array_merge($this->rules, $rules);
        return $this;
    }
1308120
def _add_match(self, match):
        
        if self.__name_dict is not None:
            if match.name:
                _BaseMatches._base_add(self._name_dict[match.name], (match))
        if self.__tag_dict is not None:
            for tag in match.tags:
                _BaseMatches._base_add(self._tag_dict[tag], match)
        if self.__start_dict is not None:
            _BaseMatches._base_add(self._start_dict[match.start], match)
        if self.__end_dict is not None:
            _BaseMatches._base_add(self._end_dict[match.end], match)
        if self.__index_dict is not None:
            for index in range(*match.span):
                _BaseMatches._base_add(self._index_dict[index], match)
        if match.end > self._max_end:
            self._max_end = match.end
534662
public function makeSearch() 
    {
        $this->setSelect($this->qb);
        $this->setAssociations($this->qb);
        $this->setWhere($this->qb);
        $this->setOrderBy($this->qb);
        $this->setLimit($this->qb);

        return $this;
    }
1283337
def add_matching(pattern)
      FileList.glob(pattern).each do |fn|
        self << fn unless excluded_from_list?(fn)
      end
    end
1030708
public function getParsedMatcher()
    {
        $parsedMatcher = $this->matcher;
        // TODO: handle parameters that are not strings
        foreach ($this->parameters as $parameter) {
            $parsedMatcher = str_replace('{parameters.' . $parameter->getName() . '}', $parameter->getValue(), $parsedMatcher);
        }
        return $parsedMatcher;
    }
495591
public static function instance(): self
    {
        if (!self::$instance) {
            self::$instance = new self(AnyMatcher::instance(), 0, -1);
        }

        return self::$instance;
    }
655110
public function merge()
    {
        $cleaned_stack = $this->cleanStack($this->get(), 'path');
        if (!empty($cleaned_stack)) {
            $this->addMerged(
                $this->mergeStack($this->extractFromStack($cleaned_stack, 'path'))
            );
        }
        return $this;
    }
161624
public function addValidator($validator)
    {
        if (!($validator instanceof ValidatorInterface) && !is_callable($validator)) {
            $validator = ValidatorHelper::create($validator);
        }

        $this->validator->addValidator($validator);

        return $this;
    }
257593
public static Matcher newClass() {
    return new Matcher() {
      @Override public boolean matches(Node node, NodeMetadata metadata) {
        return node.isNew();
      }
    };
  }
794792
protected function addWhereConstraints()
    {
        parent::addWhereConstraints();

        $this->query->where($this->table.'.'.$this->morphType, $this->morphClass);

        return $this;
    }
219022
private function addItem()
    {
        $args = func_get_args();
        $this->items[$args[0]] = implode(':', array_slice($args, 1));

        return $this;
    }
882688
public function withNoArgs()
    {
        $this->expectation->setMatchesCallback(function($name, $args) {
            if ($name == $this->methodName && count($args) == 0) {
                return true;
            } else {
                return false;
            }
        });

        $this->commentBuilder->setArgs([]);
        
        return $this;
    }
51140
public function search()
	{
		preg_match_all('/\[[^\]]*\]/', $this->str, $this->matches);		

		// Format matches
		if(!empty($this->matches))
		{
			$this->matches = $this->matches[0];
			$this->format();
		}

		return $this;
	}
1333265
protected function addWhereConstraints()
    {
        $this->query->where(
            $this->getQualifiedForeignKeyName(), '=', $this->parent->getKey()
        );

        return $this;
    }
844816
protected function addMatched(string $name)
    {
        if (! isset($this->matched[$name])) {
            $this->matched[$name] = $this->newMiddleware($name);
        }
    }
658923
public function append(PatternParser $parser) : self
    {
        $this->pattern .= $parser->getPattern();
        $this->fields = \array_merge($this->fields, $parser->getFields());

        return $this;
    }