Gets the set of all pages this node directly links to; this does not
include pages linked to by child elements.
506600
public Set<PageRef> getPageLinks() {
		synchronized(lock) {
			if(pageLinks == null) return Collections.emptySet();
			if(frozen) return pageLinks;
			return AoCollections.unmodifiableCopySet(pageLinks);
		}
	}
343572
@SuppressWarnings("unchecked")
	public Set<OGraphVertex> browseInEdgesVertexes() {
		final Set<OGraphVertex> resultset = new HashSet<OGraphVertex>();

		Set<OGraphEdge> temp = in != null ? in.get() : null;

		if (temp == null) {
			final Set<ODocument> docEdges = (Set<ODocument>) document.field(OGraphDatabase.VERTEX_FIELD_IN);

			// TRANSFORM ALL THE EDGES
			if (docEdges != null)
				for (ODocument d : docEdges) {
					resultset.add((OGraphVertex) database.getUserObjectByRecord((ODocument) d.field(OGraphDatabase.EDGE_FIELD_OUT), null));
				}
		} else {
			for (OGraphEdge edge : temp) {
				resultset.add(edge.getOut());
			}
		}

		return resultset;
	}
428162
def pages(self):
        
        # protected access has to be permitted here to not close the paginator's pages

        # pylint: disable=protected-access
        paginator_pages = list(self.paginator._pages)
        if len(self.paginator._current_page) > 1:
            paginator_pages.append('\n'.join(self.paginator._current_page) + '\n' + (self.paginator.suffix or ''))
        # pylint: enable=protected-access

        return paginator_pages
784021
def _get_page_elements(self):
        
        page_elements = []
        for attribute, value in list(self.__dict__.items()) + list(self.__class__.__dict__.items()):
            if attribute != 'parent' and isinstance(value, CommonObject):
                page_elements.append(value)
        return page_elements
39589
def getPeers(self):
        '''
            
        '''
        parentNode = self.parentNode
        # If no parent, no peers
        if not parentNode:
            return None

        peers = parentNode.children

        # Otherwise, get all children of parent excluding this node
        return TagCollection([peer for peer in peers if peer is not self])
1151697
protected List<String> getPages() {

        if (m_pages == null) {
            m_pages = Arrays.asList(getPageArray());
        }
        return m_pages;
    }
726864
def all_original_children(self):
        ''''''
        return chain.from_iterable(
            c.all_nodes_in_subtree()
            for lnk, c in self.children
            if lnk == self.LINK_CHILD)
702853
def get_pages(self, label=None):
        """"""
        return (
            page for page in sorted(
                self._pages.values(), key=lambda i: i.created, reverse=True
            ) if ((not label or label in page.labels) and page.visible)
        )
579888
def list_sets(self, project, **filters):
        """"""
        url = URL.articlesets.format(**locals())
        return self.get_pages(url, **filters)
416545
public TreeSet<String> getAllRelations() {
		TreeSet<String> set = new TreeSet<String>(); 
		Iterator<FNLPDoc> it1 = docs.iterator();
		while(it1.hasNext()){
			FNLPDoc doc = it1.next();
			Iterator<FNLPSent> it2 = doc.sentences.iterator();
			while(it2.hasNext()){
				FNLPSent sent = it2.next();
				if(!sent.hasRelation())
					continue;
				for(int i=0;i<sent.size();i++){					
					set.add(sent.relations[i]);
				}
			}

		}
		return set;
		
	}
747855
public final int getTotalPages() {
    if (getTotalItems() < getPageSize()) {
      return 1;
    } else {
      final int remainder = getTotalItems() % getPageSize();
      final int quotient = getTotalItems() / getPageSize();
      return (0 == remainder) ? quotient : (quotient + 1);
    }
  }
1247984
public Collection<Xml> getChildren()
    {
        final Collection<Xml> nodes = new ArrayList<>(1);
        final NodeList list = root.getChildNodes();
        for (int i = 0; i < list.getLength(); i++)
        {
            final Node node = list.item(i);
            if (node instanceof Element)
            {
                nodes.add(new Xml(document, (Element) node));
            }
        }
        return nodes;
    }
876893
public Set<Resource<L>> getChildren(Resource<L> resource) {
        graphLockRead.lock();
        try {
            Set<Resource<L>> directChildren = neighborIndex.successorsOf(resource);
            return Collections.unmodifiableSet(new HashSet<>(directChildren));
        } finally {
            graphLockRead.unlock();
        }
    }
686584
protected function getLinks()
    {
        $sLinks = '';
        foreach($this->xPaginator->getPages() as $page)
        {
            if($page['call'])
            {
                $sTemplate = ($page['isCurrent'] ? 'pagination::links/current' : 'pagination::links/enabled');
                $sLinks .= $this->xTemplate->render($sTemplate, ['call' => $page['call'], 'text' => $page['num']]);
            }
            else
            {
                $sLinks .= $this->xTemplate->render('pagination::links/disabled', ['text' => $page['num']]);
            }
        }
        return $sLinks;
    }
751546
public List<WebElement> getElements() {
        List<WebElement> foundElements = null;
        try {
            if (parent == null) {
                foundElements = HtmlElementUtils.locateElements(getLocator());
            } else {
                foundElements = parent.locateChildElements(getLocator());
            }
        } catch (NoSuchElementException n) {
            addInfoForNoSuchElementException(n);
        }

        return foundElements;
    }
884955
def each_page(browsed_nodes: [], &block)
            return enum_for(__method__) { self.Count.to_i } unless block_given?

            if browsed_nodes.any?{|node| node.equal?(self)}
                raise InvalidPageTreeError, "Cyclic tree graph detected"
            end

            unless self.Kids.is_a?(Array)
                raise InvalidPageTreeError, "Kids must be an Array"
            end

            browsed_nodes.push(self)

            unless self.Count.nil?
                [ self.Count.value, self.Kids.length ].min.times do |n|
                    node = self.Kids[n].solve

                    case node
                    when PageTreeNode then node.each_page(browsed_nodes: browsed_nodes, &block)
                    when Page then yield(node)
                    else
                        raise InvalidPageTreeError, "not a Page or PageTreeNode"
                    end
                end
            end

            self
        end
974053
function getLinks() {
    var links = [], alllinks, i = 0, length;
    alllinks = document.getElementsByTagName('a');
    length = alllinks.length;
    for (; i < length; i++) {
      if ((' ' + alllinks[i].className).indexOf(' jsbin-') !== -1) {
        links.push(alllinks[i]);
      }
    }

    return links;
  }