get all titles on site and return array of them
766042
def all_titles
      result = []
      @pages.each do |page|
        result << [page.page_url, page.all_titles] if page.page_a_tags
      end
      result
    end
109173
private function getArchiveFiles(): array {

        $list = [];

        for ( $i = 0; $i < $this->getArchive()->numFiles; $i++ ) {

            $file = $this->getArchive()->statIndex($i);
            if ( $file === false ) {
                continue;
            }

            $name = str_replace('\\', '/', $file['name']);
            if (
                (
                    $name[0] == "." &&
                    in_array($this->getSkipMode(), ["HIDDEN", "ALL"])
                ) ||
                (
                    $name[0] == "." &&
                    @$name[1] == "_" &&
                    in_array($this->getSkipMode(), ["COMODOJO", "ALL"])
                )
            ) {
                continue;
            }

            $list[] = $name;

        }

        return $list;

    }
987722
def _search_url_titles(self, title):
        
        # make the search
        logger.info('Searching title name for %r', title)
        r = self.session.get(self.server_url + 'subtitle/search/', params={'q': title}, timeout=10)
        r.raise_for_status()

        # check for redirections
        if r.history and all([h.status_code == 302 for h in r.history]):
            logger.debug('Redirected to the subtitles page')
            links = [r.url]
        else:
            # get the suggestions (if needed)
            soup = ParserBeautifulSoup(r.content, ['lxml', 'html.parser'])
            links = [link.attrs['href'] for link in soup.select('#processes div.generalWindowTop a')]
            logger.debug('Found %d suggestions', len(links))

        url_titles = defaultdict(list)
        for link in links:
            parts = link.split('/')
            url_titles[parts[-3]].append(parts[-2])

        return url_titles
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])
752524
public function getTitle()
    {
        if ($this->title === null) {
            $match = [];
            preg_match(self::$REGEX_TITLE, $this->output, $match);
            $this->title = array_key_exists(2, $match) ? trim($match[2]) : '';
        }

        return $this->title;
    }
615179
function fetch_all($result_type = SQLITE_BOTH) {
		$retn = array();
		while($item = $this->fetch_array()) {
			$retn[] = $item;
		}
		return $retn;
	}
760348
public function getListItems()
    {
        $item_arr = [];
        foreach ($this->items as $item)
        {
            $item_arr[$item->id] = $item->title;
        }
        return $item_arr;
    }
908808
def read
      site.collections.each_value do |collection|
        collection.read unless SPECIAL_COLLECTIONS.include?(collection.label)
      end
    end
198172
public function getAllTextItems()
    {
        $parameters = func_get_args();

        //set parameter values
        if (count($parameters) == 2) {
            $slideNumber = $parameters[0];
            $withEmpty = $parameters[1];
        }




        //Build URI to get all text items
        $strURI = Product::$baseProductUri . '/slides/' . $this->getFileName() .
            ((isset($parameters[0])) ? '/slides/' . $slideNumber . '/textItems?withEmpty=' . $withEmpty : '/textItems');

        $signedURI = Utils::sign($strURI);

        $responseStream = Utils::processCommand($signedURI, 'GET', '', '');

        $json = json_decode($responseStream);

        return $json->TextItems->Items;
    }
645689
public function getTitle()
    {
        $fields = $this->_fields;

        if (array_key_exists('title', $fields)) {
            return (string) $fields['title'];
        }

        $fieldNames = $this->getTitleColumnNames($this->contenttype);

        $title = [];
        foreach ($fieldNames as $fieldName) {
            // Make sure we add strings only, as some fields may be an array or DateTime.
            if (array_key_exists($fieldName, $fields)) {
                $title[] = is_array($fields[$fieldName]) ? implode(' ', $fields[$fieldName]) : (string) $fields[$fieldName];
            }
        }

        return implode(' ', $title);
    }
690772
def all_descriptions
      result = []
      @pages.each do |page|
        result << [page.page_url, page.meta_desc_content] if page.page_a_tags
      end
      result
    end
574187
function get()
    {
        $result = array();

        foreach ((array)$this->matches as $item) {
            if ($this->engine == 'pspell') {
                $word = $item[0];
            }
            else {
                $word = mb_substr($this->content, $item[1], $item[2], RCUBE_CHARSET);
            }

            if (is_array($item[4])) {
                $suggestions = $item[4];
            }
            else if (empty($item[4])) {
                $suggestions = array();
            }
            else {
                $suggestions = explode("\t", $item[4]);
            }

            $result[$word] = $suggestions;
        }

        return $result;
    }
528832
public function getTemplateList()
    {
        $templates = [];
        foreach ($this->storage->findTemplates() as $site) {
            $templates[$site->id] = $site->title;
        }

        return $templates;
    }
391138
public static function getRootPageList()
    {
        static $cache = null;

        if ($cache === null) {
            $query = 'SELECT uid,
                             pid,
                             title
                        FROM pages
                       WHERE is_siteroot = 1
                         AND deleted = 0';
            $cache = DatabaseUtility::getAllWithIndex($query, 'uid');
        }

        return $cache;
    }
513441
protected function extractTitles()
    {
        $result = [];
        $count = count($this->registries) - 1;
        for ($lot_id = 1; $lot_id < $count; $lot_id++) {
            $buffer = [];

            foreach ($this->registries[$lot_id][1] as $registry) {
                switch ($registry->getType()) {
                    case 'TITLE_T':
                        $data = [
                            'assignment' => $this->detectAssignment($registry)->id ?? null,
                            'our_number' => (int) $registry->our_number,
                            'value' => (float) ($registry->value / 100.0),
                            'tax' => (float) ($registry->tax / 100.0),
                            'due' => static::parseDate($registry->due),
                            'occurrence' => $this->occurrence($registry) ?? $registry->occurrence,
                        ];
                        $data['id'] = static::detectTitle($data);
                        break;

                    case 'TITLE_U':
                        $data = [
                            'value_received' => (float) ($registry->value_received / 100.0),
                            'occurrence_date' => static::parseDate($registry->occurrence_date),
                        ];
                        break;
                }

                $key = $registry->lot_registry;
                $buffer[$key] = array_merge($buffer[$key] ?? [], $data);
            }

            $result = array_merge($result, array_values($buffer));
        }

        return $result;
    }
1309736
def get_all(self, name, default=None):
        """"""
        if default is None:
            default = []
        return self._headers.get_list(name) or default
1242512
def get_titles():
    ''''''
    if os.name == 'posix':
        for proc in get_processes():
            cmd = ['xdotool','search','--name', proc]
            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            window_ids = proc.communicate()[0].decode('utf-8')
            if window_ids:
                for window_id in window_ids.split('\n'):
                    cmd = ['xdotool','getwindowname',window_id]
                    proc = subprocess.Popen(cmd,
                                        stdout=subprocess.PIPE,
                                        stderr=subprocess.PIPE)
                    title = proc.communicate()[0].decode('utf-8')
                    try:
                        if title[-1] == '\n':
                            title = title[:-1]
                        yield title
                    except IndexError:
                        pass
    else:
        raise NotImplementedError