SemanticMediaWiki/includes/datavalues/SMW_DV_Time.php

Go to the documentation of this file.

<?php
class SMWTimeValue extends SMWDataValue {

        protected $m_dataitem_greg = null;
        protected $m_dataitem_jul = null;

        protected $m_wikivalue; // a suitable wiki input value

        // The following are constant (array-valued constants are not supported, hence the declaration as private static variable):
        protected static $m_months = array( 'January', 'February', 'March', 'April' , 'May' , 'June' , 'July' , 'August' , 'September' , 'October' , 'November' , 'December' );
        protected static $m_monthsshort = array( 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' );
        protected static $m_formats = array( SMW_Y => array( 'y' ), SMW_YM => array( 'y', 'm' ), SMW_MY => array( 'm', 'y' ), SMW_YDM => array( 'y', 'd', 'm' ), SMW_YMD => array( 'y', 'm', 'd' ), SMW_DMY => array( 'd', 'm', 'y' ), SMW_MDY => array( 'm', 'd', 'y' ) );

        protected static $m_tz = array( 'A' => 1, 'ACDT' => 10.5, 'ACST' => 9.5, 'ADT' => -3, 'AEDT' => 11,
                'AEST' => 10, 'AKDT' => -8, 'AKST' => -9, 'AST' => -4, 'AWDT' => 9, 'AWST' => 8,
                'B' => 2, 'BST' => 1, 'C' => 3, 'CDT' => - 5, 'CEDT' => 2, 'CEST' => 2,
                'CET' => 1, 'CST' => -6, 'CXT' => 7, 'D' => 4, 'E' => 5, 'EDT' => - 4,
                'EEDT' => 3, 'EEST' => 3, 'EET' => 2, 'EST' => - 5, 'F' => 6, 'G' => 7,
                'GMT' => 0, 'H' => 8, 'HAA' => - 3, 'HAC' => - 5, 'HADT' => - 9, 'HAE' => -4,
                'HAP' => -7, 'HAR' => -6, 'HAST' => -10, 'HAT' => -2.5, 'HAY' => -8,
                'HNA' => -4, 'HNC' => -6, 'HNE' => -5, 'HNP' => -8, 'HNR' => -7, 'HNT' => -3.5,
                'HNY' => -9, 'I' => 9, 'IST' => 1, 'K' => 10, 'L' => 11, 'M' => 12,
                'MDT' => -6, 'MESZ' => 2, 'MEZ' => 1, 'MSD' => 4, 'MSK' => 3, 'MST' => -7,
                'N' => -1, 'NDT' => -2.5, 'NFT' => 11.5, 'NST' => -3.5, 'O' => -2, 'P' => -3 ,
                'PDT' => -7, 'PST' => -8, 'Q' => - 4, 'R' => - 5, 'S' => -6, 'T' => -7,
                'U' => -8, 'UTC' => 0, 'V' => - 9, 'W' => -10, 'WDT' => 9, 'WEDT' => 1,
                'WEST' => 1, 'WET' => 0, 'WST' => 8, 'X' => -11, 'Y' => -12, 'Z' => 0 );
        protected static $m_miltz = array( 'A' => 1, 'B' => 2, 'C' => 3, 'D' => 4, 'E' => 5, 'F' => 6,
                'G' => 7, 'H' => 8, 'I' => 9, 'K' => 10, 'L' => 11, 'M' => 12, 'N' => -1, 'O' => -2,
                'P' => -3, 'Q' => -4, 'R' => -5, 'S' => -6, 'T' => -7, 'U' => -8, 'V' => -9,
                'W' => -10, 'X' => -11, 'Y' => -12, 'Z' => 0 );

        const J1582 = 2299160.5;
        const MJD_EPOCH = 2400000.5;
        const PREHISTORY = -10000;

        protected function parseUserValue( $value ) {
                $value = trim( $value ); // ignore whitespace
                $this->m_wikivalue = $value;
                if ( $this->m_caption === false ) { // Store the caption now.
                        $this->m_caption = $value;
                }
                $this->m_dataitem = null;

                $datecomponents = array();
                $calendarmodel = $era = $hours = $minutes = $seconds = $timeoffset = false;

                // Check if it's parseable by wfTimestamp when it's not a year (which is wrongly interpreted).
                if ( strlen( $value ) != 4 && wfTimestamp( TS_MW, $value ) !== false ) {
                        $timeStamp = wfTimestamp( TS_MW, $value );

                        $this->m_dataitem = new SMWDITime(
                                SMWDITime::CM_GREGORIAN,
                                substr( $timeStamp, 0, 4 ),
                                substr( $timeStamp, 4, 2 ),
                                substr( $timeStamp, 6, 2 ),
                                substr( $timeStamp, 8, 2 ),
                                substr( $timeStamp, 10, 2 ),
                                substr( $timeStamp, 12, 2 )
                        );
                }
                elseif ( $this->parseDateString( $value, $datecomponents, $calendarmodel, $era, $hours, $minutes, $seconds, $timeoffset ) ) {
                        if ( ( $calendarmodel === false ) && ( $era === false ) && ( count( $datecomponents ) == 1 ) && ( intval( end( $datecomponents ) ) >= 100000 ) ) {
                                $calendarmodel = 'JD'; // default to JD input if a single number was given as the date
                        }

                        if ( ( $calendarmodel == 'JD' ) || ( $calendarmodel == 'MJD' ) ) {
                                if ( ( $era === false ) && ( $hours === false ) && ( $timeoffset == 0 ) ) {
                                        try {
                                                $jd = floatval( reset( $datecomponents ) );
                                                if ( $calendarmodel == 'MJD' ) $jd += self::MJD_EPOCH;
                                                $this->m_dataitem = SMWDITime::newFromJD( $jd, SMWDITime::CM_GREGORIAN, SMWDITime::PREC_YMDT, $this->m_typeid );
                                        } catch ( SMWDataItemException $e ) {
                                                $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                                        }
                                } else {
                                        $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                                }
                        } else {
                                $this->setDateFromParsedValues( $datecomponents, $calendarmodel, $era, $hours, $minutes, $seconds, $timeoffset );
                        }
                }

                if ( is_null( $this->m_dataitem ) ) { // make sure that m_dataitem is set in any case
                        $this->m_dataitem = new SMWDITime( SMWDITime::CM_GREGORIAN, 32202 );
                }
        }

        protected function parseDateString( $string, &$datecomponents, &$calendarmodel, &$era, &$hours, &$minutes, &$seconds, &$timeoffset ) {
                // crude preprocessing for supporting different date separation characters;
                // * this does not allow localized time notations such as "10.34 pm"
                // * this creates problems with keywords that contain "." such as "p.m."
                // * yet "." is an essential date separation character in languages such as German
                $parsevalue = str_replace( array( '/', '.', '&nbsp;', ',' ), array( '-', ' ', ' ', ' ' ), $string );

                $matches = preg_split( "/([T]?[0-2]?[0-9]:[\:0-9]+[+\-]?[0-2]?[0-9\:]+|[a-z,A-Z]+|[0-9]+|[ ])/u", $parsevalue , -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY );
                $datecomponents = array();
                $calendarmodel = $timezoneoffset = $era = $ampm = false;
                $hours = $minutes = $seconds = $timeoffset = false;
                $unclearparts = array();
                $matchisnumber = false; // used for looking back; numbers are days/months/years by default but may be re-interpreted if certain further symbols are found
                $matchisdate = false; // used for ensuring that date parts are in one block

                foreach ( $matches as $match ) {
                        $prevmatchwasnumber = $matchisnumber;
                        $prevmatchwasdate   = $matchisdate;
                        $matchisnumber = $matchisdate = false;

                        if ( $match == ' ' ) {
                                $matchisdate = $prevmatchwasdate; // spaces in dates do not end the date
                        } elseif ( $match == '-' ) { // can only occur separately between date components
                                $datecomponents[] = $match; // we check later if this makes sense
                                $matchisdate = true;
                        } elseif ( is_numeric( $match ) &&
                                   ( $prevmatchwasdate || count( $datecomponents ) == 0 ) ) {
                                $datecomponents[] = $match;
                                $matchisnumber = true;
                                $matchisdate = true;
                        } elseif ( $era === false && in_array( $match, array( 'AD', 'CE' ) ) ) {
                                $era = '+';
                        } elseif ( $era === false && in_array( $match, array( 'BC', 'BCE' ) ) ) {
                                $era = '-';
                        } elseif ( $calendarmodel === false && in_array( $match, array( 'Gr', 'He', 'Jl', 'MJD', 'JD', 'OS' ) ) ) {
                                $calendarmodel = $match;
                        } elseif ( $ampm === false && ( strtolower( $match ) === 'am' || strtolower( $match ) === 'pm' ) ) {
                                $ampm = strtolower( $match );
                        } elseif ( $hours === false && self::parseTimeString( $match, $hours, $minutes, $seconds, $timeoffset ) ) {
                                // nothing to do
                        } elseif ( $hours !== false && $timezoneoffset === false &&
                                   array_key_exists( $match, self::$m_tz ) ) {
                                // only accept timezone if time has already been set
                                $timezoneoffset = self::$m_tz[ $match ];
                        } elseif ( $prevmatchwasnumber && $hours === false && $timezoneoffset === false &&
                                   array_key_exists( $match, self::$m_miltz ) &&
                                   self::parseMilTimeString( end( $datecomponents ), $hours, $minutes, $seconds ) ) {
                                        // military timezone notation is found after a number -> re-interpret the number as military time
                                        array_pop( $datecomponents );
                                        $timezoneoffset = self::$m_miltz[ $match ];
                        } elseif ( ( $prevmatchwasdate || count( $datecomponents ) == 0 ) &&
                                   $this->parseMonthString( $match, $monthname ) ) {
                                $datecomponents[] = $monthname;
                                $matchisdate = true;
                        } elseif ( $prevmatchwasnumber && $prevmatchwasdate && in_array( $match, array( 'st', 'nd', 'rd', 'th' ) ) ) {
                                $datecomponents[] = 'd' . strval( array_pop( $datecomponents ) ); // must be a day; add standard marker
                                $matchisdate = true;
                        } else {
                                $unclearparts[] = $match;
                        }
                }
                // Useful for debugging:
                //              print "\n\n Results \n\n";
                //              debug_zval_dump( $datecomponents );
                //              print "\ncalendarmodel: $calendarmodel   \ntimezoneoffset: $timezoneoffset  \nera: $era  \nampm: $ampm  \nh: $hours  \nm: $minutes  \ns:$seconds  \ntimeoffset: $timeoffset  \n";
                //              debug_zval_dump( $unclearparts );

                // Abort if we found unclear or over-specific information:
                if ( count( $unclearparts ) != 0 ||
                     ( $timezoneoffset !== false && $timeoffset !== false ) ) {
                        $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                        return false;
                }

                $timeoffset = $timeoffset + $timezoneoffset;
                // Check if the a.m. and p.m. information is meaningful

                if ( $ampm !== false && ( $hours > 12 || $hours == 0 ) ) { // Note: the == 0 check subsumes $hours===false
                        $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                        return false;
                } elseif ( $ampm == 'am' && $hours == 12 ) {
                        $hours = 0;
                } elseif ( $ampm == 'pm' && $hours < 12 ) {
                        $hours += 12;
                }

                return true;
        }

        public static function parseTimeString( $string, &$hours, &$minutes, &$seconds, &$timeoffset ) {
                if ( !preg_match( "/^[T]?([0-2]?[0-9]):([0-5][0-9])(:[0-5][0-9])?(([+\-][0-2]?[0-9])(:(30|00))?)?$/u", $string, $match ) ) {
                        return false;
                } else {
                        $nhours = intval( $match[1] );
                        $nminutes = $match[2] ? intval( $match[2] ) : false;
                        if ( ( count( $match ) > 3 ) && ( $match[3] !== '' ) ) {
                                $nseconds = intval( substr( $match[3], 1 ) );
                        } else {
                                $nseconds = false;
                        }
                        if ( ( $nhours < 25 ) && ( ( $nhours < 24 ) || ( $nminutes + $nseconds == 0 ) ) ) {
                                $hours = $nhours;
                                $minutes = $nminutes;
                                $seconds = $nseconds;
                                if ( ( count( $match ) > 5 ) && ( $match[5] !== '' ) ) {
                                        $timeoffset = intval( $match[5] );
                                        if ( ( count( $match ) > 7 ) && ( $match[7] == '30' ) ) {
                                                $timeoffset += 0.5;
                                        }
                                } else {
                                        $timeoffset = false;
                                }
                                return true;
                        } else {
                                return false;
                        }
                }
        }

        protected static function parseMilTimeString( $string, &$hours, &$minutes, &$seconds ) {
                if ( !preg_match( "/^([0-2][0-9])([0-5][0-9])([0-5][0-9])?$/u", $string, $match ) ) {
                        return false;
                } else {
                        $nhours = intval( $match[1] );
                        $nminutes = $match[2] ? intval( $match[2] ) : false;
                        $nseconds = ( ( count( $match ) > 3 ) && $match[3] ) ? intval( $match[3] ) : false;
                        if ( ( $nhours < 25 ) && ( ( $nhours < 24 ) || ( $nminutes + $nseconds == 0 ) ) ) {
                                $hours = $nhours;
                                $minutes = $nminutes;
                                $seconds = $nseconds;
                                return true;
                        } else {
                                return false;
                        }
                }
        }

        protected static function parseMonthString( $string, &$monthname ) {
                global $smwgContLang;
                $monthnum = $smwgContLang->findMonth( $string ); // takes precedence over English month names!
                if ( $monthnum !== false ) {
                        $monthnum -= 1;
                } else {
                        $monthnum = array_search( $string, self::$m_months ); // check English names
                }
                if ( $monthnum !== false ) {
                        $monthname = self::$m_monthsshort[ $monthnum ];
                        return true;
                } elseif ( array_search( $string, self::$m_monthsshort ) !== false ) {
                        $monthname = $string;
                        return true;
                } else {
                        return false;
                }
        }

        protected function interpretDateComponents( $datecomponents, &$date ) {
                global $smwgContLang;
                // The following code segment creates a bit vector to encode
                // which role each digit of the entered date can take (day,
                // year, month). The vector starts with 1 and contains three
                // bits per date component, set ot true whenever this component
                // could be a month, a day, or a year (this is the order).
                // Examples:
                //   100 component could only be a month
                //   010 component could only be a day
                //   001 component could only be a year
                //   011 component could be a day or a year but no month etc.
                // For three components, we thus get a 10 digit bit vector.
                $datevector = 1;
                $propercomponents = array();
                $justfounddash = true; // avoid two dashes in a row, or dashes at the end
                $error = false;
                $numvalue = 0;
                foreach ( $datecomponents as $component ) {
                        if ( $component == "-" ) {
                                if ( $justfounddash ) {
                                        $error = true;
                                        break;
                                }
                                $justfounddash = true;
                        } else {
                                $justfounddash = false;
                                $datevector = ( $datevector << 3 ) | $this->checkDateComponent( $component, $numvalue );
                                $propercomponents[] = $numvalue;
                        }
                }
                if ( ( $error ) || ( $justfounddash ) || ( count( $propercomponents ) == 0 ) || ( count( $propercomponents ) > 3 ) ) {
                        $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                        return false;
                }
                // Now use the bitvector to find the preferred interpretation of the date components:
                $dateformats = $smwgContLang->getDateFormats();
                $date = array( 'y' => false, 'm' => false, 'd' => false );
                foreach ( $dateformats[count( $propercomponents ) - 1] as $formatvector ) {
                        if ( !( ~$datevector & $formatvector ) ) { // check if $formatvector => $datevector ("the input supports the format")
                                $i = 0;
                                foreach ( self::$m_formats[$formatvector] as $fieldname ) {
                                        $date[$fieldname] = $propercomponents[$i];
                                        $i += 1;
                                }
                                break;
                        }
                }
                if ( $date['y'] === false ) { // no band matches the entered date
                        $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                        return false;
                }
                return true;
        }

        protected function setDateFromParsedValues( $datecomponents, $calendarmodel, $era, $hours, $minutes, $seconds, $timeoffset ) {
                $date = false;
                if ( !$this->interpretDateComponents( $datecomponents, $date ) ) {
                        return false;
                }

                // Handle BC: the year is negative.
                if ( ( $era == '-' ) && ( $date['y'] > 0 ) ) { // see class documentation on BC, "year 0", and ISO conformance ...
                        $date['y'] = -( $date['y'] );
                }
                // Old Style is a special case of Julian calendar model where the change of the year was 25 March:
                if ( ( $calendarmodel == 'OS' ) &&
                     ( ( $date['m'] < 3 ) || ( ( $date['m'] == 3 ) && ( $date['d'] < 25 ) ) ) ) {
                        $date['y']++;
                }

                $calmod = $this->getCalendarModel( $calendarmodel, $date['y'], $date['m'], $date['d'] );
                try {
                        $this->m_dataitem = new SMWDITime( $calmod, $date['y'], $date['m'], $date['d'], $hours, $minutes, $seconds, $this->m_typeid );
                } catch ( SMWDataItemException $e ) {
                        $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                        return false;
                }

                // Having more than years or specifying a calendar model does
                // not make sense for prehistoric dates, and our calendar
                // conversion would not be reliable if JD numbers get too huge:
                if ( ( $date['y'] <= self::PREHISTORY ) &&
                     ( ( $this->m_dataitem->getPrecision() > SMWDITime::PREC_Y ) || ( $calendarmodel !== false ) ) ) {
                        $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                        return false;
                }
                if ( $timeoffset != 0 ) {
                        $newjd = $this->m_dataitem->getJD() - $timeoffset / 24;
                        try {
                                $this->m_dataitem = SMWDITime::newFromJD( $newjd, $calmod, $this->m_dataitem->getPrecision(), $this->m_typeid );
                        } catch ( SMWDataItemException $e ) {
                                $this->addError( wfMsgForContent( 'smw_nodatetime', $this->m_wikivalue ) );
                                return false;
                        }
                }
                return true;
        }

        protected static function checkDateComponent( $component, &$numvalue ) {
                if ( $component === '' ) { // should not happen
                        $numvalue = 0;
                        return 0;
                } elseif ( is_numeric( $component ) ) {
                        $numvalue = intval( $component );
                        if ( ( $numvalue >= 1 ) && ( $numvalue <= 12 ) ) {
                                return SMW_DAY_MONTH_YEAR; // can be a month, day or year
                        } elseif ( ( $numvalue >= 1 ) && ( $numvalue <= 31 ) ) {
                                return SMW_DAY_YEAR; // can be day or year
                        } else { // number can just be a year
                                return SMW_YEAR;
                        }
                } elseif ( $component { 0 } == 'd' ) { // already marked as day
                        if ( is_numeric( substr( $component, 1 ) ) ) {
                                $numvalue = intval( substr( $component, 1 ) );
                                return ( ( $numvalue >= 1 ) && ( $numvalue <= 31 ) ) ? SMW_DAY : 0;
                        } else {
                                return 0;
                        }
                } else {
                        $monthnum = array_search( $component, self::$m_monthsshort );
                        if ( $monthnum !== false ) {
                                $numvalue = $monthnum + 1;
                                return SMW_MONTH;
                        } else {
                                return 0;
                        }
                }
        }

        protected function getCalendarModel( $presetmodel, $year, $month, $day ) {
                if ( $presetmodel == 'OS' ) { // Old Style is a notational convention of Julian dates only
                        $presetmodel = 'Jl';
                }
                if ( $presetmodel == 'Gr' ) {
                        return SMWDITime::CM_GREGORIAN;
                } elseif ( $presetmodel == 'Jl' ) {
                        return SMWDITime::CM_JULIAN;
                }
                if ( ( $year > 1582 ) ||
                     ( ( $year == 1582 ) && ( $month > 10 ) ) ||
                     ( ( $year == 1582 ) && ( $month == 10 ) && ( $day > 4 ) ) ) {
                        return SMWDITime::CM_GREGORIAN;
                } elseif ( $year > self::PREHISTORY ) {
                        return SMWDITime::CM_JULIAN;
                } else {
                        // proleptic Julian years at some point deviate from the count of complete revolutions of the earth around the sun
                        // hence assume that earlier date years are Gregorian (where this effect is very weak only)
                        // This is mostly for internal use since we will not allow users to specify calendar models at this scale
                        return SMWDITime::CM_GREGORIAN;
                }
        }

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

        public function getShortWikiText( $linked = NULL ) {
                return ( $this->m_caption !== false ) ? $this->m_caption : $this->getPreferredCaption();
        }

        public function getShortHTMLText( $linker = NULL ) {
                return $this->getShortWikiText( $linker ); // safe in HTML
        }

        public function getLongWikiText( $linked = NULL ) {
                return  $this->isValid() ? $this->getPreferredCaption() : $this->getErrorText();
        }

        public function getLongHTMLText( $linker = NULL ) {
                return $this->getLongWikiText( $linker ); // safe in HTML
        }

        public function getWikiValue() {
                return $this->m_wikivalue ? $this->m_wikivalue : $this->getPreferredCaption();
        }

        public function isNumeric() {
                return true;
        }

        public function getYear( $calendarmodel = SMWDITime::CM_GREGORIAN ) {
                $di = $this->getDataForCalendarModel( $calendarmodel );
                if ( !is_null( $di ) ) {
                        return $di->getYear();
                } else {
                        return false;
                }
        }

        public function getMonth( $calendarmodel = SMWDITime::CM_GREGORIAN, $default = 1 ) {
                $di = $this->getDataForCalendarModel( $calendarmodel );
                if ( !is_null( $di ) ) {
                        return ( $di->getPrecision() >= SMWDITime::PREC_YM ) ? $di->getMonth() : $default;
                } else {
                        return false;
                }
        }

        public function getDay( $calendarmodel = SMWDITime::CM_GREGORIAN, $default = 1 ) {
                $di = $this->getDataForCalendarModel( $calendarmodel );
                if ( !is_null( $di ) ) {
                        return ( $di->getPrecision() >= SMWDITime::PREC_YMD ) ? $di->getDay() : $default;
                } else {
                        return false;
                }
        }

        public function getTimeString( $default = '00:00:00' ) {
                if ( $this->m_dataitem->getPrecision() < SMWDITime::PREC_YMDT ) {
                        return $default;
                } else {
                        return sprintf( "%02d", $this->m_dataitem->getHour() ) . ':' .
                               sprintf( "%02d", $this->m_dataitem->getMinute() ) . ':' .
                               sprintf( "%02d", $this->m_dataitem->getSecond() );
                }
        }

        public function getXMLSchemaDate( $mindefault = true ) {
                return $this->getISO8601Date( $mindefault );
        }

        public function getISO8601Date( $mindefault = true ) {
                $result = ( $this->getYear() > 0 ) ? '' : '-';
                $monthnum = $this->getMonth( SMWDITime::CM_GREGORIAN, ( $mindefault ? 1 : 12 ) );
                $result .= str_pad( $this->getYear(), 4, "0", STR_PAD_LEFT ) .
                          '-' . str_pad( $monthnum, 2, "0", STR_PAD_LEFT );
                if ( !$mindefault && ( $this->m_dataitem->getPrecision() < SMWDITime::PREC_YMD ) ) {
                        $maxday = SMWDITime::getDayNumberForMonth( $monthnum, $this->getYear(), SMWDITime::CM_GREGORIAN );
                        $result .= '-' . str_pad( $this->getDay( SMWDITime::CM_GREGORIAN, $maxday ), 2, "0", STR_PAD_LEFT );
                } else {
                        $result .= '-' . str_pad( $this->getDay(), 2, "0", STR_PAD_LEFT );
                }
                if ( $this->m_dataitem->getPrecision() == SMWDITime::PREC_YMDT ) {
                        $result .= 'T' . $this->getTimeString( ( $mindefault ? '00:00:00' : '23:59:59' ) );
                }
                return $result;
        }

        public function getMediaWikiDate() {
                global $wgContLang;

                $dataitem = $this->m_dataitem;
                $precision = $dataitem->getPrecision();

                $year = $this->getYear();
                if ( $year < 0 || $year > 9999 ) $year = '0000';
                $year = str_pad( $year, 4, "0", STR_PAD_LEFT );

                if ( $precision <= SMWDITime::PREC_Y ) {
                        return $wgContLang->formatNum( $year, true );
                }

                $month = str_pad( $this->getMonth( SMWDITime::CM_GREGORIAN ), 2, "0", STR_PAD_LEFT );
                $day = str_pad( $this->getDay( SMWDITime::CM_GREGORIAN ), 2, "0", STR_PAD_LEFT );

                if ( $precision <= SMWDITime::PREC_YMD ) {
                        return $wgContLang->date( "$year$month$day" . '000000', false, false );
                }

                $time = str_replace( ':', '', $this->getTimeString() );
                return $wgContLang->timeAndDate( "$year$month$day$time", false, false );
        }

        protected function getDataForCalendarModel( $calendarmodel ) {
                if ( $this->m_dataitem->getYear() <= self::PREHISTORY ) {
                        return ( $this->m_dataitem->getCalendarModel() == $calendarmodel ) ? $this->m_dataitem : null;
                } elseif ( $calendarmodel == SMWDITime::CM_GREGORIAN ) {
                        if ( $this->m_dataitem_greg === null ) {
                                $this->m_dataitem_greg = $this->m_dataitem->getForCalendarModel( SMWDITime::CM_GREGORIAN );
                        }
                        return $this->m_dataitem_greg;
                } else {
                        if ( $this->m_dataitem_jul === null ) {
                                $this->m_dataitem_jul = $this->m_dataitem->getForCalendarModel( SMWDITime::CM_JULIAN );
                        }
                        return $this->m_dataitem_jul;
                }
        }

        public function getCaptionFromDataitem( SMWDITime $dataitem ) {
                global $smwgContLang;
                if ( $dataitem->getYear() > 0 ) {
                        $cestring = '';
                        $result = number_format( $dataitem->getYear(), 0, '.', '' ) . ( $cestring ? ( ' ' . $cestring ) : '' );
                } else {
                        $bcestring = 'BC';
                        $result = number_format( -( $dataitem->getYear() ), 0, '.', '' ) . ( $bcestring ? ( ' ' . $bcestring ) : '' );
                }
                if ( $dataitem->getPrecision() >= SMWDITime::PREC_YM ) {
                        $result = $smwgContLang->getMonthLabel( $dataitem->getMonth() ) . " " . $result;
                }
                if ( $dataitem->getPrecision() >= SMWDITime::PREC_YMD ) {
                        $result = $dataitem->getDay() . " " . $result;
                }
                if ( $dataitem->getPrecision() >= SMWDITime::PREC_YMDT ) {
                        $result .= " " . $this->getTimeString();
                }
                return $result;
        }

        protected function getPreferredCaption() {
                $year = $this->m_dataitem->getYear();

                if ( strtoupper( $this->m_outformat ) === 'ISO' || $this->m_outformat == '-' ) {
                        return $this->getISO8601Date();
                } elseif ( strtoupper( $this->m_outformat ) === 'MEDIAWIKI' ) {
                        return $this->getMediaWikiDate();
                } elseif ( strtoupper( $this->m_outformat ) === 'SORTKEY' ) {
                        return $this->m_dataitem->getSortKey();
                } else {
                        if ( $year <= self::PREHISTORY ) {
                                return $this->getCaptionFromDataitem( $this->m_dataitem ); // should be Gregorian, but don't bother here
                        } elseif ( $this->m_dataitem->getJD() < self::J1582 ) {
                                return $this->getCaptionFromDataitem( $this->getDataForCalendarModel( SMWDITime::CM_JULIAN ) );
                        } else {
                                return $this->getCaptionFromDataitem( $this->getDataForCalendarModel( SMWDITime::CM_GREGORIAN ) );
                        }
                }
        }

}

---