next(self) -> Link
548264
def next(self):
        """"""
        CheckParent(self)

        val = _fitz.Link_next(self)

        if val:
            val.thisown = True
            val.parent = self.parent # copy owning page from prev link
            val.parent._annot_refs[id(val)] = val
            if self.xref > 0: # prev link has an xref
                link_xrefs = self.parent._getLinkXrefs()
                idx = link_xrefs.index(self.xref)
                val.xref = link_xrefs[idx + 1]
            else:
                val.xref = 0


        return val
642909
def get(self, url):
        # type: (str) -> List[Model]
        
        self.reset()
        self.next_link = url
        return self.advance_page()
315981
def next(self):
        
        if self.index < self.length:
            index = self.index
            self.index += 1
            return self.data[index]
        else:
            raise StopIteration()
1020370
def next(self):
        
        msg = cr.Message()
        msg.type = cr.NEXT
        self.send_message(msg)
130740
def next(self):
        '''  '''
        try:
            return self.__class__.objects.for_model(self.content_object,
                                                    self.content_type).\
                            filter(order__lt=self.order).order_by('-order')[0]
        except IndexError:
            return None
932689
def next_page(self):
        
        try:
            next_url = self.next_url
        except AttributeError:
            raise PageError("Page %r has no next page" % self)
        return self.page_for_url(next_url)
1346299
def setPrevUpNextLinks(self, prev=None, up=None, next=None):
        """"""
        if prev is not None:
            if prev:
                self._prev_link = quote_url(prev._relIndexLink())
                prev._next_link = quote_url(self._relIndexLink())
            else:
                self._prev_link = None
        if up is not None:
            self._up_link = up and quote_url(up)
        if next is not None:
            self._next_link = next and quote_url(next._relIndexLink())
836271
def next(self):
        """"""
        d = None
        if self._first_results:
            d = succeed(EsUtils.extract_hits(self._first_results))
            self._first_results = None
        elif self._scroll_id:
            d = self._scroll_next_results()
        else:
            raise StopIteration()
        return d
1247365
public final Link getNextLink() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(this, tc, "getNextLink", _positionString());
        }
        Link nextLink = null;
        LinkedList parent = _parent;
        if (null != parent) {
            nextLink = _parent.getNextLink(this);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(this, tc, "getNextLink", nextLink);
        }
        return nextLink;
    }
1158664
public final synchronized Link getNextLink(Link link)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getNextLink", link);

        Link nextLink = null;

        if (link == null)
        {
            nextLink = _dummyHead.getNextPhysicalLink();
        }
        else
        {
            // Defect 493652/PK59872
            // If the link provided is PhysicallyUnlinked then it is 
            // likely that another thread has removed it while our 
            // thread was inspecting it. In order to avoid stopping
            // in the middle of a find/removeFirstMatching search we
            // need to start from the beginning of the list again.
            if (link.isPhysicallyUnlinked())
            {
                nextLink = _dummyHead.getNextPhysicalLink();

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Current link is PhysicallyUnlinked so returning to beginning of list.");
            }
            else
            {
                nextLink = link.getNextPhysicalLink();
            }
        }

        while (nextLink != null && nextLink.isLogicallyUnlinked())
        {
            nextLink = nextLink.getNextPhysicalLink();
        }

        if (nextLink == _dummyTail)
        {
            nextLink = null;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getNextLink", nextLink);
        return nextLink;
    }
76569
def _link(self, next_worker, next_is_first=False):
        """"""

        lock = multiprocessing.Lock()
        next_worker._lock_prev_input = lock
        self._lock_next_input = lock
        lock.acquire()

        lock = multiprocessing.Lock()
        next_worker._lock_prev_output = lock
        self._lock_next_output = lock
        lock.acquire()

        # If the next worker is the first one, trigger it now.
        if next_is_first:
            self._lock_next_input.release()
            self._lock_next_output.release()
910068
def links(self):
        
        ass = self.xpath('//a')
        for a in ass:
            text = a.xpath('./text()').extract_first()
            url = a.xpath('./@href').extract_first()
            link = Link(text, url)
            yield link
154891
def links(self):
        
        links = Links()
        links["self"] = Link.for_(
            self._operation,
            self._ns,
            qs=self._page.to_items(),
            **self._context
        )
        return links
1123667
def next(self):
        
        line = self.buffer.readline()

        while line == '\n':       # Skip forward to the next line with content.
            line = self.buffer.readline()

        if line == '':            # End of file.
            self.at_eof = True
            return None, None

        match = re.match('([A-Z]{2}|[C][1])\W(.*)', line)
        if match is not None:
            self.current_tag, data = match.groups()
        else:
            self.current_tag = self.last_tag
            data = line.strip()
        return self.current_tag, _cast(data)
656702
def next(self):
        
        try:
            self.event, self.element = next(self.iterator)
            self.elementTag = clearTag(self.element.tag)
        except StopIteration:
            clearParsedElements(self.element)
            raise StopIteration
        return self.event, self.element, self.elementTag
632370
def next(self):
        
        if self.current_token == len(self.tokens):
            return None
        token = self.tokens[self.current_token]
        if token["type"] == "newline":
            self.line += 1
            self.line_start = token["start"]
        self.current_token += 1
        if token["type"] == "unknown":
            self.error("Unknown token")
        return token
13537
def next_page(self):
        
        for link in self.links:
            if link.rel.lower() == 'next':
                return self._load(link.href)
        raise PaginationError('No more entries.')