SemanticMediaWiki/includes/storage/SMW_ResultArray.php

Go to the documentation of this file.

<?php

class SMWResultArray {
        
        protected $mPrintRequest;
        
        protected $mResult;
        
        protected $mStore;
        
        protected $mContent;

        static protected $catCacheObj = false;
        static protected $catCache = false;

        public function __construct( SMWDIWikiPage $resultPage, SMWPrintRequest $printRequest, SMWStore $store ) {
                $this->mResult = $resultPage;
                $this->mPrintRequest = $printRequest;
                $this->mStore = $store;
                $this->mContent = false;
        }

        public function getStore() {
                return $this->mStore;
        }

        public function getResultSubject() {
                return $this->mResult;
        }

        public function getContent() {
                $this->loadContent();
                return $this->mContent;
        }

        public function getPrintRequest() {
                return $this->mPrintRequest;
        }

        public function getNextObject() {
                return $this->getNextDataValue();
        }

        public function getNextDataItem() {
                $this->loadContent();
                $result = current( $this->mContent );
                next( $this->mContent );
                return $result;
        }

        public function reset() {
                $this->loadContent();
                return reset( $this->mContent );
        }

        public function getNextDataValue() {
                $di = $this->getNextDataItem();
                if ( $di === false ) {
                        return false;
                }
                if ( $this->mPrintRequest->getMode() == SMWPrintRequest::PRINT_PROP &&
                     $this->mPrintRequest->getTypeID() == '_rec' &&
                     $this->mPrintRequest->getParameter( 'index' ) !== false ) {
                        // Not efficient, but correct: we need to find the right property for
                        // the selected index of the record here.
                        $pos = $this->mPrintRequest->getParameter( 'index' ) - 1;
                        $recordValue = SMWDataValueFactory::newDataItemValue( $di,
                                $this->mPrintRequest->getData()->getDataItem() );
                        $diProperties = $recordValue->getPropertyDataItems();

                        if ( array_key_exists( $pos, $diProperties ) &&
                                !is_null( $diProperties[$pos] ) ) {
                                $diProperty = $diProperties[$pos];
                        } else {
                                $diProperty = null;
                        }
                } elseif ( $this->mPrintRequest->getMode() == SMWPrintRequest::PRINT_PROP ) {
                        $diProperty = $this->mPrintRequest->getData()->getDataItem();
                } else {
                        $diProperty = null;
                }
                $dv = SMWDataValueFactory::newDataItemValue( $di, $diProperty );
                if ( $this->mPrintRequest->getOutputFormat() ) {
                        $dv->setOutputFormat( $this->mPrintRequest->getOutputFormat() );
                }
                return $dv;
        }

        public function getNextText( $outputMode, $linker = null ) {
                $dataValue = $this->getNextDataValue();
                if ( $dataValue !== false ) { // Print data values.
                        return $dataValue->getShortText( $outputMode, $linker );
                } else {
                        return false;
                }
        }

        protected function loadContent() {
                if ( $this->mContent !== false ) return;
                
                wfProfileIn( 'SMWQueryResult::loadContent (SMW)' );
                
                switch ( $this->mPrintRequest->getMode() ) {
                        case SMWPrintRequest::PRINT_THIS: // NOTE: The limit is ignored here.
                                $this->mContent = array( $this->mResult );
                        break;
                        case SMWPrintRequest::PRINT_CATS:
                                // Always recompute cache here to ensure output format is respected.
                                self::$catCache = $this->mStore->getPropertyValues( $this->mResult,
                                        new SMWDIProperty( '_INST' ), $this->getRequestOptions( false ) );
                                self::$catCacheObj = $this->mResult->getHash();
                                
                                $limit = $this->mPrintRequest->getParameter( 'limit' );
                                $this->mContent = ( $limit === false ) ? ( self::$catCache ) :
                                        array_slice( self::$catCache, 0, $limit );
                        break;
                        case SMWPrintRequest::PRINT_PROP:
                                $propertyValue = $this->mPrintRequest->getData();
                                if ( $propertyValue->isValid() ) {
                                        $this->mContent = $this->mStore->getPropertyValues( $this->mResult,
                                                $propertyValue->getDataItem(), $this->getRequestOptions() );
                                } else {
                                        $this->mContent = array();
                                }

                                // Print one component of a multi-valued string.
                                // Known limitation: the printrequest still is of type _rec, so if printers check
                                // for this then they will not recognize that it returns some more concrete type.
                                if ( ( $this->mPrintRequest->getTypeID() == '_rec' ) && 
                                     ( $this->mPrintRequest->getParameter( 'index' ) !== false ) ) {
                                        $pos = $this->mPrintRequest->getParameter( 'index' ) - 1;
                                        $newcontent = array();

                                        foreach ( $this->mContent as $diContainer ) {
                                                /* SMWRecordValue */ $recordValue = SMWDataValueFactory::newDataItemValue( $diContainer, $propertyValue->getDataItem() );
                                                $dataItems = $recordValue->getDataItems();
                                                
                                                if ( array_key_exists( $pos, $dataItems ) &&
                                                        ( !is_null( $dataItems[$pos] ) ) ) {
                                                        $newcontent[] = $dataItems[$pos];
                                                }
                                        }

                                        $this->mContent = $newcontent;
                                }
                        break;
                        case SMWPrintRequest::PRINT_CCAT: 
                                if ( self::$catCacheObj != $this->mResult->getHash() ) {
                                        self::$catCache = $this->mStore->getPropertyValues( $this->mResult, new SMWDIProperty( '_INST' ) );
                                        self::$catCacheObj = $this->mResult->getHash();
                                }

                                $found = '0';
                                $prkey = $this->mPrintRequest->getData()->getDBkey();

                                foreach ( self::$catCache as $cat ) {
                                        if ( $cat->getDBkey() == $prkey ) {
                                                $found = '1';
                                                break;
                                        }
                                }
                                $this->mContent = array( new SMWDIBoolean( $found ) );
                        break;
                        default: $this->mContent = array(); // Unknown print request.
                }
                
                reset( $this->mContent );
                
                wfProfileOut( 'SMWQueryResult::loadContent (SMW)' );
        }

        protected function getRequestOptions( $useLimit = true ) {
                $limit = $useLimit ? $this->mPrintRequest->getParameter( 'limit' ) : false;
                $order = trim( $this->mPrintRequest->getParameter( 'order' ) );
                
                // Important: use "!=" for order, since trim() above does never return "false", use "!==" for limit since "0" is meaningful here.
                if ( ( $limit !== false ) || ( $order != false ) ) { 
                        $options = new SMWRequestOptions();
                        
                        if ( $limit !== false ) $options->limit = trim( $limit );
                        
                        if ( ( $order == 'descending' ) || ( $order == 'reverse' ) || ( $order == 'desc' ) ) {
                                $options->sort = true;
                                $options->ascending = false;
                        } elseif ( ( $order == 'ascending' ) || ( $order == 'asc' ) ) {
                                $options->sort = true;
                                $options->ascending = true;
                        }
                } else {
                        $options = null;
                }
                
                return $options;
        }
        
}

---