Same as find but returns a list of all occurences
490238
def findAll(self, strSeq) :
		""""""
		arr = self.encode(strSeq)
		lst = []
                lst = self._kmp_find(arr[0], self, lst)
		return lst
472443
function find(datas, context) {
    if (!datas[0][0]) return [];
    var results = [],
      notNullResult = 0;

    for (var i = 0, len = datas.length; i < len; i++) {
      var data = datas[i],
        dlen = data.length,
        last = data[dlen - 1],
        result = getTargets(data, context);

      if (result && result.length) {notNullResult++;};
      if (!results) results = result;
      else results =results.concat(result);
    }
    clearNthPositionCache();//清理
    if (notNullResult > 1) uniqueSort(results);
    return results;
  }
751955
def FindRegex(self, regex, data):
    """"""
    for match in re.finditer(regex, data, flags=re.I | re.S | re.M):
      yield (match.start(), match.end())
1106007
def _find_multiple(self, match_class, **keywds):
        """"""
        self._logger.debug('find all query execution - started')
        start_time = timeit.default_timer()
        norm_keywds = self.__normalize_args(**keywds)
        decl_matcher = self.__create_matcher(match_class, **norm_keywds)
        dtype = self.__findout_decl_type(match_class, **norm_keywds)
        recursive_ = self.__findout_recursive(**norm_keywds)
        allow_empty = self.__findout_allow_empty(**norm_keywds)
        decls = self.__findout_range(norm_keywds['name'], dtype, recursive_)
        found = matcher.find(decl_matcher, decls, False)
        mfound = mdecl_wrapper.mdecl_wrapper_t(found)
        self._logger.debug('%d declaration(s) that match query', len(mfound))
        self._logger.debug(
            'find single query execution - done( %f seconds )',
            (timeit.default_timer() - start_time))
        if not mfound and not allow_empty:
            raise RuntimeError(
                "Multi declaration query returned 0 declarations.")
        return mfound
572196
def find_all(self, collection):
        
        obj = getattr(self.db, collection)
        result = obj.find()
        return result
210902
def list(self, relpattern):
        ""
        
        parent_path = os.path.dirname(relpattern)
        file_pattern = os.path.basename(relpattern)
        parent = self._resolve_path(parent_path)
        
        if parent is None:
            return []
        else:
            return [os.path.join(parent_path, name) 
                    for (name, mode, sha) in parent.iteritems() 
                    if fnmatch(name, file_pattern)]
466383
def findall(self, title=None):
        
        if title is None:
            return list(self._sheets)
        if title not in self._titles:
            return []
        return list(self._titles[title])
426761
function findAllIndices() {
  var needle = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : mandatory();
  var haystack = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : mandatory();

  var indices = [];
  for (var i = 0; i < haystack.length; i++) {
    if (haystack.substr(i, needle.length) === needle) {
      indices.push(i);
    }
  }

  if (indices.length) {
    return indices;
  } else {
    return -1;
  }
}
1238733
def find(self, chrom, start, end):
        """"""

        tree = self._trees.get( chrom, None )
        if tree:
            return tree.find( start, end )
        #return always a list
        return []
935826
def find(cls, *args, **kwargs):
        
        return list(cls.collection.find(*args, **kwargs))
341056
def _filter_occurrences(count, relat_op):
    """"""
    # Filter the occurrences equal (or not equal) to a given value
    if "eq" in relat_op:
        count = dfilter(lambda x: x == relat_op["eq"], count)
    elif "ne" in relat_op:
        count = dfilter(lambda x: x != relat_op["ne"], count)

    # Filter the occurrences lower (or equal) than a given value
    if "lt" in relat_op:
        count = dfilter(lambda x: x < relat_op["lt"], count)
    elif "le" in relat_op:
        count = dfilter(lambda x: x <= relat_op["le"], count)

    # Filter the occurrences greater (or equal) than a given value
    if "gt" in relat_op:
        count = dfilter(lambda x: x > relat_op["gt"], count)
    elif "ge" in relat_op:
        count = dfilter(lambda x: x >= relat_op["ge"], count)
    return count
1181751
def findall(self, title=None):
        
        if title is None:
            return list(self)
        files = backend.iterfiles(self._drive, name=title)
        return [self[id] for id, _ in files]
1292784
def find_all(self, cls):
        """"""
        final_results = []
        table = self.get_class_table(cls)
        for db_result in table.scan():
            obj = cls.from_data(db_result['value'])
            final_results.append(obj)

        return final_results
754755
def exact_find_in_pattern(fixed_text, cur=0, patterns=PATTERNS):
    """"""
    return [x for x in patterns if (cur + len(x['find']) <= len(fixed_text))
             and x['find'] == fixed_text[cur:(cur + len(x['find']))]]
198995
def find_commons(lists):
    
    others = lists[1:]
    return [
        val
        for val in lists[0]
        if is_in_all(val, others)
    ]
772948
def find_all(self, table, limit=10):
        '''
        
        '''
        sql = "select * from {} limit 0,{}".format(table, limit)
        res = self.query(sql)
        return res
587061
def doFind(self, WHAT={}, SORT=[], SKIP=None, MAX=None, LOP='AND', **params):
		""""""

		self._preFind(WHAT, SORT, SKIP, MAX, LOP)

		for key in params:
			self._addDBParam(key, params[key])

		try:
			return self._doAction('-find')
		except FMServerError as e:
			if e.args[0] in [401, 8]:
				return []