BVB Source Codes

The latest thinkphp v5.2 work order system Show phprpc_date.php Source code

Return Download The latest thinkphp v5.2 work order system: download phprpc_date.php Source code - Download The latest thinkphp v5.2 work order system Source code - Type:.php
  1. <?php
  2. /**********************************************************\
  3. |                                                          |
  4. | The implementation of PHPRPC Protocol 3.0                |
  5. |                                                          |
  6. | phprpc_date.php                                          |
  7. |                                                          |
  8. | Release 3.0.1                                            |
  9. | Copyright by Team-PHPRPC                                 |
  10. |                                                          |
  11. | WebSite:  http://www.phprpc.org/                         |
  12. |           http://www.phprpc.net/                         |
  13. |           http://www.phprpc.com/                         |
  14. |           http://sourceforge.net/projects/php-rpc/       |
  15. |                                                          |
  16. | Authors:  Ma Bingyao <andot@ujn.edu.cn>                  |
  17. |                                                          |
  18. | This file may be distributed and/or modified under the   |
  19. | terms of the GNU General Public License (GPL) version    |
  20. | 2.0 as published by the Free Software Foundation and     |
  21. | appearing in the included file LICENSE.                  |
  22. |                                                          |
  23. \**********************************************************/
  24.  
  25. /* PHPRPC_Date Class for PHP.
  26.  *
  27.  * Copyright: Ma Bingyao <andot@ujn.edu.cn>
  28.  * Version: 1.2
  29.  * LastModified: Apr 12, 2010
  30.  * This library is free.  You can redistribute it and/or modify it under GPL.
  31.  */
  32.  
  33. class PHPRPC_Date {
  34.  
  35. // public fields
  36.  
  37.     var $year = 1;
  38.     var $month = 1;
  39.     var $day = 1;
  40.     var $hour = 0;
  41.     var $minute = 0;
  42.     var $second = 0;
  43.     var $millisecond = 0;
  44.  
  45. // constructor
  46.  
  47.     function PHPRPC_Date() {
  48.         $num = func_num_args();
  49.         $time = false;
  50.         if ($num == 0) {
  51.             $time = getdate();
  52.         }
  53.         if ($num == 1) {
  54.             $arg = func_get_arg(0);
  55.             if (is_int($arg)) {
  56.                 $time = getdate($arg);
  57.             }
  58.             elseif (is_string($arg)) {
  59.                 $time = getdate(strtotime($arg));
  60.             }
  61.         }
  62.         if (is_array($time)) {
  63.             $this->year = $time['year'];
  64.             $this->month = $time['mon'];
  65.             $this->day = $time['mday'];
  66.             $this->hour = $time['hours'];
  67.             $this->minute = $time['minutes'];
  68.             $this->second = $time['seconds'];
  69.         }
  70.     }
  71.  
  72. // public instance methods
  73.  
  74.     function addMilliseconds($milliseconds) {
  75.         if (!is_int($milliseconds)) return false;
  76.         if ($milliseconds == 0) return true;
  77.         $millisecond = $this->millisecond + $milliseconds;
  78.         $milliseconds = $millisecond % 1000;
  79.         if ($milliseconds < 0) {
  80.             $milliseconds += 1000;
  81.         }
  82.         $seconds = (int)(($millisecond - $milliseconds) / 1000);
  83.         $millisecond = (int)$milliseconds;
  84.         if ($this->addSeconds($seconds)) {
  85.             $this->millisecond = (int)$milliseconds;
  86.             return true;
  87.         }
  88.         else {
  89.             return false;
  90.         }
  91.     }
  92.  
  93.     function addSeconds($seconds) {
  94.         if (!is_int($seconds)) return false;
  95.         if ($seconds == 0) return true;
  96.         $second = $this->second + $seconds;
  97.         $seconds = $second % 60;
  98.         if ($seconds < 0) {
  99.             $seconds += 60;
  100.         }
  101.         $minutes = (int)(($second - $seconds) / 60);
  102.         if ($this->addMinutes($minutes)) {
  103.             $this->second = (int)$seconds;
  104.             return true;
  105.         }
  106.         else {
  107.             return false;
  108.         }
  109.     }
  110.  
  111.     function addMinutes($minutes) {
  112.         if (!is_int($minutes)) return false;
  113.         if ($minutes == 0) return true;
  114.         $minute = $this->minute + $minutes;
  115.         $minutes = $minute % 60;
  116.         if ($minutes < 0) {
  117.             $minutes += 60;
  118.         }
  119.         $hours = (int)(($minute - $minutes) / 60);
  120.         if ($this->addHours($hours)) {
  121.             $this->minute = (int)$minutes;
  122.             return true;
  123.         }
  124.         else {
  125.             return false;
  126.         }
  127.     }
  128.  
  129.     function addHours($hours) {
  130.         if (!is_int($hours)) return false;
  131.         if ($hours == 0) return true;
  132.         $hour = $this->hour + $hours;
  133.         $hours = $hour % 24;
  134.         if ($hours < 0) {
  135.             $hours += 24;
  136.         }
  137.         $days = (int)(($hour - $hours) / 24);
  138.         if ($this->addDays($days)) {
  139.             $this->hour = (int)$hours;
  140.             return true;
  141.         }
  142.         else {
  143.             return false;
  144.         }
  145.     }
  146.  
  147.     function addDays($days) {
  148.         if (!is_int($days)) return false;
  149.         $year = $this->year;
  150.         if ($days == 0) return true;
  151.         if ($days >= 146097 || $days <= -146097) {
  152.             $remainder = $days % 146097;
  153.             if ($remainder < 0) {
  154.                 $remainder += 146097;
  155.             }
  156.             $years = 400 * (int)(($days - $remainder) / 146097);
  157.             $year += $years;
  158.             if ($year < 1 || $year > 9999) return false;
  159.             $days = $remainder;
  160.         }
  161.         if ($days >= 36524 || $days <= -36524) {
  162.             $remainder = $days % 36524;
  163.             if ($remainder < 0) {
  164.                 $remainder += 36524;
  165.             }
  166.             $years = 100 * (int)(($days - $remainder) / 36524);
  167.             $year += $years;
  168.             if ($year < 1 || $year > 9999) return false;
  169.             $days = $remainder;
  170.         }
  171.         if ($days >= 1461 || $days <= -1461) {
  172.             $remainder = $days % 1461;
  173.             if ($remainder < 0) {
  174.                 $remainder += 1461;
  175.             }
  176.             $years = 4 * (int)(($days - $remainder) / 1461);
  177.             $year += $years;
  178.             if ($year < 1 || $year > 9999) return false;
  179.             $days = $remainder;
  180.         }
  181.         $month = $this->month;
  182.         while ($days >= 365) {
  183.             if ($year >= 9999) return false;
  184.             if ($month <= 2) {
  185.                 if ((($year % 4) == 0) ? (($year % 100) == 0) ? (($year % 400) == 0) : true : false) {
  186.                     $days -= 366;
  187.                 }
  188.                 else {
  189.                     $days -= 365;
  190.                 }
  191.                 $year++;
  192.             }
  193.             else {
  194.                 $year++;
  195.                 if ((($year % 4) == 0) ? (($year % 100) == 0) ? (($year % 400) == 0) : true : false) {
  196.                     $days -= 366;
  197.                 }
  198.                 else {
  199.                     $days -= 365;
  200.                 }
  201.             }
  202.         }
  203.         while ($days < 0) {
  204.             if ($year <= 1) return false;
  205.             if ($month <= 2) {
  206.                 $year--;
  207.                 if ((($year % 4) == 0) ? (($year % 100) == 0) ? (($year % 400) == 0) : true : false) {
  208.                     $days += 366;
  209.                 }
  210.                 else {
  211.                     $days += 365;
  212.                 }
  213.             }
  214.             else {
  215.                 if ((($year % 4) == 0) ? (($year % 100) == 0) ? (($year % 400) == 0) : true : false) {
  216.                     $days += 366;
  217.                 }
  218.                 else {
  219.                     $days += 365;
  220.                 }
  221.                 $year--;
  222.             }
  223.         }
  224.         $daysInMonth = cal_days_in_month(CAL_GREGORIAN, $month, $year);
  225.         $day = $this->day;
  226.         while ($day + $days > $daysInMonth) {
  227.             $days -= $daysInMonth - $day + 1;
  228.             $month++;
  229.             if ($month > 12) {
  230.                 if ($year >= 9999) return false;
  231.                 $year++;
  232.                 $month = 1;
  233.             }
  234.             $day = 1;
  235.             $daysInMonth = cal_days_in_month(CAL_GREGORIAN, $month, $year);
  236.         }
  237.         $day += $days;
  238.         $this->year = $year;
  239.         $this->month = $month;
  240.         $this->day = $day;
  241.         return true;
  242.     }
  243.  
  244.     function addMonths($months) {
  245.         if (!is_int($months)) return false;
  246.         if ($months == 0) return true;
  247.         $month = $this->month + $months;
  248.         $months = ($month - 1) % 12 + 1;
  249.         if ($months < 1) {
  250.             $months += 12;
  251.         }
  252.         $years = (int)(($month - $months) / 12);
  253.         if ($this->addYears($years)) {
  254.             $daysInMonth = cal_days_in_month(CAL_GREGORIAN, $months, $this->year);
  255.             if ($this->day > $daysInMonth) {
  256.                 $months++;
  257.                 $this->day -= $daysInMonth;
  258.             }
  259.             $this->month = (int)$months;
  260.             return true;
  261.         }
  262.         else {
  263.             return false;
  264.         }
  265.     }
  266.  
  267.     function addYears($years) {
  268.         if (!is_int($years)) return false;
  269.         if ($years == 0) return true;
  270.         $year = $this->year + $years;
  271.         if ($year < 1 || $year > 9999) return false;
  272.         $this->year = $year;
  273.         return true;
  274.     }
  275.  
  276.     function after($when) {
  277.         if (!is_a($when, 'PHPRPC_Date')) {
  278.             $when = PHPRPC_Date::parse($when);
  279.         }
  280.         if ($this->year < $when->year) return false;
  281.         if ($this->year > $when->year) return true;
  282.         if ($this->month < $when->month) return false;
  283.         if ($this->month > $when->month) return true;
  284.         if ($this->day < $when->day) return false;
  285.         if ($this->day > $when->day) return true;
  286.         if ($this->hour < $when->hour) return false;
  287.         if ($this->hour > $when->hour) return true;
  288.         if ($this->minute < $when->minute) return false;
  289.         if ($this->minute > $when->minute) return true;
  290.         if ($this->second < $when->second) return false;
  291.         if ($this->second > $when->second) return true;
  292.         if ($this->millisecond < $when->millisecond) return false;
  293.         if ($this->millisecond > $when->millisecond) return true;
  294.         return false;
  295.     }
  296.  
  297.     function before($when) {
  298.         if (!is_a($when, 'PHPRPC_Date')) {
  299.             $when = new PHPRPC_Date($when);
  300.         }
  301.         if ($this->year < $when->year) return true;
  302.         if ($this->year > $when->year) return false;
  303.         if ($this->month < $when->month) return true;
  304.         if ($this->month > $when->month) return false;
  305.         if ($this->day < $when->day) return true;
  306.         if ($this->day > $when->day) return false;
  307.         if ($this->hour < $when->hour) return true;
  308.         if ($this->hour > $when->hour) return false;
  309.         if ($this->minute < $when->minute) return true;
  310.         if ($this->minute > $when->minute) return false;
  311.         if ($this->second < $when->second) return true;
  312.         if ($this->second > $when->second) return false;
  313.         if ($this->millisecond < $when->millisecond) return true;
  314.         if ($this->millisecond > $when->millisecond) return false;
  315.         return false;
  316.     }
  317.  
  318.     function equals($when) {
  319.         if (!is_a($when, 'PHPRPC_Date')) {
  320.             $when = new PHPRPC_Date($when);
  321.         }
  322.         return (($this->year == $when->year) &&
  323.             ($this->month == $when->month) &&
  324.             ($this->day == $when->day) &&
  325.             ($this->hour == $when->hour) &&
  326.             ($this->minute == $when->minute) &&
  327.             ($this->second == $when->second) &&
  328.             ($this->millisecond == $when->millisecond));
  329.     }
  330.  
  331.     function set() {
  332.         $num = func_num_args();
  333.         $args = func_get_args();
  334.         if ($num >= 3) {
  335.             if (!PHPRPC_Date::isValidDate($args[0], $args[1], $args[2])) {
  336.                 return false;
  337.             }
  338.             $this->year  = (int)$args[0];
  339.             $this->month = (int)$args[1];
  340.             $this->day   = (int)$args[2];
  341.             if ($num == 3) {
  342.                 return true;
  343.             }
  344.         }
  345.         if ($num >= 6) {
  346.             if (!PHPRPC_Date::isValidTime($args[3], $args[4], $args[5])) {
  347.                 return false;
  348.             }
  349.             $this->hour   = (int)$args[3];
  350.             $this->minute = (int)$args[4];
  351.             $this->second = (int)$args[5];
  352.             if ($num == 6) {
  353.                 return true;
  354.             }
  355.         }
  356.         if (($num == 7) && ($args[6] >= 0 && $args[6] <= 999)) {
  357.             $this->millisecond = (int)$args[6];
  358.             return true;
  359.         }
  360.         return false;
  361.     }
  362.  
  363.     function time() {
  364.         return mktime($this->hour, $this->minute, $this->second, $this->month, $this->day, $this->year);
  365.     }
  366.  
  367.     function toString() {
  368.         return sprintf('%04d-%02d-%02d %02d:%02d:%02d.%03d',
  369.             $this->year, $this->month, $this->day,
  370.             $this->hour, $this->minute, $this->second,
  371.             $this->millisecond);
  372.     }
  373.  
  374. // magic method for PHP 5
  375.  
  376.     function __toString() {
  377.         return $this->toString();
  378.     }
  379.  
  380. // public instance & static methods
  381.  
  382.     function dayOfWeek() {
  383.         $num = func_num_args();
  384.         if ($num == 3) {
  385.             $args = func_get_args();
  386.             $y = $args[0];
  387.             $m = $args[1];
  388.             $d = $args[2];
  389.         }
  390.         else {
  391.             $y = $this->year;
  392.             $m = $this->month;
  393.             $d = $this->day;
  394.         }
  395.         $d += $m < 3 ? $y-- : $y - 2;
  396.         return ((int)(23 * $m / 9) + $d + 4 + (int)($y / 4) - (int)($y / 100) + (int)($y / 400)) % 7;
  397.     }
  398.  
  399.     function dayOfYear() {
  400.         static $daysToMonth365 = array(0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365);
  401.         static $daysToMonth366 = array(0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366);
  402.         $num = func_num_args();
  403.         if ($num == 3) {
  404.             $args = func_get_args();
  405.             $y = $args[0];
  406.             $m = $args[1];
  407.             $d = $args[2];
  408.         }
  409.         else {
  410.             $y = $this->year;
  411.             $m = $this->month;
  412.             $d = $this->day;
  413.         }
  414.         $days = PHPRPC_Date::isLeapYear($y) ? $daysToMonth365 : $daysToMonth366;
  415.         return $days[$m - 1] + $d;
  416.     }
  417.  
  418. // public static methods
  419.  
  420.     function now() {
  421.         $date = new PHPRPC_Date();
  422.         return $date;
  423.     }
  424.  
  425.     function today() {
  426.         $date = PHPRPC_Date::now();
  427.         $date->hour = 0;
  428.         $date->minute = 0;
  429.         $date->second = 0;
  430.         return $date;
  431.     }
  432.  
  433.     function parse($dt) {
  434.         if (is_a($dt, 'PHPRPC_Date')) {
  435.             return $dt;
  436.         }
  437.         if (is_int($dt)) {
  438.             return new PHPRPC_Date($dt);
  439.         }
  440.         $shortFormat = '(\d|\d{2}|\d{3}|\d{4})-([1-9]|0[1-9]|1[012])-([1-9]|0[1-9]|[12]\d|3[01])';
  441.         if (preg_match("/^$shortFormat$/", $dt, $match)) {
  442.             $year   = intval($match[1]);
  443.             $month  = intval($match[2]);
  444.             $day    = intval($match[3]);
  445.             if (PHPRPC_Date::isValidDate($year, $month, $day)) {
  446.                 $date = new PHPRPC_Date(false);
  447.                 $date->year  = $year;
  448.                 $date->month = $month;
  449.                 $date->day   = $day;
  450.                 return $date;
  451.             }
  452.             else {
  453.                 return false;
  454.             }
  455.         }
  456.         $longFormat = $shortFormat . ' (\d|0\d|1\d|2[0-3]):(\d|[0-5]\d):(\d|[0-5]\d)';
  457.         if (preg_match("/^$longFormat$/", $dt, $match)) {
  458.             $year   = intval($match[1]);
  459.             $month  = intval($match[2]);
  460.             $day    = intval($match[3]);
  461.             if (PHPRPC_Date::isValidDate($year, $month, $day)) {
  462.                 $date = new PHPRPC_Date(false);
  463.                 $date->year  = $year;
  464.                 $date->month = $month;
  465.                 $date->day   = $day;
  466.                 $date->hour   = intval($match[4]);
  467.                 $date->minute = intval($match[5]);
  468.                 $date->second = intval($match[6]);
  469.                 return $date;
  470.             }
  471.             else {
  472.                 return false;
  473.             }
  474.         }
  475.         $fullFormat = $longFormat . '\.(\d|\d{2}|\d{3})';
  476.         if (preg_match("/^$fullFormat$/", $dt, $match)) {
  477.             $year   = intval($match[1]);
  478.             $month  = intval($match[2]);
  479.             $day    = intval($match[3]);
  480.             if (PHPRPC_Date::isValidDate($year, $month, $day)) {
  481.                 $date = new PHPRPC_Date(false);
  482.                 $date->year  = $year;
  483.                 $date->month = $month;
  484.                 $date->day   = $day;
  485.                 $date->hour        = intval($match[4]);
  486.                 $date->minute      = intval($match[5]);
  487.                 $date->second      = intval($match[6]);
  488.                 $date->millisecond = intval($match[7]);
  489.                 return $date;
  490.             }
  491.             else {
  492.                 return false;
  493.             }
  494.         }
  495.         return false;
  496.     }
  497.  
  498.     function isLeapYear($year) {
  499.         return (($year % 4) == 0) ? (($year % 100) == 0) ? (($year % 400) == 0) : true : false;
  500.     }
  501.  
  502.     function daysInMonth($year, $month) {
  503.         if (($month < 1) || ($month > 12)) {
  504.             return false;
  505.         }
  506.         return cal_days_in_month(CAL_GREGORIAN, $month, $year);
  507.     }
  508.  
  509.     function isValidDate($year, $month, $day) {
  510.         if (($year >= 1) && ($year <= 9999)) {
  511.             return checkdate($month, $day, $year);
  512.         }
  513.         return false;
  514.     }
  515.  
  516.     function isValidTime($hour, $minute, $second) {
  517.         return !(($hour < 0) || ($hour > 23) ||
  518.             ($minute < 0) || ($minute > 59) ||
  519.             ($second < 0) || ($second > 59));
  520.     }
  521. }
  522. ?>
