{
    "content": [
        {
            "type": "text",
            "text": "# Date::Calc::Object (perldoc)\n\n## NAME\n\nDate::Calc::Object - Object-oriented add-on for Date::Calc with overloaded operators\n\n## DESCRIPTION\n\n* FLAG\n\n## Sections\n\n- **NAME**\n- **MOTTO**\n- **PREFACE**\n- **SYNOPSIS** (9 subsections)\n- **DESCRIPTION**\n- **EXAMPLES**\n- **SEE ALSO**\n- **VERSION**\n- **AUTHOR**\n- **COPYRIGHT**\n- **LICENSE**\n- **DISCLAIMER**\n\nUse structuredContent.sections for detailed options, examples, and full documentation.\n"
        }
    ],
    "structuredContent": {
        "command": "Date::Calc::Object",
        "section": "",
        "mode": "perldoc",
        "summary": "Date::Calc::Object - Object-oriented add-on for Date::Calc with overloaded operators",
        "synopsis": "",
        "tldr_summary": null,
        "tldr_examples": [],
        "tldr_source": null,
        "flags": [],
        "examples": [
            "1)",
            "# Switch to summer time:",
            "$now = Date::Calc->now();",
            "if (($now ge [2000,3,26,2,0,0]) and",
            "($now lt [2000,3,26,3,0,0]))",
            "$now += [0,0,0,1,0,0];",
            "2)",
            "use Date::Calc::Object qw(:all);",
            "Date::Calc->dateformat(3);",
            "$date = 0;",
            "while (!$date)",
            "print \"Please enter the date of your birthday (day-month-year): \";",
            "$date = Date::Calc->new( DecodeDateEU( scalar(<STDIN>) ) );",
            "if ($date)",
            "$resp = 0;",
            "while ($resp !~ /^\\s*[YyNn]/)",
            "print \"Your birthday is: $date\\n\";",
            "print \"Is that correct? (yes/no) \";",
            "$resp = <STDIN>;",
            "$date = 0 unless ($resp =~ /^\\s*[Yy]/)",
            "else",
            "print \"Unable to parse your birthday. Please try again.\\n\";",
            "if ($date + [18,0,0] <= [Today()])",
            "{ print \"Ok, you are over 18.\\n\"; }",
            "else",
            "{ print \"Sorry, you are under 18!\\n\"; }",
            "For more examples, see the \"examples\" subdirectory in this distribution, and their descriptions",
            "in the file \"EXAMPLES.txt\"."
        ],
        "see_also": [
            {
                "name": "Calc",
                "section": "3",
                "url": "https://www.chedong.com/phpMan.php/man/Calc/3/json"
            },
            {
                "name": "Util",
                "section": "3",
                "url": "https://www.chedong.com/phpMan.php/man/Util/3/json"
            },
            {
                "name": "Calendar",
                "section": "3",
                "url": "https://www.chedong.com/phpMan.php/man/Calendar/3/json"
            },
            {
                "name": "Year",
                "section": "3",
                "url": "https://www.chedong.com/phpMan.php/man/Year/3/json"
            },
            {
                "name": "Profiles",
                "section": "3",
                "url": "https://www.chedong.com/phpMan.php/man/Profiles/3/json"
            }
        ],
        "section_outline": [
            {
                "name": "NAME",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "MOTTO",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "PREFACE",
                "lines": 25,
                "subsections": []
            },
            {
                "name": "SYNOPSIS",
                "lines": 1,
                "subsections": [
                    {
                        "name": "Export tags",
                        "lines": 4
                    },
                    {
                        "name": "Functions",
                        "lines": 7
                    },
                    {
                        "name": "Methods",
                        "lines": 78
                    },
                    {
                        "name": "Overloaded Operators",
                        "lines": 5
                    },
                    {
                        "name": "Comparison Operators:",
                        "lines": 33
                    },
                    {
                        "name": "Plus:",
                        "lines": 31
                    },
                    {
                        "name": "Unary Minus:",
                        "lines": 2
                    },
                    {
                        "name": "Minus:",
                        "lines": 31
                    },
                    {
                        "name": "Miscellaneous Operators:",
                        "lines": 14
                    }
                ]
            },
            {
                "name": "DESCRIPTION",
                "lines": 834,
                "subsections": []
            },
            {
                "name": "EXAMPLES",
                "lines": 44,
                "subsections": []
            },
            {
                "name": "SEE ALSO",
                "lines": 3,
                "subsections": []
            },
            {
                "name": "VERSION",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "AUTHOR",
                "lines": 4,
                "subsections": []
            },
            {
                "name": "COPYRIGHT",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "LICENSE",
                "lines": 10,
                "subsections": []
            },
            {
                "name": "DISCLAIMER",
                "lines": 5,
                "subsections": []
            }
        ],
        "sections": {
            "NAME": {
                "content": "Date::Calc::Object - Object-oriented add-on for Date::Calc with overloaded operators\n",
                "subsections": []
            },
            "MOTTO": {
                "content": "Make frequent things easy and infrequent or hard things possible\n",
                "subsections": []
            },
            "PREFACE": {
                "content": "Note that you do NOT need to \"\"use Date::Calc qw(...);\"\" in addition to this module.\n\nSimply\n\nuse Date::Calc::Object qw(...);\n\nINSTEAD OF\n\nuse Date::Calc qw(...);\n\nwith the same \"\"qw(...)\"\" as you would with the \"Date::Calc\" module, and then forget about\n\"Date::Calc::Object\" altogether.\n\nThe rest of your existing code doesn't change at all.\n\nNote also that in order to create a new date object, you do not need to use\n\n$dateobject = Date::Calc::Object->new(...);\n\n(but you may), and should use\n\n$dateobject = Date::Calc->new(...);\n\ninstead (saves you some typing and is a trifle faster).\n",
                "subsections": []
            },
            "SYNOPSIS": {
                "content": "",
                "subsections": [
                    {
                        "name": "Export tags",
                        "content": ":all  -  all functions from Date::Calc\n:aux  -  auxiliary functions shift*\n:ALL  -  both :all and :aux\n"
                    },
                    {
                        "name": "Functions",
                        "content": "See Date::Calc(3) for a list of available functions.\n\n$year                          = shiftyear(\\@);\n($year,$mm,$dd)                = shiftdate(\\@);\n($hrs,$min,$sec)               = shifttime(\\@);\n($year,$mm,$dd,$hrs,$min,$sec) = shiftdatetime(\\@);\n"
                    },
                    {
                        "name": "Methods",
                        "content": "$old = Date::Calc->accuratemode([FLAG]);\n$old = Date::Calc->normalizedmode([FLAG]);\n$old = Date::Calc->numberformat([NUMBER|CODEREF]);\n$old = Date::Calc->deltaformat([NUMBER|CODEREF]);  # global default\n$old = Date::Calc->dateformat([NUMBER|CODEREF]);   # global default\n$old = Date::Calc->language([LANGUAGE]);            # global default - DEPRECATED\n\n$old = $date->accuratemode([FLAG]);           # is global nevertheless!\n$old = $date->normalizedmode([FLAG]);         # is global nevertheless!\n$old = $date->numberformat([NUMBER|CODEREF]); # is global nevertheless!\n$old = $date->deltaformat([NUMBER|CODEREF]);  # individual override\n$old = $date->dateformat([NUMBER|CODEREF]);   # individual override\n$old = $date->language([LANGUAGE]);            # individual override\n\n$flag = $date->isdelta();\n$flag = $date->isdate();\n$flag = $date->isshort(); # i.e., has no time part\n$flag = $date->islong();  # i.e., has time part\n$flag = $date->isvalid();\n\n$date = Date::Calc->new([TYPE]);\n$date = Date::Calc->new([TYPE,]YEAR,MONTH,DAY[,HRS,MIN,SEC]);\n$date = Date::Calc->new($arrayref);\n$newdate = $somedate->new([TYPE]);\n$newdate = $somedate->new([TYPE,]YEAR,MONTH,DAY[,HRS,MIN,SEC]);\n$newdate = $somedate->new($arrayref);\n\n$datecopy = $date->clone();\n$targetdate->copy($sourcedate);\n$targetdate->copy($arrayref);\n$targetdate->copy(@list);\n\n($year,$month,$day) = $date->date([TYPE]);\n($year,$month,$day) = $date->date([TYPE,]YEAR,MONTH,DAY[,HRS,MIN,SEC]);\n($year,$month,$day) = $date->date($arrayref);\n([$hrs,$min,$sec])  = $date->time([TYPE]);\n($hrs,$min,$sec)    = $date->time([TYPE,]HRS,MIN,SEC);\n([$hrs,$min,$sec])  = $date->time($arrayref);\n\n($year,$month,$day,$hrs,$min,$sec) =\n$date->datetime([TYPE]);\n($year,$month,$day,$hrs,$min,$sec) =\n$date->datetime([TYPE,]YEAR,MONTH,DAY[,HRS,MIN,SEC]);\n\n$date  = Date::Calc->today([FLAG]);\n$date  = Date::Calc->now([FLAG]); # shorthand for --+\n$date  = Date::Calc->todayandnow([FLAG]); # <-----+\n$date  = Date::Calc->gmtime([time]);    # UTC/GMT\n$date  = Date::Calc->localtime([time]); # local time\n$delta = Date::Calc->tzoffset([time]);\n$date  = Date::Calc->time2date([time]); # UTC/GMT\n\n$date->today([FLAG]);         # updates the date part only\n$date->now([FLAG]);           # updates the time part only\n$date->todayandnow([FLAG]); # updates both date and time\n$date->gmtime([time]);        # updates both date and time (UTC/GMT)\n$date->localtime([time]);     # updates both date and time (local time)\n$delta->tzoffset([time]);     # updates both date and time\n$date->time2date([time]);     # updates both date and time (UTC/GMT)\n\n$time = Date::Calc->mktime();    # same as \"$time = CORE::time();\"\n$time = Date::Calc->date2time(); # same as \"$time = CORE::time();\"\n\n$time = $date->mktime();      # converts into Unix time (local time)\n$time = $date->date2time();   # converts into Unix time (UTC/GMT)\n\n$year    = $date->year([YEAR]);\n$month   = $date->month([MONTH]);\n$day     = $date->day([DAY]);\n$hours   = $date->hours([HRS]);\n$minutes = $date->minutes([MIN]);\n$seconds = $date->seconds([SEC]);\n\n$number = $date->number([NUMBER|CODEREF]);\n$string = $date->string([NUMBER|CODEREF][,LANGUAGE]);\n\n$delta->normalize(); # renormalizes a delta vector\n"
                    },
                    {
                        "name": "Overloaded Operators",
                        "content": "#####################################################\n# Scalar operands are always converted into a delta #\n# vector with that many days, i.e., [1,0,0,SCALAR]  #\n#####################################################\n"
                    },
                    {
                        "name": "Comparison Operators:",
                        "content": "if ($date1 <  $date2) { # compares date part only\nif ($date1 <= $date2) { # compares date part only\nif ($date1 >  $date2) { # compares date part only\nif ($date1 >= $date2) { # compares date part only\nif ($date1 == $date2) { # compares date part only\nif ($date1 != $date2) { # compares date part only\n\n$comp = $date1 <=> $date2; # compares date part only\n\nif ($date1 lt $date2) { # compares both date and time\nif ($date1 le $date2) { # compares both date and time\nif ($date1 gt $date2) { # compares both date and time\nif ($date1 ge $date2) { # compares both date and time\nif ($date1 eq $date2) { # compares both date and time\nif ($date1 ne $date2) { # compares both date and time\n\n$comp = $date1 cmp $date2; # compares both date and time\n\nNote that you can of course also compare two deltas, but not a date and a delta!\n\n##################################################\n# Default TYPE for array refs in comparisons is: #\n# Same as other operand                          #\n##################################################\n\nif ([2000,4,1] == $date) {\nif ($today > [2000,4,1]) {\n\nif ($now ge [2000,3,26,2,0,0]) {\n\nif ($delta == [18,0,0]) {\nif ($delta == -1) {\n"
                    },
                    {
                        "name": "Plus:",
                        "content": "$date2 = $date1 + $delta;\n$date2 = $delta + $date1;\n$date += $delta;\n$this = $date++;\n$next = ++$date;\n\n$delta3 = $delta1 + $delta2;\n$delta1 += $delta2;\n$delta += $date; # beware of implicit type change!\n$delta++;\n++$delta;\n\n#####################################################\n# Default TYPE for array refs in '+' operations is: #\n# Opposite of other operand                         #\n#####################################################\n\n$date2 = [2000,3,26] + $delta;\n$date2 = $date1 + [+1,0,0];\n$date2 = [0,0,-1] + $date1;\n$date2 = $date1 + 1;\n$date += [0,0,+1];\n$date += 2;\n\n$delta3 = [1,+1,0,-1] + $delta2;\n$delta3 = $delta1 + [1,0,0,+1];\n$delta3 = $delta1 + 1;\n$delta += [1,0,+1,0];\n$delta += [2000,3,26]; # beware of implicit type change!\n$delta += 7;\n"
                    },
                    {
                        "name": "Unary Minus:",
                        "content": "$delta2 = -$delta1;\n"
                    },
                    {
                        "name": "Minus:",
                        "content": "$delta = $date2 - $date1;\n$date2 = $date1 - $delta;\n$date -= $delta;\n$date2 -= $date1; # beware of implicit type change!\n$this = $date--;\n$prev = --$date;\n\n$delta3 = $delta2 - $delta1;\n$delta2 -= $delta1;\n$delta--;\n--$delta;\n\n#####################################################\n# Default TYPE for array refs in '-' operations is: #\n# Always a date                                     #\n#####################################################\n\n$delta = $today - [2000,3,26];\n$delta = [2000,4,1] - $date;\n$date2 = [2000,3,26] - $delta;\n$date2 = $date1 - [1,0,0,+7];\n$date2 = $date1 - 7;\n$date -= [1,0,0,+1]; # better add [0,0,-1] instead!\n$date2 -= [2000,3,26]; # beware of implicit type change!\n$date2 -= 1;\n\n$delta3 = [1,0,+1,0] - $delta1;\n$delta3 = $delta2 - [1,0,0,-1];\n$delta -= [1,0,0,+1];\n$delta -= 7;\n"
                    },
                    {
                        "name": "Miscellaneous Operators:",
                        "content": "$string = \"$date\";\n$string = \"$delta\";\n\nprint \"$date\\n\";\nprint \"$delta\\n\";\n\nif ($date) { # date is valid\nif ($delta) { # delta is valid\n\n$days = abs($date);\n$diff = abs($delta); # can be negative!\n\n$diff = abs(abs($delta)); # always positive\n"
                    }
                ]
            },
            "DESCRIPTION": {
                "content": "* FLAG\n\n\"FLAG\" is either 0 (for \"false\") or 1 (for \"true\").\n\nIn the case of \"\"accuratemode()\"\" and \"\"normalizedmode()\"\", this switches the corresponding\nmode on and off (see further below for an explanation of what these are).\n\nIn the case of \"\"today()\"\", \"\"now()\"\" and \"\"todayandnow()\"\", a \"true\" value indicates \"GMT\"\n(Greenwich Mean Time), as opposed to local time, which is the default.\n\n* NUMBER\n\n\"NUMBER\" is a number between 0 and 2 (for \"numberformat()\" and \"number()\") or between 0 and 4\n(for \"deltaformat()\", \"dateformat()\" and \"string()\"), indicating which of the three/five\npredefined formats, respectively, should be used for converting a date into numeric\nrepresentation (needed for comparing dates, for instance) or string representation.\n\nFormat #0 is the default at startup and the simplest of all (and should be fastest to\ncalculate, too).\n\nThe string representation of dates in format #0 also has the advantage of being sortable in\nchronological order (and of complying with ISO 8601).\n\n(The numeric formats are (trivially) always sortable in chronological order of course.)\n\nThe other formats are (mostly) increasingly more sophisticated (in terms of esthetics and\ncomputation time) with increasing number (except for format #4):\n\nDelta number formats (short):\n\n0    13603\n1    13603\n2    13603\n\nDelta string formats (short):\n\n0    '+0+0+13603'\n1    '+0 +0 +13603'\n2    '+0Y +0M +13603D'\n3    '+0 Y +0 M +13603 D'\n4    '(0,0,13603)'\n\nDate number formats (short):\n\n0    20010401\n1    730576\n2    730576\n\nDate string formats (short):\n\n0    '20010401'\n1    '01-Apr-2001'\n2    'Sun 1-Apr-2001'\n3    'Sunday, April 1st 2001'\n4    '[2001,4,1]'\n\nDelta number formats (long):\n\n0    13603.012959\n1    13603.012959\n2    13603.0624884259\n\nDelta string formats (long):\n\n0    '+0+0+13603+1+29+59'\n1    '+0 +0 +13603 +1 +29 +59'\n2    '+0Y +0M +13603D +1h +29m +59s'\n3    '+0 Y +0 M +13603 D +1 h +29 m +59 s'\n4    '(0,0,13603,1,29,59)'\n\nDate number formats (long):\n\n0    20010401.082959\n1    730576.082959\n2    730576.354155093\n\nDate string formats (long):\n\n0    '20010401082959'\n1    '01-Apr-2001 08:29:59'\n2    'Sun 1-Apr-2001 08:29:59'\n3    'Sunday, April 1st 2001 08:29:59'\n4    '[2001,4,1,8,29,59]'\n\nIf a number outside of the permitted range is specified, or if the value is not a code\nreference (see also the next section below for more details), the default format #0 is used\ninstead.\n\n* CODEREF\n\n\"CODEREF\" is the reference of a subroutine which can be passed to the methods\n\"numberformat()\", \"deltaformat()\" and \"dateformat()\" in order to install a callback\nfunction which will be called subsequently whenever a date (or delta) object needs to be\n(implicitly) converted into a number or string.\n\nThis happens for instance when you compare two date objects, or when you put a date object\nreference in a string between double quotes.\n\nSuch a \"CODEREF\" can also be passed to the methods \"number()\" and \"string()\" for explicitly\nconverting a date object as desired.\n\n* LANGUAGE\n\n\"LANGUAGE\" is either a number in the range \"[1..Languages()]\", or one of the strings\n\"\"LanguagetoText(1..Languages())\"\" (see also Date::Calc(3)).\n\n* TYPE\n\n\"TYPE\" is 0 for a regular date and 1 for a delta vector (a list of year, month, day and\noptionally hours, minutes and seconds offsets).\n\n* Storage\n\n\"Date::Calc\" objects are implemented as two nested arrays.\n\nThe \"blessed\" array (whose reference is the object reference you receive when calling the\n\"new()\" method) contains an anonymous array at position zero and the object's data in its\nremaining fields.\n\nThe embedded anonymous array is used for storing the object's attributes (flags).\n\nDates and delta vectors always comprise either 3 or 6 data values: Year, month, day plus\n(optionally) hours, minutes and seconds.\n\nThese values are stored in the \"blessed\" array at positions 1..3 or 1..6, respectively.\n\nAn object without the time values is therefore called \"short\", and an object having time\nvalues is called \"long\" throughout this manual.\n\nHint: Whenever possible, if you do not need the time values, omit them, i.e., always use the\n\"short\" form of the object if possible, this will speed up calculations a little (the short\nform uses different (faster) functions for all calculations internally).\n\nThe embedded anonymous array contains various flags:\n\nAt position zero, it contains the \"TYPE\" indicator which determines whether the object is a\ndate or a delta vector.\n\nAt position 1, the object stores the \"NUMBER\" of one of the delta vector formats, or the\nreference of a callback function which converts the contents of the object into string\nrepresentation if it's a delta vector, or \"undef\" if the global settings apply.\n\nAt position 2, the object stores the \"NUMBER\" of one of the date formats, or the reference of\na callback function which converts the contents of the object into string representation if\nit's a date, or \"undef\" if the global settings apply.\n\nAt position 3, the object stores the \"LANGUAGE\" to be used for all conversions into strings\n(where applicable), or \"undef\" if the global language setting applies.\n\nNote that your callback functions (see the section \"Callback Functions\" further below for more\ndetails) should not pay attention to this value at position 3, because they get a parameter\nwhich tells them which language to use (this is necessary in order to allow temporary\noverrides).\n\nIf your callback handlers use the \"*toText*\" functions (or any other language-dependent\nfunction) from the \"Date::Calc\" module, your handlers should pass on this language parameter\nto these functions (and not the value from position 3).\n\nBe reminded though that you should NEVER access the object's internal data directly, i.e.,\nthrough their positional numbers, but ALWAYS through their respective accessor methods, e.g.:\n\nyear()\nmonth()\nday()\nhours()\nminutes()\nseconds()\ndate()\ntime()\ndatetime()\nisdelta()\nisdate()\nisshort()\nislong()\ndeltaformat()\ndateformat()\nlanguage()\n\nAnd although position 4 and onward in the embedded anonymous array is currently unused, it\nmight not stay so in future releases of this module.\n\nTherefore, in case you need more attributes in a subclass of the \"Date::Calc[::Object]\" class,\nI suggest using values starting at positions a bit further up, e.g. 6, 8 or 10.\n\n* Invalid Dates\n\nOnly \"new()\" allows one to create objects containing possibly invalid dates (needed for\nreading in and evaluating user input, for example).\n\n* Usage\n\nThe methods\n\naccuratemode()\nnormalizedmode()\nnumberformat()\ndeltaformat()\ndateformat()\nlanguage()\ndate()\ntime()\ndatetime()\nyear()\nmonth()\nday()\nhours()\nminutes()\nseconds()\n\nare used for reading as well as for setting attributes. They simply return the values in\nquestion if they are called without parameters.\n\nThe methods\n\naccuratemode()\nnormalizedmode()\nnumberformat()\ndeltaformat()\ndateformat()\nlanguage()\n\nalways return the previous value if a new value is set. This allows you to change these values\ntemporarily and to restore their old value afterwards more easily (but you can also override\nthe \"format\" and \"language\" settings directly when calling the \"number()\" or \"string()\"\nmethod).\n\nThe methods\n\ndate()\ntime()\ndatetime()\nyear()\nmonth()\nday()\nhours()\nminutes()\nseconds()\n\nalways return the new values when the corresponding values have been changed.\n\nThe method \"date()\" NEVER returns the time values (hours, minutes, seconds) even if they have\njust been set using this method (which the method optionally allows). Otherwise it would be\nvery hard to predict the exact number of values it returns, which might lead to errors (wrong\nnumber of parameters) elsewhere in your program.\n\nThe method \"datetime()\" ALWAYS returns the time values (hours, minutes, seconds) even if the\nobject in question lacks a time part. In that case, zeros are returned for hours, minutes and\nseconds instead (but the stored time part is left unchanged, whether it exists or not).\n\nIf you do not provide values for hours, minutes and seconds when using the method \"date()\" to\nset the values for year, month and day, the time part will not be changed (whether it exists\nor not).\n\nIf you do not provide values for hours, minutes and seconds when using the method \"datetime()\"\nto set the values for year, month and day, the time part will be filled with zeros (the time\npart will be created if necessary).\n\nIf the object is short, i.e., if it does not have any time values, the method \"time()\" returns\nan empty list.\n\nIf the object is short and the methods \"hours()\", \"minutes()\" or \"seconds()\" are used to set\nany of these time values, the object is automatically promoted to the \"long\" form, and the\nother two time values are filled with zeros.\n\nThe following methods can also return \"undef\" under certain circumstances:\n\ndeltaformat()\ndateformat()\nlanguage()\nisdelta()\nisdate()\nisshort()\nislong()\nisvalid()\nhours()\nminutes()\nseconds()\nnumber()\nstring()\n\nThe methods \"deltaformat()\", \"dateformat()\" and \"language()\" return \"undef\" when they are\ncalled as object methods and no individual override has been defined for the object in\nquestion.\n\nThe \"is*()\" predicate methods return \"undef\" if the object in question does not have the\nexpected internal structure. This can happen for instance when you create an empty object with\n\"new()\".\n\nWhen called without parameters, the methods \"hours()\", \"minutes()\" and \"seconds()\" return\n\"undef\" if the object in question does not have a time part.\n\nThe methods \"number()\" and \"string()\" return \"undef\" if the object in question is not valid\n(i.e., if \"isvalid()\" returns \"undef\" or false).\n\nAnd finally, the methods\n\ncopy()\ntoday()\nnow()\ntodayandnow()\ngmtime()\nlocaltime()\ntzoffset()\ntime2date()\nnormalize()\n\nreturn the object reference of the (target) object in question for convenience.\n\n* Import/Export\n\nNote that you can import and export Unix \"time\" values using the methods \"gmtime()\",\n\"localtime()\", \"mktime()\", \"date2time()\" and \"time2date()\", both as local time or as UTC/GMT.\n\n* Accurate Mode and Normalized Mode\n\nThe method \"accuratemode()\" controls the internal flag which determines which of two\nfundamental modes of operation is used.\n\nWhen set to true (the default at startup), delta vectors are calculated to give the exact\ndifference in days between two dates. The \"year\" and \"month\" entries in the resulting delta\nvector are always zero in that case.\n\nIf \"accurate mode\" is switched off (when the corresponding flag is set to false), delta\nvectors are calculated with year and month differences.\n\nE.g., the difference between \"[1999,12,6]\" and \"[2000,6,24]\" is \"[+0 +0 +201]\" (plus 201 days)\nin accurate mode and \"[+1 -6 +18]\" (plus one year, minus 6 months, plus 18 days) when accurate\nmode is switched off, and is \"[+0 +6 +18]\" (plus 6 months, plus 18 days) if additionally,\n\"normalized mode\" is switched on.\n\nThe delta vector is calculated by simply taking the difference in years, the difference in\nmonths and the difference in days (if \"accurate mode\" is switched off and if \"normalized mode\"\nhas not been switched on). This is called \"one-by-one\" semantics or \"year-month-day mode\";\n\"YMD mode\" for short.\n\nWhen \"normalized mode\" is switched on (while \"accurate mode\" is switched off), the delta\nvector is calculated in a more complex way involving the functions \"\"AddDeltaYM()\"\" (for\n\"truncation\") and \"\"DeltaDays()\"\".\n\nMoreover, the result is normalized, i.e., the return values are guaranteed to all have the\nsame sign (or to be zero), and to all be \"minimal\", i.e., not to exceed the ranges\n\"[-11..+11]\" for months, \"[-30..+30]\" for days, \"[-23..+23]\" for hours and \"[-59..+59]\" for\nminutes and seconds.\n\nThe rule is to add these result values to a date in a left-to-right order, and to truncate\ninvalid intermediate dates, such as e.g. \"[2009,2,29]\", to the last valid day of that same\nmonth, e.g. \"[2009,2,28]\". This is called \"left-to-right with truncation\" semantics or\n\"normalized mode\"; \"NYMD mode\" for short.\n\nThe method \"normalizedmode()\" controls the internal flag which determines whether \"YMD mode\"\nis used (the default at startup, for reasons of backward compatibility) or \"NYMD mode\".\n\nNote that also for reasons of backward compatibility, this flag only has effect when \"accurate\nmode\" is switched off.\n\nBoth flags can be set and reset independently from each other, however.\n\nTherefore, at startup, you can for instance switch \"normalized mode\" on, without having any\nimmediate effect, and switch off \"accurate mode\" later, which instantly also causes\n\"normalized mode\" to spring into effect.\n\nBecause years and months have varying lengths in terms of days, the \"YMD\" and \"NYMD\" modes\nare less accurate than \"accurate mode\", because these modes depend on the context of the two\ndates of which the delta vector is the difference. Added to a different date, a delta vector\ncalculated in \"YMD mode\" or \"NYMD mode\" may yield a different offset in terms of days, i.e.,\nthe final result may sometimes vary seemingly unpredictably (or in other situations may give\nyou the expected result, at the expense of actually representing a varying difference in days,\ndetermined exclusively by context).\n\nBeware also that - for the same reason - the absolute value (\"\"abs()\"\") of a delta vector\nreturns a fictitious number of days if the delta vector contains non-zero values for \"year\"\nand/or \"month\" (see also the next section \"Absolute Value\" below for more details).\n\nExample:\n\nThe difference between \"[2000,1,1]\" and \"[2000,3,1]\" is \"[+0 +0 +60]\" in \"accurate mode\" and\n\"[+0 +2 +0]\" in \"YMD mode\" (in this \"benign\" example, the result is the same in \"YMD mode\" and\nin \"NYMD mode\").\n\nWhen added to the date \"[2000,4,1]\", the \"accurate\" delta vector yields the date\n\"[2000,5,31]\", whereas the \"YMD mode\" delta vector yields the date \"[2000,6,1]\" (which is\nactually a difference of 61 days).\n\nMoreover, when added to the date \"[1999,1,1]\", the \"accurate\" delta vector yields the date\n\"[1999,3,2]\", whereas the \"inaccurate\" \"YMD Mode\" delta vector yields the date \"[1999,3,1]\"\n(which is actually a difference of 59 days).\n\nDepending on what you want, either mode may suit you better.\n\n* Absolute Value\n\nNote that \"\"abs($date)\"\" and \"\"abs($delta)\"\" are just shorthands for \"\"$date->number()\"\" and\n\"\"$delta->number()\"\".\n\nThe operator \"\"abs()\"\", when applied to a date or delta vector, returns the corresponding\nnumber of days (see below for an exception to this), with the time part (if available)\nrepresented by a fraction after the decimal point.\n\nIn the case of dates, the absolute value (to the left of the decimal point) is the number of\ndays since the 1st of January 1 A.D. (by extrapolating the Gregorian calendar back beyond its\n\"natural\" limit of 1582 A.D.) PLUS ONE.\n\n(I.e., the absolute value of the 1st of January 1 A.D. is 1.)\n\nException:\n\nIf the \"NUMBER\" or \"numberformat()\" is set to 0 (the default setting), the absolute value of\na date to the left of the decimal point is \"yyyymmdd\", i.e., the number in which the uppermost\nfour digits correspond to the year, the next lower two digits to the month and the lowermost\ntwo digits to the day.\n\nIn the case of delta vectors, the absolute value (to the left of the decimal point) is simply\nthe difference in days (but see also below).\n\nNote that the absolute value of a delta vector can be negative!\n\nIf you want a positive value in all cases, apply the \"\"abs()\"\" operator again, i.e.,\n\"\"$posdiff = abs(abs($delta));\"\".\n\nIf the delta vector contains non-zero values for \"year\" and/or \"month\" (see also the\ndiscussion of \"Accurate Mode\" in the section above), an exact representation in days cannot be\ncalculated, because years and months do not have fixed equivalents in days.\n\nIf nevertheless you attempt to calculate the absolute value of such a delta vector, a\nfictitious value is returned, which is calculated by simply multiplying the year difference\nwith 12, adding the month difference, multiplying this sum with 31 and finally adding the day\ndifference.\n\nBeware that because of this, the absolute values of delta vectors are not necessarily\ncontiguous.\n\nMoreover, since there is more than one way to express the difference between two dates,\ncomparisons of delta vectors may not always yield the expected result.\n\nExample:\n\nThe difference between the two dates \"[2000,4,30]\" and \"[2001,5,1]\" can be expressed as \"[+1\n+1 -29]\", or as \"[+1 +0 +1]\".\n\nThe first delta vector has an absolute value of 374, whereas the latter delta vector has an\nabsolute value of only 373 (while the true difference in days between the two dates is 366).\n\nIf the date or delta vector has a time part, the time is returned as a fraction of a full day\nafter the decimal point as follows:\n\nIf the \"NUMBER\" or \"numberformat()\" is set to 0 (the default setting) or 1, this fraction is\nsimply \".hhmmss\", i.e., the two digits after the decimal point represent the hours, the next\ntwo digits the minutes and the last two digits the seconds.\n\nNote that you cannot simply add and subtract these values to yield meaningful dates or deltas\nagain, you can only use them for comparisons (equal, not equal, less than, greater than,\netc.). If you want to add/subtract, read on:\n\nOnly when the \"NUMBER\" or \"numberformat()\" is set to 2, this fraction will be the equivalent\nnumber of seconds (i.e., \"(((hours * 60) + minutes) * 60) + seconds\") divided by the number of\nseconds in a full day (i.e., \"24*60*60 = 86400\"), or \"0/86400\", \"1/86400\", ... ,\n\"86399/86400\".\n\nIn other words, the (mathematically correct) fraction of a day.\n\nYou can safely perform arithmetics with these values as far as the internal precision of your\nvendor's implementation of the C run-time library (on which Perl depends) will permit.\n\n* Renormalizing Delta Vectors\n\nWhen adding or subtracting delta vectors to/from one another, the addition or subtraction\ntakes place component by component.\n\nExample:\n\n[+0 +0 +0 +3 +29 +50] + [+0 +0 +0 +0 +55 +5] = [+0 +0 +0 +3 +84 +55]\n[+0 +0 +0 +3 +29 +50] - [+0 +0 +0 +0 +55 +5] = [+0 +0 +0 +3 -26 +45]\n\nThis may result in time values outside the usual ranges (\"[-23..+23]\" for hours and\n\"[-59..+59]\" for minutes and seconds).\n\nNote that even though the delta value for days will often become quite large, it is impossible\nto renormalize this value because there is no constant conversion factor from days to months\n(should it be 28, 29, 30 or 31?).\n\nIf accurate mode (see further above for what that is) is switched off, delta vectors can also\ncontain non-zero values for years and months. If you add or subtract these, the value for\nmonths can lie outside the range \"[-11..11]\", which isn't wrong, but may seem funny.\n\nTherefore, the \"normalize()\" method will also renormalize the \"months\" value, if and only if\naccurate mode has been switched off. (!)\n\n(Hence, switch accurate mode ON temporarily if you DON'T want the renormalization of the\n\"months\" value to happen.)\n\nIf you want to force the time values from the example above back into their proper ranges, use\nthe \"normalize()\" method as follows:\n\nprint \"[$delta]\\n\";\n$delta->normalize();\nprint \"[$delta]\\n\";\n\nThis will print\n\n[+0 +0 +0 +3 +84 +55]\n[+0 +0 +0 +4 +24 +55]\n\nfor the first and\n\n[+0 +0 +0 +3 -26 +45]\n[+0 +0 +0 +2 +34 +45]\n\nfor the second delta vector from the example further above.\n\nNote that the values for days, hours, minutes and seconds are guaranteed to have the same sign\nafter the renormalization.\n\nUnder \"normal\" circumstances, i.e., when accurate mode is on (the default), this method only\nhas an effect on the time part of the delta vector.\n\nIf the delta vector in question does not have a time part, nothing happens.\n\nIf accurate mode is off, the \"months\" value is also normalized, i.e., if it lies outside of\nthe range \"[-11..11]\", integer multiples of 12 are added to the \"years\" value and subtracted\nfrom the \"months\" value. Moreover, the \"months\" value is guaranteed to have the same sign as\nthe values for days, hours, minutes and seconds, unless the \"months\" value is zero or the\nvalues for days, hours, minutes and seconds are all zero.\n\nIf the object in question is a date and if warnings are enabled, the message \"normalizing a\ndate is a no-op\" will be printed to STDERR.\n\nIf the object in question is not a valid \"Date::Calc\" object, nothing happens.\n\nThe method returns its object's reference, which allows chaining of method calls, as in the\nfollowing example:\n\n@time = $delta->normalize()->time();\n\n* Callback Functions\n\nNote that you are not restricted to the built-in formats (numbered from 0 to 2 for\n\"numberformat()\" and \"number()\" and from 0 to 4 for \"deltaformat()\", \"dateformat()\" and\n\"string()\") for converting a date or delta object into a number or string.\n\nYou can also provide your own function(s) for doing so, in order to suit your own taste or\nneeds, by passing a subroutine reference to the appropriate method, i.e., \"numberformat()\",\n\"number()\", \"deltaformat()\", \"dateformat()\" and \"string()\".\n\nYou can pass a handler to only one or more of these methods, or to all of them, as you like.\nYou can use different callback functions, or the same for all.\n\nIn order to facilitate the latter, and in order to make the decoding of the various cases\neasier for you, the callback function receives a uniquely identifying function code as its\nsecond parameter:\n\n0  =  TONUMBER | ISDATE  | ISSHORT  (number[format])\n1  =  TONUMBER | ISDATE  | ISLONG   (number[format])\n2  =  TONUMBER | ISDELTA | ISSHORT  (number[format])\n3  =  TONUMBER | ISDELTA | ISLONG   (number[format])\n4  =  TOSTRING | ISDATE  | ISSHORT  (string|dateformat)\n5  =  TOSTRING | ISDATE  | ISLONG   (string|dateformat)\n6  =  TOSTRING | ISDELTA | ISSHORT  (string|deltaformat)\n7  =  TOSTRING | ISDELTA | ISLONG   (string|deltaformat)\n\nThe first parameter of the callback function is of course the reference of the object in\nquestion itself (therefore, the callback function can actually be an object method - but not a\nclass method, for obvious reasons).\n\nThe third parameter is the number of the language (in the range \"[1..Languages()]\") which you\nshould always pass along when using any of the following functions from the \"Date::Calc\"\nmodule in your handler:\n\n\"DecodeMonth()\", \"DecodeDayofWeek()\", \"CompressedtoText()\", \"DatetoText()\",\n\"DatetoTextLong()\", \"Calendar()\", \"MonthtoText()\", \"DayofWeektoText()\",\n\"DayofWeekAbbreviation()\", \"DecodeDateEU()\", \"DecodeDateUS()\", \"DecodeDateEU2()\",\n\"DecodeDateUS2()\", \"ParseDate()\".\n\nThe callback handler should return the resulting number or string, as requested.\n\nBEWARE that you should NEVER rely upon any knowledge of the object's internal structure, as\nthis may be subject to change!\n\nALWAYS use the test and access methods provided by this module!\n\nExample:\n\nsub handler\n{\nmy($self,$code,$lang) = @;\n\nif    ($code == 0) # TONUMBER | ISDATE  | ISSHORT\n{\nreturn DatetoDays( $self->date() );\n}\nelsif ($code == 1) # TONUMBER | ISDATE  | ISLONG\n{\nreturn DatetoDays( $self->date() ) +\n( ( $self->hours() * 60 +\n$self->minutes() ) * 60 +\n$self->seconds() ) / 86400;\n}\nelsif ($code == 2) # TONUMBER | ISDELTA | ISSHORT\n{\nreturn ( $self->year() * 12 +\n$self->month() ) * 31 +\n$self->day();\n}\nelsif ($code == 3) # TONUMBER | ISDELTA | ISLONG\n{\nreturn ( $self->year() * 12 +\n$self->month() ) * 31 +\n$self->day() +\n( ( $self->hours() * 60 +\n$self->minutes() ) * 60 +\n$self->seconds() ) / 86400;\n}\nelsif ($code == 4) # TOSTRING | ISDATE  | ISSHORT\n{\nreturn join( \"/\", $self->date() );\n}\nelsif ($code == 5) # TOSTRING | ISDATE  | ISLONG\n{\nreturn join( \"/\", $self->date() ) . \" \" .\njoin( \":\", $self->time() );\n}\nelsif ($code == 6) # TOSTRING | ISDELTA | ISSHORT\n{\nreturn join( \"|\", $self->date() );\n}\nelsif ($code == 7) # TOSTRING | ISDELTA | ISLONG\n{\nreturn join( \"|\", $self->datetime() );\n}\nelse\n{\ndie \"internal error\";\n}\n}\n\nDate::Calc->numberformat(\\&handler);\nDate::Calc->deltaformat(\\&handler);\nDate::Calc->dateformat(\\&handler);\n\nThis sets our handler to take care of all automatic conversions, such as needed when comparing\ndates or when interpolating a string in double quotes which contains a date object.\n\nTo deactivate a handler, simply pass a valid format number to the method in question, e.g.:\n\nDate::Calc->numberformat(0);\nDate::Calc->deltaformat(2);\nDate::Calc->dateformat(3);\n\nWhen calling the \"number()\" or \"string()\" method explicitly, you can pass a different format\nnumber (than the global setting), like this:\n\n$number = $date->number(2);\n$string = $date->string(1);\n\nYou can also pass a handler's reference, like so:\n\n$number = $date->number(\\&handler);\n$string = $date->string(\\&handler);\n\nThis overrides the global setting and the individual object's local setting for the duration\nof the call of \"number()\" or \"string()\" (but doesn't change the global or local settings\nthemselves).\n\nMoreover, you can also define individual overrides for the date and the delta vector formats\n(but not the number format) for individual objects, e.g.:\n\n$date->deltaformat(1);\n$date->dateformat(2);\n\n$date->deltaformat(\\&handler);\n$date->dateformat(\\&handler);\n\nIn order to deactivate an individual handler for an object, and/or in order to deactivate any\noverride altogether (so that the global settings apply again), you have to pass \"undef\"\nexplicitly to the method in question:\n\n$date->deltaformat(undef);\n$date->dateformat(undef);\n\nYou can also define a language for individual objects (see the next section immediately below\nfor more details).\n\nIf such an individual language override has been set, it will be passed to your callback\nhandlers as the third parameter (in the case of \"string\" conversions, but not in the case of\n\"number\" conversions).\n\nOtherwise, the global settings as defined by \"Language($lang);\" or\n\"Date::Calc-\"language($lang);> will be passed to your handler.\n\n* Languages\n\nNote that this module is completely transparent to the setting of a language in \"Date::Calc\".\nThis means that you can choose a language in \"Date::Calc\" (with the \"Language()\" function) and\nall dates subsequently printed by this module will automatically be in that language -\nprovided that you use the built-in formats of this module, or that you pass the third\nparameter of the callback function to the functions of the \"Date::Calc\" module which accept\nit.\n\nHowever, this global language setting can be overridden for individual date (or delta) objects\nby using the OBJECT method\n\n$oldlang = $date->language($newlang);\n\n(The global setting is not altered by this in any way.)\n\nIn order to deactivate such an individual language setting (so that the global setting applies\nagain), simply pass the value \"undef\" explicitly to the \"language()\" object method:\n\n$date->language(undef);\n\nThe CLASS method\n\n$oldlang = Date::Calc->language($newlang);\n\nis just a convenient wrapper around the \"Language()\" function, which allows you to enter\nlanguage numbers (as returned by the \"DecodeLanguage()\" function) or strings (as returned by\nthe \"LanguagetoText()\" function), whatever you prefer.\n\nThe \"language()\" method (both class and object) always returns the NAME (one of\n\"\"LanguagetoText(1..Languages())\"\") of the current setting (and never its number).\n\nBEWARE that in order to avoid possible conflicts between threads or modules running\nconcurrently, you should NEVER use the global function \"Language($lang);\" or the class method\n\"Date::Calc-\"language($lang);> in this module!\n\nThe class method is retained only for backward compatibility and for convenience in\nstand-alone applications when it is guaranteed that no such conflicts can arise.\n\nBut you should probably avoid to use global settings anyway, because it may be especially\ntroublesome to fix your code later when suddenly the need arises to use your code with threads\nor when your code needs to use other modules which also use \"Date::Calc\" (with different\nsettings!).\n\nBy exclusively using local settings, you are making your code invulnerable against other,\nconcurrent modules also using \"Date::Calc\" which still use global settings.\n\n* Exported Functions\n\nThe \"Date::Calc::Object\" package imports \":all\" functions exported by the \"Date::Calc\" module\nand re-exports them, for conveniency.\n\nThis allows you to write\n\nuse Date::Calc::Object qw(...);\n\ninstead of\n\nuse Date::Calc qw(...);\n\nbut with exactly the same semantics. The difference is that the object-oriented frontend is\nloaded additionally in the first case.\n\nAs with \"Date::Calc\" you can use the \":all\" tag to import all of \"Date::Calc\"'s functions:\n\nuse Date::Calc::Object qw(:all);\n\nIn addition to the functions exported by \"Date::Calc\", the \"Date::Calc::Object\" package offers\nsome utility functions of its own for export:\n\n$year                          = shiftyear(\\@);\n($year,$mm,$dd)                = shiftdate(\\@);\n($hrs,$min,$sec)               = shifttime(\\@);\n($year,$mm,$dd,$hrs,$min,$sec) = shiftdatetime(\\@);\n\nThese functions enable your subroutines or methods to accept a \"Date::Calc\" (or subclass) date\nobject, an (anonymous) array or a list (containing the necessary values) as parameters\nINTERCHANGEABLY.\n\nYou can import all of these auxiliary functions by using an \":aux\" tag:\n\nuse Date::Calc::Object qw(:aux);\n\nIf you want to import both all of the \"Date::Calc\" functions as well as all these auxiliary\nfunctions, use the \":ALL\" tag:\n\nuse Date::Calc::Object qw(:ALL);\n\n* Subclassing\n\nIn case you want to subclass \"Date::Calc\" objects and to add new attributes of your own, it is\nrecommended that you proceed as follows (the following will be considered as a part of the\nmodule's \"contract of use\" - which might be subject to change in the future, however):\n\nDefine a constant for the index of each attribute you want to add, currently starting no lower\nthan \"4\", at the top of your subclass:\n\nuse constant ATTRIB1 => 4;\nuse constant ATTRIB2 => 5;\nuse constant ATTRIB3 => 6;\n...\n\nIt is recommended that you use constants (which are easy to change), because I someday might\nwant to require the element with index \"4\" for a new attribute of my own... \":-)\"\n\nThen access your attributes like so (e.g. after calling \"\"$self = SUPER->new();\"\" in your\nconstructor method):\n\n$self->[0][ATTRIB1] = 'value1';\n$self->[0][ATTRIB2] = 'value2';\n$self->[0][ATTRIB3] = 'value3';\n...\n\nBeware that if you put anything other than numbers or strings into your attributes, the\nmethods \"clone()\" and \"copy()\" might not work as expected anymore!\n\nEspecially if your attributes contain references to other data structures, only the references\nwill be copied, but not the data structures themselves.\n\nThis may not be what you want.\n\n(You will have to override these two methods and write some of your own if not.)\n\nIn order for the overloaded operators and the \"shift*()\" auxiliary functions from the\n\"Date::Calc::Object\" package to work properly (the latter of which are heavily used in the\n\"Date::Calendar[::Year]\" modules, for instance), the package name of your subclass (= the one\nyour objects will be blessed into) is REQUIRED to contain a \"::\".\n\nNote that you should ONLY subclass \"Date::Calc\", NEVER \"Date::Calc::Object\", since subclassing\nthe latter is less efficient (because \"Date::Calc::Object\" is just an empty class which\ninherits from \"Date::Calc\" - subclassing \"Date::Calc::Object\" would thus just introduce an\nadditional name space layer to search during Perl's runtime method binding process).\n\nIf you give your subclass a package name below/inside the \"Date::\" namespace, you will also\nbenefit from the fact that all error messages produced by the \"Date::Calc[::Object]\" module\n(and also the \"Date::Calendar[::Year]\" modules, by the way) will appear to have originated\nfrom the place outside of all \"\"/^Date::/\"\" modules (including yours) where one of the\n\"Date::\" modules was first called - i.e., all errors are always blamed on the user, no matter\nhow deeply nested inside the \"Date::\" modules they occur, and do not usually refer to places\ninside any of the \"Date::\" modules (this assumes that there are no bugs in the \"Date::\"\nmodules, and that all errors are always the user's fault \":-)\").\n\nMoreover, your module's own error messages will behave in the same way if you \"\"use Carp::Clan\nqw(^Date::);\"\" at the top of your module and if you produce all error messages using \"carp()\"\nand \"croak()\" (instead of \"warn()\" and \"die()\", respectively).\n",
                "subsections": []
            },
            "EXAMPLES": {
                "content": "1)\n# Switch to summer time:\n$now = Date::Calc->now();\nif (($now ge [2000,3,26,2,0,0]) and\n($now lt [2000,3,26,3,0,0]))\n{\n$now += [0,0,0,1,0,0];\n}\n\n2)\nuse Date::Calc::Object qw(:all);\n\nDate::Calc->dateformat(3);\n\n$date = 0;\nwhile (!$date)\n{\nprint \"Please enter the date of your birthday (day-month-year): \";\n$date = Date::Calc->new( DecodeDateEU( scalar(<STDIN>) ) );\nif ($date)\n{\n$resp = 0;\nwhile ($resp !~ /^\\s*[YyNn]/)\n{\nprint \"Your birthday is: $date\\n\";\nprint \"Is that correct? (yes/no) \";\n$resp = <STDIN>;\n}\n$date = 0 unless ($resp =~ /^\\s*[Yy]/)\n}\nelse\n{\nprint \"Unable to parse your birthday. Please try again.\\n\";\n}\n}\n\nif ($date + [18,0,0] <= [Today()])\n{ print \"Ok, you are over 18.\\n\"; }\nelse\n{ print \"Sorry, you are under 18!\\n\"; }\n\nFor more examples, see the \"examples\" subdirectory in this distribution, and their descriptions\nin the file \"EXAMPLES.txt\".\n",
                "subsections": []
            },
            "SEE ALSO": {
                "content": "Date::Calc(3), Date::Calc::Util(3), Date::Calendar(3), Date::Calendar::Year(3),\nDate::Calendar::Profiles(3).\n",
                "subsections": []
            },
            "VERSION": {
                "content": "This man page documents \"Date::Calc::Object\" version 6.4.\n",
                "subsections": []
            },
            "AUTHOR": {
                "content": "Steffen Beyer\nmailto:STBEY@cpan.org\nhttp://www.engelschall.com/u/sb/download/\n",
                "subsections": []
            },
            "COPYRIGHT": {
                "content": "Copyright (c) 2000 - 2015 by Steffen Beyer. All rights reserved.\n",
                "subsections": []
            },
            "LICENSE": {
                "content": "This package is free software; you can use, modify and redistribute it under the same terms as\nPerl itself, i.e., at your option, under the terms either of the \"Artistic License\" or the \"GNU\nGeneral Public License\".\n\nThe C library at the core of the module \"Date::Calc::XS\" can, at your discretion, also be used,\nmodified and redistributed under the terms of the \"GNU Library General Public License\".\n\nPlease refer to the files \"Artistic.txt\", \"GNUGPL.txt\" and \"GNULGPL.txt\" in the \"license\"\nsubdirectory of this distribution for any details!\n",
                "subsections": []
            },
            "DISCLAIMER": {
                "content": "This package is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;\nwithout even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\nSee the \"GNU General Public License\" for more details.\n",
                "subsections": []
            }
        }
    }
}