SemanticMediaWiki/includes/dataitems/SMW_DI_Property.php

Go to the documentation of this file.

<?php
class SMWDIProperty extends SMWDataItem {

        static protected $m_prop_types;

        static protected $m_prop_labels;

        static protected $m_prop_aliases;

        protected $m_key;

        protected $m_inverse;

        protected $m_proptypeid;

        public function __construct( $key, $inverse = false ) {
                if ( ( $key === '' ) || ( $key{0} == '-' ) ) {
                        throw new SMWDataItemException( "Illegal property key \"$key\"." );
                }

                if ( $key{0} == '_' ) {
                        SMWDIProperty::initPropertyRegistration();
                        if ( !array_key_exists( $key, SMWDIProperty::$m_prop_types ) ) {
                                throw new SMWDataItemException( "There is no predefined property with \"$key\"." );
                        }
                }

                $this->m_key = $key;
                $this->m_inverse = $inverse;
        }

        public function getDIType() {
                return SMWDataItem::TYPE_PROPERTY;
        }

        public function getKey() {
                return $this->m_key;
        }

        public function isInverse() {
                return $this->m_inverse;
        }

        public function getSortKey() {
                return $this->m_key;
        }

        public function isShown() {
                return ( ( $this->isUserDefined() ) ||
                         ( array_key_exists( $this->m_key, SMWDIProperty::$m_prop_types ) &&
                           SMWDIProperty::$m_prop_types[$this->m_key][1] ) );
        }

        public function isUserDefined() {
                return $this->m_key{0} != '_';
        }

        public function getLabel() {
                if ( $this->isUserDefined() ) {
                        return str_replace( '_', ' ', $this->m_key );
                } else {
                        SMWDIProperty::initPropertyRegistration();
                        if ( array_key_exists( $this->m_key, SMWDIProperty::$m_prop_labels ) ) {
                                return SMWDIProperty::$m_prop_labels[$this->m_key];
                        } else {
                                return '';
                        }
                }
        }

        public function getDiWikiPage() {
                if ( $this->m_inverse ) {
                        return null;
                }

                if ( $this->isUserDefined() ) {
                        $dbkey = $this->m_key;
                } else {
                        $dbkey = str_replace( ' ', '_', $this->getLabel() );
                }

                try {
                        return new SMWDIWikiPage( $dbkey, SMW_NS_PROPERTY, '' );
                } catch ( SMWDataItemException $e ) {
                        return null;
                }
        }

        public function findPropertyTypeID() {
                global $smwgPDefaultType;

                if ( !isset( $this->m_proptypeid ) ) {
                        if ( $this->isUserDefined() ) { // normal property
                                $diWikiPage = new SMWDIWikiPage( $this->getKey(), SMW_NS_PROPERTY, '' );
                                $typearray = smwfGetStore()->getPropertyValues( $diWikiPage, new SMWDIProperty( '_TYPE' ) );

                                if ( count( $typearray ) >= 1 ) { // some types given, pick one (hopefully unique)
                                        $typeDataItem = reset( $typearray );

                                        if ( $typeDataItem instanceof SMWDIUri ) {
                                                $this->m_proptypeid = $typeDataItem->getFragment();
                                        } else {
                                                $this->m_proptypeid = '__err';
                                        }
                                } elseif ( count( $typearray ) == 0 ) { // no type given
                                        $this->m_proptypeid = $smwgPDefaultType;
                                }
                        } else { // pre-defined property
                                $this->m_proptypeid = self::getPredefinedPropertyTypeId( $this->m_key );
                        }
                }

                return $this->m_proptypeid;
        }


        public function getSerialization() {
                return ( $this->m_inverse ? '-' : '' ) . $this->m_key;
        }

        public static function doUnserialize( $serialization ) {
                $inverse = false;

                if ( $serialization{0} == '-' ) {
                        $serialization = substr( $serialization, 1 );
                        $inverse = true;
                }

                return new SMWDIProperty( $serialization, $inverse );
        }

        public static function newFromUserLabel( $label, $inverse = false ) {
                $id = SMWDIProperty::findPropertyID( $label );

                if ( $id === false ) {
                        return new SMWDIProperty( str_replace( ' ', '_', $label ), $inverse );
                } else {
                        return new SMWDIProperty( $id, $inverse );
                }
        }

