Iterates through list articles and performs list view specific tasks:
- sets type of link which needs to be generated (Manufacturer link)
422008
protected function _processListArticles()
    {
        if ($articleList = $this->getArticleList()) {
            $linkType = $this->_getProductLinkType();
            $dynamicParameters = $this->getAddUrlParams();
            $seoParameters = $this->getAddSeoUrlParams();

            foreach ($articleList as $article) {
                /** @var \OxidEsales\Eshop\Application\Model\Article $article */
                $article->setLinkType($linkType);

                if ($dynamicParameters) {
                    $article->appendStdLink($dynamicParameters);
                }

                if ($seoParameters) {
                    $article->appendLink($seoParameters);
                }
            }
        }
    }
1102532
def _set_list_ids_from_xml_iter(self, xml, xmlpath, var):
        '''
        
        '''
        es = xml.iterfind(xmlpath)
        if es is not None:
            l = []
            for e in es:
                l.append( e.attrib['frameid'] )
            
            setattr(self, var, l)
75521
def _generate_list_skippers(self):
        

        container = self.parser.find(
            '#'
            + AccessibleNavigationImplementation.ID_CONTAINER_SKIPPERS
        ).first_result()
        html_list = None
        if container is None:
            local = self.parser.find('body').first_result()
            if local is not None:
                container = self.parser.create_element('div')
                container.set_attribute(
                    'id',
                    AccessibleNavigationImplementation.ID_CONTAINER_SKIPPERS
                )
                local.prepend_element(container)
        if container is not None:
            html_list = self.parser.find(container).find_children(
                'ul'
            ).first_result()
            if html_list is None:
                html_list = self.parser.create_element('ul')
                container.append_element(html_list)
        self.list_skippers_added = True

        return html_list
379158
protected function process()
    {

        // initialize the array for the links
        $artefacts = array();

        // load the link type mappings
        $linkTypes = $this->getLinkTypeMappings();

        // prepare the links for the found link types and merge the found artefacts
        foreach ($linkTypes as $linkTypeCode => $columns) {
            $artefacts = array_merge($artefacts, $this->prepareArtefacts($linkTypeCode, $columns));
        }

        // append the links to the subject
        $this->addArtefacts($artefacts);
    }
1372497
def linkify(self):
        
        for t_id in self.items:
            timeperiod = self.items[t_id]
            timeperiod.linkify(self)
581616
public function loadManufacturerList()
    {
        $oBaseObject = $this->getBaseObject();

        $sFieldList = $oBaseObject->getSelectFields();
        $sViewName = $oBaseObject->getViewName();
        $this->getBaseObject()->setShowArticleCnt($this->_blShowManufacturerArticleCnt);

        $sWhere = '';
        if (!$this->isAdmin()) {
            $sWhere = $oBaseObject->getSqlActiveSnippet();
            $sWhere = $sWhere ? " where $sWhere and " : ' where ';
            $sWhere .= "{$sViewName}.oxtitle != '' ";
        }

        $sSelect = "select {$sFieldList} from {$sViewName} {$sWhere} order by {$sViewName}.oxtitle";
        $this->selectString($sSelect);
    }
613522
private function appendPaginationLinks()
    {
        if (class_basename($this->models) == 'LengthAwarePaginator') {
            // This set of models was paginated.  Make it append our current view variables.
            $this->models->appends(Input::only(config('gbrock-tables.key_field'),
                config('gbrock-tables.key_direction')));
        }
    }
1000958
protected function _process()
	{
		$this->_msg( 'Adding product suggestion performance data', 0 );


		$productManager = MShop_Product_Manager_Factory::createManager( $this->_getContext() );
		$productListManager = $productManager->getSubManager( 'list' );
		$productListTypeManager = $productListManager->getSubManager( 'type' );

		$expr = array();
		$search = $productListTypeManager->createSearch();
		$expr[] = $search->compare('==', 'product.list.type.code', 'suggestion');
		$expr[] = $search->compare('==', 'product.list.type.domain', 'product');
		$search->setConditions( $search->combine( '&&', $expr ) );
		$types = $productListTypeManager->searchItems($search);

		if ( ($listTypeItem = reset($types)) === false) {
			throw new Exception('Product list type item not found');
		}

		$search = $productManager->createSearch();
		$search->setSortations( array( $search->sort( '+', 'product.id' ) ) );

		$refsearch = $productManager->createSearch();
		$refsearch->setSortations( array( $refsearch->sort( '+', 'product.id' ) ) );
		$refsearch->setSlice( 1 );

		$listItem = $productListManager->createItem();
		$listItem->setTypeId( $listTypeItem->getId() );
		$listItem->setDomain( 'product' );


		$this->_txBegin();

		$start = 0;

		do
		{
			$num = 0;

			$result = $productManager->searchItems( $search );
			$refresult = $productManager->searchItems( $refsearch );

			foreach( $result as $id => $product )
			{
				$pos = 0;
				$length = ( $num % 4 ) + 3;

				foreach( array_slice( $refresult, $num, $length, true ) as $refid => $refproduct )
				{
					$listItem->setId( null );
					$listItem->setParentId( $id );
					$listItem->setRefId( $refid );
					$listItem->setPosition( $pos++ );

					$productListManager->saveItem( $listItem, false );
				}

				$num++;
			}

			$count = count( $result );
			$start += $count;
			$search->setSlice( $start );
			$refsearch->setSlice( $start + 1 );
		}
		while( $count == $search->getSliceSize() );

		$this->_txCommit();


		$this->_status( 'done' );
	}
