SemanticMediaWiki/includes/datavalues/SMW_DV_Record.php

Go to the documentation of this file.

<?php
class SMWRecordValue extends SMWDataValue {

        protected $m_diProperties = null;

        protected function parseUserValue( $value ) {
                $this->parseUserValueOrQuery( $value, false );
        }

        protected function parseUserValueOrQuery( $value, $queryMode ) {
                if ( $value === '' ) {
                        $this->addError( wfMsg( 'smw_novalues' ) );

                        if ( $queryMode ) {
                                return new SMWThingDescription();
                        } else {
                                return;
                        }
                }

                if ( $queryMode ) {
                        $subdescriptions = array();
                } elseif ( is_null( $this->m_contextPage ) ) {
                        $semanticData = SMWContainerSemanticData::makeAnonymousContainer();
                } else {
                        $subobjectName = '_' . hash( 'md4', $value, false ); // md4 is probably fastest of PHP's hashes
                        $subject = new SMWDIWikiPage( $this->m_contextPage->getDBkey(),
                                $this->m_contextPage->getNamespace(), $this->m_contextPage->getInterwiki(),
                                $subobjectName );
                        $semanticData = new SMWContainerSemanticData( $subject );
                }

                $values = preg_split( '/[\s]*;[\s]*/u', trim( $value ) );
                $valueIndex = 0; // index in value array
                $propertyIndex = 0; // index in property list
                $empty = true;

                foreach ( $this->getPropertyDataItems() as $diProperty ) {
                        if ( !array_key_exists( $valueIndex, $values ) ) {
                                break; // stop if there are no values left
                        }

                        if ( $queryMode ) { // special handling for supporting query parsing
                                $comparator = SMW_CMP_EQ;
                                SMWDataValue::prepareValue( $values[$valueIndex], $comparator );
                        }

                        // generating the DVs:
                        if ( ( $values[$valueIndex] === '' ) || ( $values[$valueIndex] == '?' ) ) { // explicit omission
                                $valueIndex++;
                        } else {
                                $dataValue = SMWDataValueFactory::newPropertyObjectValue( $diProperty, $values[$valueIndex] );

                                if ( $dataValue->isValid() ) { // valid DV: keep
                                        if ( $queryMode ) {
                                                $subdescriptions[] = new SMWSomeProperty( $diProperty, new SMWValueDescription( $dataValue->getDataItem(), $comparator ) );
                                        } else {
                                                $semanticData->addPropertyObjectValue( $diProperty, $dataValue->getDataItem() );
                                        }

                                        $valueIndex++;
                                        $empty = false;
                                } elseif ( ( count( $values ) - $valueIndex ) == ( count( $this->m_diProperties ) - $propertyIndex ) ) {
                                        // too many errors: keep this one to have enough slots left
                                        if ( !$queryMode ) {
                                                $semanticData->addPropertyObjectValue( $diProperty, $dataValue->getDataItem() );
                                        }

                                        $this->addError( $dataValue->getErrors() );
                                        ++$valueIndex;
                                }
                        }
                        ++$propertyIndex;
                }

                if ( $empty ) {
                        $this->addError( wfMsg( 'smw_novalues' ) );
                }

                if ( $queryMode ) {
                        switch ( count( $subdescriptions ) ) {
                                case 0: return new SMWThingDescription();
                                case 1: return reset( $subdescriptions );
                                default: return new SMWConjunction( $subdescriptions );
                        }
                } else {
                        $this->m_dataitem = new SMWDIContainer( $semanticData );
                }
        }

        protected function loadDataItem( SMWDataItem $dataItem ) {
                if ( $dataItem->getDIType() == SMWDataItem::TYPE_CONTAINER ) {
                        $this->m_dataitem = $dataItem;
                        return true;
                } else {
                        return false;
                }
        }

        public function getQueryDescription( $value ) {
                return $this->parseUserValueOrQuery( $value, true );
        }

        public function getShortWikiText( $linked = null ) {
                if ( $this->m_caption !== false ) {
                        return $this->m_caption;
                }
                return $this->makeOutputText( 0, $linked );
        }

