Add functional pattern

        :param pattern:
        :type pattern:
        :return: self
        :rtype: Rebulk
355358
def functional(self, *pattern, **kwargs):
        
        self.pattern(self.build_functional(*pattern, **kwargs))
        return self
66141
def add_page(self, pattern, classname):
        
        if not self._loaded:
            raise PluginManagerNotLoadedException()
        self._app.add_mapping(pattern, classname)
920614
def pattern_with_glob_pattern(*pattern, **options)
      options[:uri_decode]    ||= false
      pattern                   = Mustermann.new(*pattern.flatten, **options)
      @glob_patterns          ||= {}
      @glob_patterns[pattern] ||= GlobPattern.generate(pattern)
      [pattern, @glob_patterns[pattern]]
    end
403684
def compile_pattern(self):
        
        if self.PATTERN is not None:
            PC = PatternCompiler()
            self.pattern, self.pattern_tree = PC.compile_pattern(self.PATTERN,
                                                                 with_tree=True)
1031970
def string(self, *pattern, **kwargs):
        
        self.pattern(self.build_string(*pattern, **kwargs))
        return self
637293
def _add_version_info(func):
		
		pattern = r'v(?P<source>\d+)_to_(?P<target>\d+)$'
		match = re.match(pattern, func.__name__)
		if not match:
			raise ValueError("migration function name must match " + pattern)
		func.source, func.target = map(int, match.groups())
286105
def regex(self, *pattern, **kwargs):
        
        self.pattern(self.build_re(*pattern, **kwargs))
        return self
681541
function addFiles(pattern, cb){
    glob(pattern, function(err, files){
      if(err) throw err;

      async.each(files, readFile, function(err){
        if(err) throw err;
        if(cb) cb();
      });
    });
  }
1262496
def addPattern(self, word, vector):
        
        if word in self.patterns:
            raise NetworkError('Pattern key already in use. Call delPattern to free key.', word)
        else:
            self.patterns[word] = vector
400295
def add(self, rule, method, target, name=None):
        '''  '''
        anons     = 0    # Number of anonymous wildcards found
        keys      = []   # Names of keys
        pattern   = ''   # Regular expression pattern with named groups
        filters   = []   # Lists of wildcard input filters
        builder   = []   # Data structure for the URL builder
        is_static = True

        for key, mode, conf in self._itertokens(rule):
            if mode:
                is_static = False
                if mode == 'default': mode = self.default_filter
                mask, in_filter, out_filter = self.filters[mode](conf)
                if not key:
                    pattern += '(?:%s)' % mask
                    key = 'anon%d' % anons
                    anons += 1
                else:
                    pattern += '(?P<%s>%s)' % (key, mask)
                    keys.append(key)
                if in_filter: filters.append((key, in_filter))
                builder.append((key, out_filter or str))
            elif key:
                pattern += re.escape(key)
                builder.append((None, key))

        self.builder[rule] = builder
        if name: self.builder[name] = builder

        if is_static and not self.strict_order:
            self.static.setdefault(method, {})
            self.static[method][self.build(rule)] = (target, None)
            return

        try:
            re_pattern = re.compile('^(%s)$' % pattern)
            re_match = re_pattern.match
        except re.error:
            raise RouteSyntaxError("Could not add Route: %s (%s)" % (rule, _e()))

        if filters:
            def getargs(path):
                url_args = re_match(path).groupdict()
                for name, wildcard_filter in filters:
                    try:
                        url_args[name] = wildcard_filter(url_args[name])
                    except ValueError:
                        raise HTTPError(400, 'Path has wrong format.')
                return url_args
        elif re_pattern.groupindex:
            def getargs(path):
                return re_match(path).groupdict()
        else:
            getargs = None

        flatpat = _re_flatten(pattern)
        whole_rule = (rule, flatpat, target, getargs)

        if (flatpat, method) in self._groups:
            if DEBUG:
                msg = 'Route <%s %s> overwrites a previously defined route'
                warnings.warn(msg % (method, rule), RuntimeWarning)
            self.dyna_routes[method][self._groups[flatpat, method]] = whole_rule
        else:
            self.dyna_routes.setdefault(method, []).append(whole_rule)
            self._groups[flatpat, method] = len(self.dyna_routes[method]) - 1

        self._compile(method)
186597
def refresh_token(self, pattern=KEY_PATTERN):
        
        self.token = generate_token(pattern)
        self.save()
487282
def PATTERN(self):
        
        """
        self.update_mapping()
        return u" |\n".join([pattern_unformatted % (f.name, f._pattern) for f in iter(self)])
273286
public void addInclude(PathPatternType pattern)
  {
    if (_includeList == null)
      _includeList = new ArrayList<PathPatternType>();

    _includeList.add(pattern);
  }
1208831
def resolve_pattern(pattern):
    ''''''
    if os.path.exists(pattern) and os.path.isdir(pattern):
        pattern = os.path.join(pattern, '**/*.bench.py')
    return recursive_glob(pattern)
1048471
@Deprecated
    public void setPattern(Pattern pattern) {
        patterns = new ArrayList<Pattern>(1);
        patterns.add(pattern);
    }
1059234
def register_function(self, patterns, instances=None, **reg_kwargs):
        """"""

        def wrapper(function):
            self.register(patterns, function, instances=instances, **reg_kwargs)
            return function

        return wrapper
285753
def build_functional(self, *pattern, **kwargs):
        
        set_defaults(self._functional_defaults, kwargs)
        set_defaults(self._defaults, kwargs)
        return FunctionalPattern(*pattern, **kwargs)