SemanticMediaWiki/includes/datavalues/SMW_DataValue.php

Go to the documentation of this file.

<?php
abstract class SMWDataValue {

        protected $m_dataitem;

        protected $m_property = null;

        protected $m_contextPage = null;

        protected $m_caption;

        protected $m_typeid;

        protected $m_infolinks = array();

        protected $m_outformat = false;

        private $mHasSearchLink;

        private $mHasServiceLinks;

        private $mErrors = array();

        private $mHasErrors = false;

        public function __construct( $typeid ) {
                $this->m_typeid = $typeid;
        }


        public function setUserValue( $value, $caption = false ) {
                wfProfileIn( 'SMWDataValue::setUserValue (SMW)' );

                $this->m_dataitem = null;
                $this->mErrors = array(); // clear errors
                $this->mHasErrors = false;
                $this->m_infolinks = array(); // clear links
                $this->mHasSearchLink = false;
                $this->mHasServiceLinks = false;
                $this->m_caption = is_string( $caption ) ? trim( $caption ) : false;


                $this->parseUserValue( $value ); // may set caption if not set yet, depending on datavalue

                // The following checks for markers generated by MediaWiki to handle special content,
                // e.g. math. In general, we are not prepared to handle such content properly, and we
                // also have no means of obtaining the user input at this point. Hence the assignement
                // just fails, even if parseUserValue() above might not have noticed this issue.
                // Note: \x07 was used in MediaWiki 1.11.0, \x7f is used now (backwards compatiblity, b/c)
                if ( ( strpos( $value, "\x7f" ) !== false ) || ( strpos( $value, "\x07" ) !== false ) ) {
                        $this->addError( wfMsgForContent( 'smw_parseerror' ) );
                }

                if ( $this->isValid() ) {
                        $this->checkAllowedValues();
                }

                wfProfileOut( 'SMWDataValue::setUserValue (SMW)' );
        }

        public function setDataItem( SMWDataItem $dataItem ) {
                $this->m_dataitem = null;
                $this->mErrors = $this->m_infolinks = array();
                $this->mHasErrors = $this->mHasSearchLink = $this->mHasServiceLinks = $this->m_caption = false;
                return $this->loadDataItem( $dataItem );
        }

        public function setProperty( SMWDIProperty $property ) {
                $this->m_property = $property;
        }

        public function setContextPage( SMWDIWikiPage $contextPage ) {
                $this->m_contextPage = $contextPage;
        }

        public function setCaption( $caption ) {
                $this->m_caption = $caption;
        }

        public function addInfolink( SMWInfolink $link ) {
                $this->m_infolinks[] = $link;
        }

        public function addServiceLinks() {
                if ( $this->mHasServiceLinks ) {
                        return;
                }
                if ( !is_null( $this->m_property ) ) {
                        $propertyDiWikiPage = $this->m_property->getDiWikiPage();
                }
                if ( is_null( $this->m_property ) || is_null( $propertyDiWikiPage ) ) {
                        return; // no property known, or not associated with a page
                }

                $args = $this->getServiceLinkParams();

                if ( $args === false ) {
                        return; // no services supported
                }

                array_unshift( $args, '' ); // add a 0 element as placeholder
                $servicelinks = smwfGetStore()->getPropertyValues( $propertyDiWikiPage, new SMWDIProperty( '_SERV' ) );

                foreach ( $servicelinks as $dataItem ) {
                        if ( !( $dataItem instanceof SMWDIString ) ) continue;

                        $args[0] = 'smw_service_' . str_replace( ' ', '_', $dataItem->getString() ); // messages distinguish ' ' from '_'
                        $text = call_user_func_array( 'wfMsgForContent', $args );
                        $links = preg_split( "/[\n][\s]?/u", $text );

                        foreach ( $links as $link ) {
                                $linkdat = explode( '|', $link, 2 );

                                if ( count( $linkdat ) == 2 ) {
                                        $this->addInfolink( SMWInfolink::newExternalLink( $linkdat[0], trim( $linkdat[1] ) ) );
                                }
                        }
                }
                $this->mHasServiceLinks = true;
        }

        public function setOutputFormat( $formatString ) {
                $this->m_outformat = $formatString; // just store it, subclasses may or may not use this
        }

        public function addError( $error ) {
                if ( is_array( $error ) ) {
                        $this->mErrors = array_merge( $this->mErrors, $error );
                        $this->mHasErrors = $this->mHasErrors || ( count( $error ) > 0 );
                } else {
                        $this->mErrors[] = $error;
                        $this->mHasErrors = true;
                }
        }

        protected function clearErrors() {
                $this->mErrors = array();
                $this->mHasErrors = false;
        }


        abstract protected function parseUserValue( $value );

        abstract protected function loadDataItem( SMWDataItem $dataItem );



        public function getQueryDescription( $value ) {
                $comparator = SMW_CMP_EQ;

                self::prepareValue( $value, $comparator );

                $this->setUserValue( $value );

                if ( !$this->isValid() ) {
                        return new SMWThingDescription();
                } else {
                        return new SMWValueDescription( $this->getDataItem(), $this->m_property, $comparator );
                }
        }