        public function getShortHTMLText( $linker = null ) {
                if ( $this->m_caption !== false ) {
                        return $this->m_caption;
                }
                return $this->makeOutputText( 1, $linker );
        }

        public function getLongWikiText( $linked = null ) {
                return $this->makeOutputText( 2, $linked );
        }

        public function getLongHTMLText( $linker = null ) {
                return $this->makeOutputText( 3, $linker );
        }

        public function getWikiValue() {
                return $this->makeOutputText( 4 );
        }

        protected function checkAllowedValues() { }

        public function setProperty( SMWDIProperty $property ) {
                parent::setProperty( $property );
                $this->m_diProperties = null;
        }


        public function getDVs() {
                return $this->getDataItems();
        }

        public function getDataItems() {
                if ( $this->isValid() ) {
                        $result = array();
                        $index = 0;
                        foreach ( $this->getPropertyDataItems() as $diProperty ) {
                                $values = $this->getDataItem()->getSemanticData()->getPropertyValues( $diProperty );
                                if ( count( $values ) > 0 ) {
                                        $result[$index] = reset( $values );
                                } else {
                                        $result[$index] = null;
                                }
                                $index += 1;
                        }
                        return $result;
                } else {
                        return array();
                }
        }

        public function getPropertyDataItems() {
                if ( is_null( $this->m_diProperties ) ) {
                        $this->m_diProperties = self::findPropertyDataItems( $this->m_property );

                        if ( count( $this->m_diProperties ) == 0 ) { // TODO internalionalize
                                $this->addError( 'The list of properties to be used for the data fields has not been specified properly.' );
                        }
                }

                return $this->m_diProperties;
        }

        public static function findPropertyDataItems( $diProperty ) {
                if ( !is_null( $diProperty ) ) {
                        $propertyDiWikiPage = $diProperty->getDiWikiPage();

                        if ( !is_null( $propertyDiWikiPage ) ) {
                                $listDiProperty = new SMWDIProperty( '_LIST' );
                                $dataItems = smwfGetStore()->getPropertyValues( $propertyDiWikiPage, $listDiProperty );

                                if ( count( $dataItems ) == 1 ) {
                                        $propertyListValue = new SMWPropertyListValue( '__pls' );
                                        $propertyListValue->setDataItem( reset( $dataItems ) );

                                        if ( $propertyListValue->isValid() ) {
                                                return $propertyListValue->getPropertyDataItems();
                                        }
                                }
                        }
                }

                return array();
        }


        protected function makeOutputText( $type = 0, $linker = null ) {
                if ( !$this->isValid() ) {
                        return ( ( $type == 0 ) || ( $type == 1 ) ) ? '' : $this->getErrorText();
                }

                $result = '';
                $i = 0;
                foreach ( $this->getPropertyDataItems() as $propertyDataItem ) {
                        if ( $i == 1 ) {
                                $result .= ( $type == 4 ) ? '; ' : ' (';
                        } elseif ( $i > 1 ) {
                                $result .= ( $type == 4 ) ? '; ' : ', ';
                        }
                        ++$i;
                        $propertyValues = $this->m_dataitem->getSemanticData()->getPropertyValues( $propertyDataItem ); // combining this with next line violates PHP strict standards
                        $dataItem = reset( $propertyValues );
                        if ( $dataItem !== false ) {
                                $dataValue = SMWDataValueFactory::newDataItemValue( $dataItem, $propertyDataItem );
                                $result .= $this->makeValueOutputText( $type, $dataValue, $linker );
                        } else {
                                $result .= '?';
                        }
                }
                if ( ( $i > 1 ) && ( $type != 4 ) ) $result .= ')';

                return $result;
        }

        protected function makeValueOutputText( $type, $dataValue, $linker ) {
                switch ( $type ) {
                        case 0: return $dataValue->getShortWikiText( $linker );
                        case 1: return $dataValue->getShortHTMLText( $linker );
                        case 2: return $dataValue->getShortWikiText( $linker );
                        case 3: return $dataValue->getShortHTMLText( $linker );
                        case 4: return $dataValue->getWikiValue();
                }
        }

}

---