Collects all the information contained in the concurrent R structures in
every context and returns a single R structure with all their content.

@return R
11845
public R getRelationships() {
        R r = new R(factory.getTotalConcepts(), factory.getTotalRoles());
        
        // Collect subsumptions from context index
        for (IntIterator it = contextIndex.keyIterator(); it.hasNext();) {
            int key = it.next();
            Context ctx = contextIndex.get(key);
            int concept = ctx.getConcept();
            CR pred = ctx.getPred();
            CR succ = ctx.getSucc();
            
            int[] predRoles = pred.getRoles();
            for(int i = 0; i < predRoles.length; i++) {
                IConceptSet cs = pred.lookupConcept(predRoles[i]);
                for(IntIterator it2 = cs.iterator(); it2.hasNext(); ) {
                    int predC = it2.next();
                    r.store(predC, predRoles[i], concept);
                }
            }
            
            int[] succRoles = succ.getRoles();
            for(int i = 0; i < succRoles.length; i++) {
                IConceptSet cs = succ.lookupConcept(succRoles[i]);
                for(IntIterator it2 = cs.iterator(); it2.hasNext(); ) {
                    int succC = it2.next();
                    r.store(concept, succRoles[i], succC);
                }
            }
        }
        
        return r;
    }
897897
public function getContents()
    {
        if(!$this->isReady())
            return;

        ob_start();

        extract($this->callbackResolve($this->data));

        require $this->path;

        return ob_get_clean();
    }
497618
public function getContents()
    {
        if ($this->resource === null) {
            return '';
        }

        $result = substr($this->resource, $this->pointer);

        if ($result === false) {
            return '';
        }

        return $result;
    }
987504
public function getAllModularInfo()
    {
        $modularInfo = new Collection();
        foreach ($this->getAllValidModular() as $modularName => $modular) {
            $modularInfo[$modularName] = $this->getModularInformation($modularName);
        }

        return $modularInfo;
    }
1223656
protected function getContent()
    {
        $response = new SamlResponse();
        $response->setStatus(new Status(new StatusCode($this->status)));

        $context = new SerializationContext();
        $response->serialize($context->getDocument(), $context);

        return $context->getDocument()->saveXML();
    }
877501
public static function getAll()
    {
        $class = get_called_class();
        if (!isset(static::$values[$class])) {
            $reflection = new \ReflectionClass($class);
            static::$values[$class] = $reflection->getConstants();
        }

        return static::$values[$class];
    }
181967
public function all()
    {
        $data = [];

        $page      = 1;
        $fetch_all = true;

        $resourceName = constant($this->type . '::RESOURCE');
        $url          = sprintf("%s/%s", self::ENDPOINT, $resourceName);
        if (isset($this->params['page'])) {
            $page      = $this->params['page'];
            $fetch_all = false;
        }

        while (true) {
            $response = $this->fetch($this->buildUrl($url, $this->params), $resourceName);

            if (count($response) > 0) {
                foreach ($response as $item) {
                    $data[] = new $this->type($item);
                }

                if (!$fetch_all) {
                    break;
                } else {
                    $page++;
                    $this->where(['page' => $page]);
                }
            } else {
                break;
            }
        }

        return $data;
    }
140415
public function collectChildren()
    {
        if ($this->hasChildrenRelation()) {
            $result = $this->getRelation($this->getChildrenRelationIndex());
        } else {
            $result = $this->children();
        }

        return $result;
    }
256096
public function getAllMetadata()
    {
        if (!$this->metadataLoaded) {
            // We have to load all the metadata
            $doctrineMetadata = $this->doctrine->getManager()->getMetadataFactory();

            /** @var ClassMetadata $doctrineClassMetadata */
            foreach ($doctrineMetadata->getAllMetadata() as $doctrineClassMetadata) {
                $reflectionClass = $doctrineClassMetadata->getReflectionClass();
                $this->metadata[$reflectionClass->getName()] = $this->getClassMetadata($reflectionClass);
            }

            $this->metadataLoaded = true;
        }

        $allMetadata = array_filter($this->metadata, function($element) { return null !== $element; });

        return $allMetadata;
    }
