1: <?php
  2: 
  3:     /**
  4:      * Class QDateTimeSpan: This class is used to calculate the time difference between two dates (including time)
  5:      *
  6:      * @property-read int $Years   Years in the calculated timespan
  7:      * @property-read int $Months  Months in the calculated timespan
  8:      * @property-read int $Days    Days in the calculated timespan
  9:      * @property-read int $Hours   Hours in the calculated timespan
 10:      * @property-read int $Minutes Minutes in the calculated timespan
 11:      * @property int      $Seconds Number seconds which correspond to the time difference
 12:      */
 13:     class QDateTimeSpan extends QBaseClass{
 14:         /** @var int Seconds variable which will be used to calculate the timespan */
 15:         protected $intSeconds;
 16: 
 17:         /* From: http://tycho.usno.navy.mil/leapsec.html:
 18:             This definition was ratified by the Eleventh General Conference on Weights and Measures in 1960.
 19:             Reference to the year 1900  does not mean that this is the epoch of a mean solar day of 86,400 seconds.
 20:             Rather, it is the epoch of the tropical year of 31,556,925.9747 seconds of ephemeris time.
 21:             Ephemeris Time (ET) was defined as the measure of time that brings the observed positions of the celestial
 22:             bodies into accord with the Newtonian dynamical theory of motion.
 23:         */
 24:         /** Number of seconds in an year */
 25:         const SecondsPerYear    = 31556926;
 26:         
 27:         // Assume 30 Days per Month
 28:         /** Number of seconds in a month (assuming 30 days in a month) */
 29:         const SecondsPerMonth   = 2592000;
 30:         /** Number of seconds per day */
 31:         const SecondsPerDay     = 86400;
 32:         /** Number of seconds in an hour */
 33:         const SecondsPerHour    = 3600;
 34:         /** Number of seconds per minute */
 35:         const SecondsPerMinute  = 60;
 36: 
 37:         /**
 38:          * Constructor for the QDateTimeSpan class
 39:          *
 40:          * @param int $intSeconds Number of seconds to set for this QDateTimeSpan
 41:          */
 42:         public function __construct($intSeconds = 0) {
 43:             $this->intSeconds = $intSeconds;
 44:         }
 45: 
 46:         /*
 47:             Is functions
 48:         */ 
 49:         
 50:         /**
 51:          * Checks if the current DateSpan is positive
 52:          *
 53:          * @return boolean
 54:          */
 55:         public function IsPositive(){
 56:             return ($this->intSeconds > 0);
 57:         }
 58: 
 59:         /**
 60:          * Checks if the current DateSpan is negative
 61:          *
 62:          * @return boolean
 63:          */
 64:         public function IsNegative(){
 65:             return ($this->intSeconds < 0);
 66:         }
 67: 
 68:         /**
 69:          * Checks if the current DateSpan is zero
 70:          *
 71:          * @return boolean
 72:          */
 73:         public function IsZero(){
 74:             return ($this->intSeconds == 0);
 75:         }
 76:         
 77:         /**
 78:          * Calculates the difference between this DateSpan and another DateSpan
 79:          *
 80:          * @param QDateTimeSpan $dtsSpan
 81:          * @return new QDateTimeSpan
 82:          */
 83:         public function Difference(QDateTimeSpan $dtsSpan){
 84:             $intDifference = $this->Seconds - $dtsSpan->Seconds;
 85:             $dtsDateSpan = new QDateTimeSpan();
 86:             $dtsDateSpan->AddSeconds($intDifference);
 87:             return $dtsDateSpan;
 88:         }
 89:         
 90:         /*
 91:             SetFrom methods
 92:         */
 93:         
 94:         /**
 95:          * Sets current QDateTimeSpan to the difference between two QDateTime objects
 96:          *
 97:          * @param QDateTime $dttFrom
 98:          * @param QDateTime $dttTo
 99:          */
100:         public function SetFromQDateTime(QDateTime $dttFrom, QDateTime $dttTo){
101:             $this->Add($dttFrom->Difference($dttTo));
102:         }
103:         
104:         /*
105:             Add methods
106:         */  
107:         
108:         /**
109:          * Adds an amount of seconds to the current QDateTimeSpan
110:          *
111:          * @param int $intSeconds
112:          */
113:         public function AddSeconds($intSeconds){
114:             $this->intSeconds = $this->intSeconds + $intSeconds;
115:         }
116:         
117:         /**
118:          * Adds an amount of minutes to the current QDateTimeSpan
119:          *
120:          * @param int $intMinutes
121:          */
122:         public function AddMinutes($intMinutes){
123:             $this->intSeconds = $this->intSeconds + ($intMinutes * QDateTimeSpan::SecondsPerMinute);
124:         }
125:         
126:         /**
127:          * Adds an amount of hours to the current QDateTimeSpan
128:          *
129:          * @param int $intHours
130:          */
131:         public function AddHours($intHours){
132:             $this->intSeconds = $this->intSeconds + ($intHours * QDateTimeSpan::SecondsPerHour);
133:         }
134:         
135:         /**
136:          * Adds an amount of days to the current QDateTimeSpan
137:          *
138:          * @param int $intDays
139:          */
140:         public function AddDays($intDays){
141:             $this->intSeconds = $this->intSeconds + ($intDays * QDateTimeSpan::SecondsPerDay);
142:         }
143:         
144:         /**
145:          * Adds an amount of months to the current QDateTimeSpan
146:          *
147:          * @param int $intMonths
148:          */
149:         public function AddMonths($intMonths){
150:             $this->intSeconds = $this->intSeconds + ($intMonths * QDateTimeSpan::SecondsPerMonth);
151:         }
152:         
153:         /* 
154:             Get methods
155:         */
156:         
157:         /**
158:          * Calculates the total whole years in the current QDateTimeSpan
159:          *
160:          * @return int
161:          */
162:         protected function GetYears() {
163:             $intSecondsPerYear = ($this->IsPositive()) ? QDateTimeSpan::SecondsPerYear : ((-1) * QDateTimeSpan::SecondsPerYear);
164:             $intYears = floor($this->intSeconds / $intSecondsPerYear);
165:             if ($this->IsNegative()) $intYears = (-1) * $intYears;
166:             return $intYears;
167:         }
168: 
169:         /**
170:          * Calculates the total whole months in the current QDateTimeSpan
171:          *
172:          * @return int
173:          */
174:         protected function GetMonths(){
175:             $intSecondsPerMonth = ($this->IsPositive()) ? QDateTimeSpan::SecondsPerMonth : ((-1) * QDateTimeSpan::SecondsPerMonth);
176:             $intMonths = floor($this->intSeconds / $intSecondsPerMonth);
177:             if($this->IsNegative()) $intMonths = (-1) * $intMonths;
178:             return $intMonths;
179:         }
180:         
181:         /**
182:          * Calculates the total whole days in the current QDateTimeSpan
183:          *
184:          * @return int
185:          */
186:         protected function GetDays(){
187:             $intSecondsPerDay = ($this->IsPositive()) ? QDateTimeSpan::SecondsPerDay : ((-1) * QDateTimeSpan::SecondsPerDay);
188:             $intDays = floor($this->intSeconds / $intSecondsPerDay);
189:             if($this->IsNegative()) $intDays = (-1) * $intDays;
190:             return $intDays;
191:         }
192: 
193:         /**
194:          * Calculates the total whole hours in the current QDateTimeSpan
195:          *
196:          * @return int
197:          */
198:         protected function GetHours(){
199:             $intSecondsPerHour = ($this->IsPositive()) ? QDateTimeSpan::SecondsPerHour : ((-1) * QDateTimeSpan::SecondsPerHour);
200:             $intHours = floor($this->intSeconds / $intSecondsPerHour);
201:             if($this->IsNegative()) $intHours = (-1) * $intHours;
202:             return $intHours;
203:         }
204:         
205:         /**
206:          * Calculates the total whole minutes in the current QDateTimeSpan
207:          *
208:          * @return int
209:          */
210:         protected function GetMinutes(){
211:             $intSecondsPerMinute = ($this->IsPositive()) ? QDateTimeSpan::SecondsPerMinute : ((-1) * QDateTimeSpan::SecondsPerMinute);
212:             $intMinutes = floor($this->intSeconds / $intSecondsPerMinute);
213:             if($this->IsNegative()) $intMinutes = (-1) * $intMinutes;
214:             return $intMinutes;
215:         } 
216:         
217:         /*
218:             DateMathSettings
219:         */
220:         
221:         /**
222:          * Adds a QDateTimeSpan to current QDateTimeSpan
223:          *
224:          * @param QDateTimeSpan $dtsSpan
225:          */
226:         public function Add(QDateTimeSpan $dtsSpan){
227:             $this->intSeconds = $this->intSeconds + $dtsSpan->Seconds;
228:         }
229:         
230:         /**
231:          * Subtracts a QDateTimeSpan to current QDateTimeSpan
232:          *
233:          * @param QDateTimeSpan $dtsSpan
234:          */
235:         public function Subtract(QDateTimeSpan $dtsSpan){
236:             $this->intSeconds = $this->intSeconds - $dtsSpan->Seconds;
237:         }
238: 
239:         /**
240:          * Returns the time difference in approximate duration
241:          * e.g. "about 4 months" or "4 minutes"
242:          *
243:          * The QDateTime class uses this function in its 'Age' property accessor
244:          *
245:          * @return null|string
246:          */
247:         public function SimpleDisplay(){
248:             $arrTimearray = $this->GetTimearray();
249:             $strToReturn = null;
250: 
251:             if($arrTimearray['Years'] != 0) {
252:                 $strFormat = ($arrTimearray['Years'] != 1) ? QApplication::Translate('about %s years') :  QApplication::Translate('a year');
253:                 $strToReturn = sprintf($strFormat, $arrTimearray['Years']);
254:             }
255:             elseif($arrTimearray['Months'] != 0){
256:                 $strFormat = ($arrTimearray['Months'] != 1) ? QApplication::Translate('about %s months') : QApplication::Translate('a month');
257:                 $strToReturn = sprintf($strFormat,$arrTimearray['Months']);
258:             }
259:             elseif($arrTimearray['Days'] != 0){
260:                 $strFormat = ($arrTimearray['Days'] != 1) ? QApplication::Translate('about %s days') : QApplication::Translate('a day');
261:                 $strToReturn = sprintf($strFormat,$arrTimearray['Days']);
262:             }
263:             elseif($arrTimearray['Hours'] != 0){
264:                 $strFormat = ($arrTimearray['Hours'] != 1) ? QApplication::Translate('about %s hours') : QApplication::Translate('an hour');
265:                 $strToReturn = sprintf($strFormat,$arrTimearray['Hours']);
266:             }
267:             elseif($arrTimearray['Minutes'] != 0){
268:                 $strFormat = ($arrTimearray['Minutes'] != 1) ? QApplication::Translate('%s minutes') : QApplication::Translate('a minute');
269:                 $strToReturn = sprintf($strFormat,$arrTimearray['Minutes']);
270:             }
271:             elseif($arrTimearray['Seconds'] != 0 ){
272:                 $strFormat = ($arrTimearray['Seconds'] != 1) ? QApplication::Translate('%s seconds') : QApplication::Translate('a second');
273:                 $strToReturn = sprintf($strFormat,$arrTimearray['Seconds']);
274:             }
275:             
276:             return $strToReturn;
277:         }
278:         
279:         
280:         /**
281:          * Return an array of timeunints
282:          *
283:          * @return array of timeunits
284:          */
285:         protected function GetTimearray(){
286:             $intSeconds = abs($this->intSeconds);
287: 
288:             $intYears = floor($intSeconds / QDateTimeSpan::SecondsPerYear);
289:             $intSeconds = $intSeconds - ($intYears * QDateTimeSpan::SecondsPerYear);
290: 
291:             $intMonths = floor($intSeconds / QDateTimeSpan::SecondsPerMonth);
292:             $intSeconds = $intSeconds - ($intMonths * QDateTimeSpan::SecondsPerMonth);
293: 
294:             $intDays = floor($intSeconds / QDateTimeSpan::SecondsPerDay);
295:             $intSeconds = $intSeconds - ($intDays * QDateTimeSpan::SecondsPerDay);
296:             
297:             $intHours = floor($intSeconds / QDateTimeSpan::SecondsPerHour);
298:             $intSeconds = $intSeconds - ($intHours * QDateTimeSpan::SecondsPerHour);
299:             
300:             $intMinutes = floor($intSeconds / QDateTimeSpan::SecondsPerMinute);
301:             $intSeconds = $intSeconds - ($intMinutes * QDateTimeSpan::SecondsPerMinute);
302: 
303:             if($this->IsNegative()){
304:                 // Turn values to negative
305:                 $intYears = ((-1) * $intYears);
306:                 $intMonths = ((-1) * $intMonths);
307:                 $intDays = ((-1) * $intDays);
308:                 $intHours = ((-1) * $intHours);
309:                 $intMinutes = ((-1) * $intMinutes);
310:                 $intSeconds = ((-1) * $intSeconds);
311:             }
312: 
313:             return array('Years' => $intYears, 'Months' => $intMonths, 'Days' => $intDays, 'Hours' => $intHours, 'Minutes' => $intMinutes,'Seconds' => $intSeconds);
314:         }
315: 
316:         /**
317:          * Override method to perform a property "Get"
318:          * This will get the value of $strName
319:          * PHP magic method
320:          *
321:          * @param string $strName Name of the property to get
322:          *
323:          * @return mixed the returned property
324:          * @throws Exception|QCallerException
325:          */
326:         
327:         public function __get($strName) {
328:             switch ($strName) {
329:                 case 'Years': return $this->GetYears();
330:                 case 'Months': return $this->GetMonths();
331:                 case 'Days': return $this->GetDays();
332:                 case 'Hours': return $this->GetHours();
333:                 case 'Minutes': return $this->GetMinutes();
334:                 case 'Seconds': return $this->intSeconds;
335:                 case 'Timearray' : return ($this->GetTimearray());
336: 
337:                 default:
338:                     try {
339:                         return parent::__get($strName);
340:                     } catch (QCallerException $objExc) {
341:                         $objExc->IncrementOffset();
342:                         throw $objExc;
343:                     }
344:             }
345:         }
346: 
347:         /**
348:          * Override method to perform a property "Set"
349:          * This will set the property $strName to be $mixValue
350:          * PHP magic method
351:          *
352:          * @param string $strName  Name of the property to set
353:          * @param string $mixValue New value of the property
354:          *
355:          * @return mixed the property that was set
356:          * @throws Exception|QCallerException
357:          */
358:     
359:         public function __set($strName, $mixValue) {
360:             try {
361:                 switch ($strName) {
362:                     case 'Seconds':
363:                         return ($this->intSeconds = QType::Cast($mixValue, QType::Integer));
364:                     default:
365:                         return (parent::__set($strName, $mixValue));
366:                 }               
367:             } catch (QCallerException $objExc) {
368:                 $objExc->IncrementOffset();
369:                 throw $objExc;
370:             }
371:         }
372:     }