        static protected function prepareValue( &$value, &$comparator ) {
                // Loop over the comparators to determine which one is used and what the actual value is.
                foreach ( SMWQueryLanguage::getComparatorStrings() as $srting ) {
                        if ( strpos( $value, $srting ) === 0 ) {
                                $comparator = SMWQueryLanguage::getComparatorFromString( substr( $value, 0, strlen( $srting ) ) );
                                $value = substr( $value, strlen( $srting ) );
                                break;
                        }
                }
        }


        public function getDataItem() {
                if ( $this->isValid() ) {
                        return $this->m_dataitem;
                } else {
                        return new SMWDIError( $this->mErrors );
                }
        }

        abstract public function getShortWikiText( $linked = null );

        abstract public function getShortHTMLText( $linker = null );

        abstract public function getLongWikiText( $linked = null );

        abstract public function getLongHTMLText( $linker = null );

        public function getShortText( $outputformat, $linker = null ) {
                switch ( $outputformat ) {
                        case SMW_OUTPUT_WIKI:
                                return $this->getShortWikiText( $linker );
                        case SMW_OUTPUT_HTML:
                        case SMW_OUTPUT_FILE:
                        default:
                                return $this->getShortHTMLText( $linker );
                }
        }

        public function getLongText( $outputformat, $linker = null ) {
                switch ( $outputformat ) {
                        case SMW_OUTPUT_WIKI:
                                return $this->getLongWikiText( $linker );
                        case SMW_OUTPUT_HTML:
                        case SMW_OUTPUT_FILE:
                        default:
                                return $this->getLongHTMLText( $linker );
                }
        }

        public function getInfolinkText( $outputformat, $linker = null ) {
                $result = '';
                $first = true;
                $extralinks = array();

                switch ( $outputformat ) {
                        case SMW_OUTPUT_WIKI:
                                foreach ( $this->getInfolinks() as $link ) {
                                        if ( $first ) {
                                                $result .= '<!-- -->  ' . $link->getWikiText();
                                                        // the comment is needed to prevent MediaWiki from linking URL-strings together with the nbsps!
                                                $first = false;
                                        } else {
                                                $extralinks[] = $link->getWikiText();
                                        }
                                }
                                break;

                        case SMW_OUTPUT_HTML: case SMW_OUTPUT_FILE: default:
                                foreach ( $this->getInfolinks() as $link ) {
                                        if ( $first ) {
                                                $result .= '&#160;&#160;' . $link->getHTML( $linker );
                                                $first = false;
                                        } else {
                                                $extralinks[] = $link->getHTML( $linker );
                                        }
                                }
                                break;
                }

                if ( count( $extralinks ) > 0 ) {
                        $result .= smwfEncodeMessages( $extralinks, 'info', ', <!--br-->', false );
                }

                return $result;
        }

        abstract public function getWikiValue();

        public function getTypeID() {
                return $this->m_typeid;
        }

        public function getInfolinks() {
                if ( $this->isValid() && !is_null( $this->m_property ) ) {
                        if ( !$this->mHasSearchLink ) { // add default search link
                                $this->mHasSearchLink = true;
                                $this->m_infolinks[] = SMWInfolink::newPropertySearchLink( '+',
                                        $this->m_property->getLabel(), $this->getWikiValue() );
                        }

                        if ( !$this->mHasServiceLinks ) { // add further service links
                                $this->addServiceLinks();
                        }
                }

                return $this->m_infolinks;
        }

        protected function getServiceLinkParams() {
                return false;
        }

        public function getHash() {
                return $this->isValid() ? $this->m_dataitem->getHash() : implode( "\t", $this->mErrors );
        }

        public function isNumeric() {
                if ( isset( $this->m_dataitem ) ) {
                        return is_numeric( $this->m_dataitem->getSortKey() );
                } else {
                        return false;
                }
        }

        public function isValid() {
                return !$this->mHasErrors && isset( $this->m_dataitem );
        }

        public function getErrorText() {
                return smwfEncodeMessages( $this->mErrors );
        }

        public function getErrors() {
                return $this->mErrors;
        }

        protected function checkAllowedValues() {
                if ( !is_null( $this->m_property ) ) {
                        $propertyDiWikiPage = $this->m_property->getDiWikiPage();
                }

                if ( is_null( $this->m_property ) || is_null( $propertyDiWikiPage ) ||
                        !isset( $this->m_dataitem ) ) {
                        return; // no property known, or no data to check
                }

                $allowedvalues = smwfGetStore()->getPropertyValues(
                        $propertyDiWikiPage,
                        new SMWDIProperty( '_PVAL' )
                );

                if ( count( $allowedvalues ) == 0 ) {
                        return;
                }

                $hash = $this->m_dataitem->getHash();
                $testdv = SMWDataValueFactory::newTypeIDValue( $this->getTypeID() );
                $accept = false;
                $valuestring = '';
                foreach ( $allowedvalues as $di ) {
                        if ( $di->getDIType() === SMWDataItem::TYPE_STRING ) {
                                $testdv->setUserValue( $di->getString() );

                                if ( $hash === $testdv->getDataItem()->getHash() ) {
                                        $accept = true;
                                        break;
                                } else {
                                        if ( $valuestring !== '' ) {
                                                $valuestring .= ', ';
                                        }
                                        $valuestring .= $di->getString();
                                }
                        }
                }

                if ( !$accept ) {
                        $this->addError(
                                wfMsgForContent( 'smw_notinenum', $this->getWikiValue(), $valuestring )
                        );
                }
        }

}

---