Get the next feed of the given feed.
 Return the first feed if no argument is passed.
 @param [Hatenablog::Feed] feed blog feed
 @return [Hatenablog::Feed] next blog feed
338075
def next_feed(feed = nil)
      return Feed.load_xml(get_collection(collection_uri).body) if feed.nil?
      return nil unless feed.has_next?
      Feed.load_xml(get_collection(feed.next_uri).body)
    end
1310795
def clean(feed: "Feed") -> "Feed":
    
    feed = feed.copy()
    ops = [
        "clean_ids",
        "clean_times",
        "clean_route_short_names",
        "drop_zombies",
    ]
    for op in ops:
        feed = globals()[op](feed)

    return feed
1249495
function feed_links( $args = array() ) {
		if ( !current_theme_supports('automatic-feed-links') )
			return;
		$defaults = array(
			/* translators: Separator between blog name and feed type in feed links */
			'separator'	=> _x('&raquo;', 'feed link'),
			/* translators: 1: blog title, 2: separator (raquo) */
			'feedtitle'	=> __('%1$s %2$s Feed'),
		);
		$args = wp_parse_args( $args, $defaults );
		echo '<link rel="alternate" type="' . feed_content_type() . '" title="' . esc_attr( sprintf( $args['feedtitle'], get_bloginfo('name'), $args['separator'] ) ) . '" href="' . esc_url( get_feed_link() ) . "\" />\n";
	}
339248
def blog_post_feed(request, format, **kwargs):
    
    try:
        return {"rss": PostsRSS, "atom": PostsAtom}[format](**kwargs)(request)
    except KeyError:
        raise Http404()
771464
def get_filtered_feed(self, feed_filter):
        
        assert isinstance(feed_filter, (UnreadFilter, FollowingFilter,
                                        FolderFilter))
        return self._rpc.filter_feed(**feed_filter.to_kwargs())
63072
def next_element
      element = next_sibling
      element = element.next_sibling until element.nil? or element.kind_of? Element 
      return element
    end
603864
def datafeed(self):
        
        import ns1.rest.data
        return ns1.rest.data.Feed(self.config)
136765
def blog__get_posts(
      order: nil,
      language: nil,
      category_permalink: nil,
      category_permalink_AND: false,
      category_id: nil,
      category_id_AND: false,
      tag_permalink: nil,
      tag_permalink_AND: false,
      tag_id: nil,
      tag_id_AND: false,
      search: nil,
      page: nil,
      per_page: nil
    )
      posts = LatoBlog::Post.published.joins(:post_parent).where('lato_blog_post_parents.publication_datetime <= ?', DateTime.now)

      # apply filters
      order = order && order == 'ASC' ? 'ASC' : 'DESC'
      posts = _posts_filter_by_order(posts, order)
      posts = _posts_filter_by_language(posts, language)
      if category_permalink || category_id
        posts = posts.joins(:categories)
        posts = _posts_filter_by_category_permalink(posts, category_permalink, category_permalink_AND)
        posts = _posts_filter_category_id(posts, category_id, category_id_AND)
      end
      if tag_permalink || tag_id
        posts = posts.joins(:tags)
        posts = _posts_filter_by_tag_permalink(posts, tag_permalink, tag_permalink_AND)
        posts = _posts_filter_tag_id(posts, tag_id, tag_id_AND)
      end
      posts = _posts_filter_search(posts, search)

      # take posts uniqueness
      posts = posts.uniq(&:id)

      # save total posts
      total = posts.length

      # manage pagination
      page = page&.to_i || 1
      per_page = per_page&.to_i || 20
      posts = core__paginate_array(posts, per_page, page)

      # return result
      {
        posts: posts && !posts.empty? ? posts.map(&:serialize) : [],
        page: page,
        per_page: per_page,
        order: order,
        total: total
      }
    end
30406
def next(self):
        
        try:
            child = self.children[self.pos]
            self.pos += 1
            return child
        except:
            raise StopIteration()
773426
def get_url(data_name, next_data_indices = {})
      if next_data_indices.empty?
        next_data_indices = { nextStartIndex: 0, nextLikeStartIndex: 0, nextThumbStartIndex: 0 }
      else
        next_data_indices = next_data_indices.dup
      end

      next_data_indices[:webname] = @webname
      next_data_indices[:pat] = Downloader.get_pat

      DATA_FEED_URLS[data_name] % next_data_indices
    end
158209
def next(self):
        
        next = request.args.get('next')
        if next is None:
            params = self.default_redirect_params
            next = url_for(self.default_redirect_endpoint, **params)
        return next
994469
def next(self):
        
        try:
            result = self.data[self.index]
        except IndexError:
            self.index = 0
            raise StopIteration
        self.index += 1
        return result
1161790
def neo_feed(start_date = Time.now.strftime('%Y-%m-%d'),
                 end_date = (Time.now + 604800).strftime('%Y-%m-%d'))
      request
        .neo
        .rest
        .v1('feed')
        .get(:params => { :api_key => @application_id.dup,
                          :start_date => start_date,
                          :end_date => end_date })
        .to_h
    end
668621
def feed(scope = :team, page = 0, comment = true)
      scope_param = case scope
        when :team
          "TEAM"
        when :extended_team
          "EXTM"
        when :department
          "DEPT"
        when :company
          "CMPY"
        else
          scope.to_s
      end
      get "/api/v1/feed", scope: scope_param, page: page, comment: comment
    end
1367168
def get_following(self):
        
        return github.PaginatedList.PaginatedList(
            NamedUser,
            self._requester,
            self.url + "/following",
            None
        )
1040991
def _next(self):
        
        c = self._get()
        if c == '/':
            p = self._peek()
            if p == '/':
                c = self._get()
                while c > '\n':
                    c = self._get()
                return c
            if p == '*':
                c = self._get()
                while 1:
                    c = self._get()
                    if c == '*':
                        if self._peek() == '/':
                            self._get()
                            return ' '
                    if c == '\000':
                        raise UnterminatedComment()

        return c
546771
def next(self, fetch: bool = False, next_symbol: _NextSymbol = DEFAULT_NEXT_SYMBOL) -> _Next:
        

        def get_next():
            candidates = self.find('a', containing=next_symbol)

            for candidate in candidates:
                if candidate.attrs.get('href'):
                    # Support 'next' rel (e.g. reddit).
                    if 'next' in candidate.attrs.get('rel', []):
                        return candidate.attrs['href']

                    # Support 'next' in classnames.
                    for _class in candidate.attrs.get('class', []):
                        if 'next' in _class:
                            return candidate.attrs['href']

                    if 'page' in candidate.attrs['href']:
                        return candidate.attrs['href']

            try:
                # Resort to the last candidate.
                return candidates[-1].attrs['href']
            except IndexError:
                return None

        __next = get_next()
        if __next:
            url = self._make_absolute(__next)
        else:
            return None

        if fetch:
            return self.session.get(url)
        else:
            return url