        protected static function findPropertyID( $label, $useAlias = true ) {
                SMWDIProperty::initPropertyRegistration();
                $id = array_search( $label, SMWDIProperty::$m_prop_labels );

                if ( $id !== false ) {
                        return $id;
                } elseif ( ( $useAlias ) && ( array_key_exists( $label, SMWDIProperty::$m_prop_aliases ) ) ) {
                        return SMWDIProperty::$m_prop_aliases[$label];
                } else {
                        return false;
                }
        }

        public static function getPredefinedPropertyTypeId( $key ) {
                if ( array_key_exists( $key, SMWDIProperty::$m_prop_types ) ) {
                        return SMWDIProperty::$m_prop_types[$key][0];
                } else {
                        return '';
                }
        }

        static protected function findPropertyLabel( $id ) {
                SMWDIProperty::initPropertyRegistration();
                if ( array_key_exists( $id, SMWDIProperty::$m_prop_labels ) ) {
                        return SMWDIProperty::$m_prop_labels[$id];
                } else { // incomplete translation (language bug) or deliberately invisible property
                        return false;
                }
        }

        static protected function initPropertyRegistration() {
                if ( is_array( SMWDIProperty::$m_prop_types ) ) {
                        return; // init happened before
                }

                global $smwgContLang, $smwgUseCategoryHierarchy;
                $datatypeLabels = $smwgContLang->getDatatypeLabels();
                SMWDIProperty::$m_prop_labels  = $smwgContLang->getPropertyLabels() + $datatypeLabels;
                SMWDIProperty::$m_prop_aliases = $smwgContLang->getPropertyAliases() + $smwgContLang->getDatatypeAliases();
                // Setup built-in predefined properties.
                // NOTE: all ids must start with underscores. The translation
                // for each ID, if any, is defined in the language files.
                // Properties without translation cannot be entered by or
                // displayed to users, whatever their "show" value below.
                SMWDIProperty::$m_prop_types = array(
                                '_TYPE'  =>  array( '__typ', true ), // "has type"
                                '_URI'   =>  array( '__spu', true ), // "equivalent URI"
                                '_INST'  =>  array( '__sin', false ), // instance of a category
                                '_UNIT'  =>  array( '__sps', true ), // "displays unit"
                                '_IMPO'  =>  array( '__imp', true ), // "imported from"
                                '_CONV'  =>  array( '__sps', true ), // "corresponds to"
                                '_SERV'  =>  array( '__sps', true ), // "provides service"
                                '_PVAL'  =>  array( '__sps', true ), // "allows value"
                                '_REDI'  =>  array( '__red', true ), // redirects to some page
                                '_SUBP'  =>  array( '__sup', true ), // "subproperty of"
                                '_SUBC'  =>  array( '__suc', !$smwgUseCategoryHierarchy ), // "subcategory of"
                                '_CONC'  =>  array( '__con', false ), // associated concept
                                '_MDAT'  =>  array( '_dat', false ), // "modification date"
                                '_CDAT'  =>  array( '_dat', false ), // "creation date"
                                '_NEWP'  =>  array( '_boo', false ), // "is a new page"
                                '_LEDT'  =>  array( '_wpg', false ), // "last editor is"
                                '_ERRP'  =>  array( '_wpp', false ), // "has improper value for"
                                '_LIST'  =>  array( '__pls', true ), // "has fields"
                                '_SKEY'  =>  array( '__key', false ), // sort key of a page
                                '_SF_DF' => array( '__spf', true ), // Semantic Form's default form property
                                '_SF_AF' => array( '__spf', true ),  // Semantic Form's alternate form property
                                '_SOBJ'  =>  array( '_wpg', true ), // "has subobject"
                        );

                foreach ( $datatypeLabels as $typeid => $label ) {
                        SMWDIProperty::$m_prop_types[$typeid] = array( $typeid, true );
                }

                wfRunHooks( 'smwInitProperties' );
        }

        static public function registerProperty( $id, $typeid, $label = false, $show = false ) {
                SMWDIProperty::$m_prop_types[$id] = array( $typeid, $show );

                if ( $label != false ) {
                        SMWDIProperty::$m_prop_labels[$id] = $label;
                }
        }

        static public function registerPropertyAlias( $id, $label ) {
                SMWDIProperty::$m_prop_aliases[$label] = $id;
        }

}

---