downloadphprpc_date.php Source code - Download The latest thinkphp v5.2 work order system Source code
Related Source Codes/Software:
V3.3.6 Workerman high-performance PHP Socket (framework) - High performance PHP Socket framework Workerman re... 2017-05-03
The phosphor meeting room reservation system MRBS (loop reservation v16.0) - The phosphor meeting room reservation system MRBS ... 2017-05-03
IDC v5.2.3 agent center - IDC Centre IDC for exploitation is a PHP+MySQL age... 2017-05-03
Zen master v9.0.1 project management software - Zen is the first domestic open source project mana... 2017-05-03
Ray speed v7.03 employee files management system - Employee files project is various, and some conten... 2017-05-03
HITCMS Haitian responsive electronic mechanical v3.0 foreign trade website source code - HITCMS Haitian response electronic machinery trade... 2017-05-03
Ray v7.02 speed survey system - Lightning speed survey system is a. NET+MSSQL deve... 2017-05-03
Cool HITCMS reactive black v3.0 enterprise website source code - HITCMS-Haitian response black enterprises website ... 2017-05-03
WebOA v17.2 network office automation system - WebOA network using b/s structure development of o... 2017-05-03
Pure imitation of han site source code, one a 】 【 c9cms kernel v1.0 - Generic http://www.wufazhuce.com/Han one · Config... 2017-05-04
zone.js - Implements Zones for JavaScript ... 2017-05-11
dragonfly - A Ruby gem for on-the-fly processing - suitable fo... 2017-05-11
oh-my-fish - The Fishshell Framework. 2017-05-11
canvas-lms - The open LMS by Instructure, Inc. 2017-05-11
ledger - Double-entry accounting system with a command-line... 2017-05-11
Python - My Python Examples http://w... 2017-05-11
blade - 2017-05-11
LaZagne - Credentials recovery project 2017-05-10
Pull-to-Refresh.Rentals-iOS - This project aims to provide a simple and customiz... 2017-05-10
spoon - Distributing instrumentation tests to all your And... 2017-05-10

 Back to top