123962
final protected static function get_context_structure() {
        return array(
            'contextid' => new external_value(PARAM_INT, 'The context id', VALUE_OPTIONAL),
            'contextlevel' => new external_value(PARAM_ALPHA, 'The context level', VALUE_OPTIONAL),
            'instanceid' => new external_value(PARAM_INT, 'The Instance id', VALUE_OPTIONAL),
        );
    }
985020
public function getChildrenRecursive()
    {
        $res = new ObjectCollection();
        foreach ($this->children() as $child) {
            $res->add($child);
            if ($child instanceof ParentNodeInterface) {
                $res->addMany($child->getChildrenRecursive());
            }
        }

        return $res;
    }
523563
public function getAllTxrefs()
    {
        $allTxrefs = array();
        if (is_array($this->txrefs)) {
            $allTxrefs = array_merge($allTxrefs, $this->txrefs);
        }
        if (is_array($this->unconfirmed_txrefs)) {
            $allTxrefs = array_merge($allTxrefs, $this->unconfirmed_txrefs);
        }

        if (count($allTxrefs) == 0)
            return null;
        else
            return $allTxrefs;
    }
1296500
public ITreeData getNode() {
        if (lastPointer.get(mRTX) != null && lastPointer.get(mRTX) < 0) {
            return atomics.get(mRTX).getItem(lastPointer.get(mRTX));
        } else {
            return mRTX.getNode();
        }
    }
738042
public function getItems()
    {
        if ($this->items === null) {
            $fusionContext = $this->runtime->getCurrentContext();
            $this->currentNode = isset($fusionContext['activeNode']) ? $fusionContext['activeNode'] : $fusionContext['documentNode'];
            $this->currentLevel = 1;
            $this->items = $this->buildItems();
        }

        return $this->items;
    }
786555
public function getItems()
	{
		/**
		 * @var array $res
		 */
		$res = array();
		foreach ( $this->iter as /** @var XPathItem $item */ $item )
		{
			if ( count( $res ) == 10)
				break;

			$res[] = $item->CloneInstance();
		}

		return $res;
	}
1049237
public function findAll()
    {
        if (empty($this->context) || empty($this->siteDomain) || empty($this->deviceView) || empty($this->design))
            return;

        if ($this->isSiteDeployment) {
            $design = $this->design;
            $deviceView = $this->deviceView;
        } else {
            $design = '';
            $deviceView = '';
        }

        $aggregatePath = $this->getAggregatePath();

        $files = null;
        $md5   = null;

        $this->Logger->debug("Aggregate Path: {$aggregatePath}");


        if ($this->isDevelopmentMode || $this->isOneOffRedeploy || !file_exists($aggregatePath))
            list($files,$md5) = $this->getFiles();

        if (file_exists($aggregatePath)) {

            //$contents = JSONUtils::decode(file_get_contents($aggregatePath),true);
            include $aggregatePath;

            //if this IS development mode, a refresh is performed everytime the md5's dont' match
            //if this is NOT development mode, the only way to force a refresh is to delete the .php file
            if (( $this->isDevelopmentMode === false && $this->isOneOffRedeploy === false)
             || ( ($this->isDevelopmentMode === true || $this->isOneOffRedeploy === true) && $md5 === $contents['md5']))
                if(isset(${$this->subject}))
                    return ${$this->subject}; // files haven't changed, return previously aggregated contents
                else
                    return array();
        }

        //rebuild file
        return $this->aggregateFiles($md5, $files, $aggregatePath);
    }
160166
public function getAllDocuments()
    {
        $documents = ArrayList::create();

        foreach ($this->owner->DocumentSets() as $documentSet) {
            /** @var DocumentSet $documentSet */
            $documents->merge($documentSet->getDocuments());
        }
        $documents->removeDuplicates();

        return $documents;
    }