1289871
public function generateItems()
    {
        // Iterator for pagination pages.
        $j = 1;

        foreach ($this->getLinks() as $index => $link) {
            // Create new pagination item
            $item = new PaginationItem($link);

            // If we on first link and currently active page is not first,
            // we know that this link is for previous pagination item.
            if ($index === 0 && $this->currentPage != 1) {
                $this->markAsPrevious($item);

                continue;
            }

            // If we on last link and currently active page is not last,
            // we know that this link is for next pagination item.
            if (
                $index === $this->getLinksCount(true)
                && $this->currentPage != $this->getLinksCount(true)
            ) {
                $this->markAsNext($item);

                break;
            }

            // We can't use loop index, because sometimes first and
            // last link are for the next and previous item, so use
            // external iterator to index pages of pagination.
            $item->number = $j++;

            // Push pagination pages to items collection.
            $this->items[] = $item;
        }
    }
602570
def target_schema(link)
      if link.target_schema
        link.target_schema
      elsif legacy_hyper_schema_rel?(link)
        link.parent
      end
    end
371489
def generate_list_view(self):
        """"""

        name = model_class_form(self.model + 'ListView')
        list_args = dict(
            model=self.get_model_class,
            context_object_name=plural(self.model),
            template_name=self.get_template('list'),
            table_class=self.get_actual_table(),
            context_table_name='table_objects',
            crud=self.crud,
            permissions=self.view_permission('list'),
            permission_required=self.check_permission_required,
            login_required=self.check_login_required,
            table_pagination={'per_page': self.tables2_pagination or 10},
            custom_queryset=self.custom_queryset,
            custom_context=self.custom_context,
            custom_postfix_url=self.custom_postfix_url
        )

        list_class = type(
            name,
            (BaseListViewMixin, SingleTableView),
            list_args
        )
        self.classes[name] = list_class
        return list_class
349284
def initWithArticleUriWgtList(uriWgtList):
        
        q = QueryArticles()
        assert isinstance(uriWgtList, list), "uriList has to be a list of strings that represent article uris"
        q.queryParams = { "action": "getArticles", "articleUriWgtList": ",".join(uriWgtList) }
        return q
516497
protected function _seoSetManufacturerData()
    {
        // only when SEO id on and in front end
        if (\OxidEsales\Eshop\Core\Registry::getUtils()->seoIsActive() && !$this->isAdmin()) {
            $oEncoder = \OxidEsales\Eshop\Core\Registry::get(\OxidEsales\Eshop\Application\Model\SeoEncoderManufacturer::class);

            // preparing root manufacturer category
            if ($this->_oRoot) {
                $oEncoder->getManufacturerUrl($this->_oRoot);
            }

            // encoding manufacturer category
            foreach ($this as $sVndId => $value) {
                $oEncoder->getManufacturerUrl($this->_aArray[$sVndId]);
            }
        }
    }
598808
protected function process()
    {

        // process the link type attributes
        $productLinkAttribute = $this->getProductLinkAttributeByLinkTypeCodeAndAttributeCode($this->getValue(ColumnKeys::LINK_TYPE_CODE), $this->getValue(ColumnKeys::LINK_TYPE_ATTRIBUTE_CODE));

        // try to load the product link attribute
        $this->setProductLinkAttributeId($productLinkAttribute[MemberNames::PRODUCT_LINK_ATTRIBUTE_ID]);

        // load the link attribute data type
        $dataType = $productLinkAttribute[MemberNames::DATA_TYPE];

        // concatenate the initialize/persist method names
        $intializeMethod = sprintf('initializeProductLinkAttribute%s', $dataType);
        $persistMethod = sprintf('persistProductLinkAttribute%s', $dataType);

        // prepare, initialize and persist the product link attribute int entity
        $this->$persistMethod($this->$intializeMethod($this->prepareAttributes()));
    }
457138
public void setLink(Link link) {
		setHref(link.getHref());
		setHrefAbsolute(link.getHrefAbsolute());
		HttpParameters linkParams = link.getParams();
		if(linkParams != null) {
			for(Map.Entry<String,List<String>> entry : linkParams.getParameterMap().entrySet()) {
				String paramName = entry.getKey();
				for(String paramValue : entry.getValue()) {
					addParam(paramName, paramValue);
				}
			}
		}
		this.addLastModified = link.getAddLastModified();
		setHreflang(link.getHreflang());
		setRel(link.getRel());
		setType(link.getType());
		setMedia(link.getMedia());
		setTitle(link.getTitle());
	}
527185
@JsonProperty(value = "links")
    public void setLinks(List<PageRequestLinkDto> links) {
        if (links == null) {
            this.links = new ArrayList<>();
        } else {
            this.links = links;
        }
    }
1213412
def iter_links_style_element(self, element):
        ''''''
        if self.css_scraper and element.text:
            link_iter = self.css_scraper.scrape_links(element.text,
                                                      context=True)
            for link, context in link_iter:
                if context == 'import':
                    link_type = LinkType.css
                else:
                    link_type = LinkType.media

                yield LinkInfo(
                    element=element, tag=element.tag, attrib=None,
                    link=link,
                    inline=True, linked=False,
                    base_link=None,
                    value_type='css',
                    link_type=link_type
                )