From 96ebede305ebf50b37fc5ed1185568d1553c27dc Mon Sep 17 00:00:00 2001 From: Raymond Hill Date: Thu, 29 Aug 2013 05:54:49 -0700 Subject: [PATCH 001/105] Initial commit --- LICENSE | 674 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ README.md | 4 + 2 files changed, 678 insertions(+) create mode 100644 LICENSE create mode 100644 README.md diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0a2023c --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ +GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. {http://fsf.org/} + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + {one line to give the program's name and a brief idea of what it does.} + Copyright (C) {year} {name of author} + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see {http://www.gnu.org/licenses/}. + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + gocronexpression Copyright (C) 2013 Raymond Hill + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +{http://www.gnu.org/licenses/}. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +{http://www.gnu.org/philosophy/why-not-lgpl.html}. diff --git a/README.md b/README.md new file mode 100644 index 0000000..9055cb3 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +gocronexpression +================ + +Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression From 960263f0acd30ed75645e9362d931aed1f52143a Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 09:03:10 -0400 Subject: [PATCH 002/105] first commit --- cronexpression.go | 726 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 726 insertions(+) create mode 100644 cronexpression.go diff --git a/cronexpression.go b/cronexpression.go new file mode 100644 index 0000000..6b8fa6b --- /dev/null +++ b/cronexpression.go @@ -0,0 +1,726 @@ +/*! + * Copyright 2013 Raymond Hill + * + * Project: github.com/gorhill/gocronexpression + * File: cronexpression.go + * Version: 1.0 + * License: GPL v3 see + * + */ + +package cronexpression + +/******************************************************************************/ + +import ( + "regexp" + "sort" + "strconv" + "strings" + "time" +) + +/******************************************************************************/ + +// A CronExpression represents a specific cron expression as defined on +// Wikipedia: https://en.wikipedia.org/wiki/Cron#CRON_expression +// +type CronExpression struct { + Expression string + secondList []int + minuteList []int + hourList []int + daysOfMonth map[int]bool + workdaysOfMonth map[int]bool + lastDayOfMonth bool + daysOfMonthRestricted bool + actualDaysOfMonthList []int + monthList []int + daysOfWeek map[int]bool + specificWeekDaysOfWeek map[int]bool + lastWeekDaysOfWeek map[int]bool + daysOfWeekRestricted bool + yearList []int +} + +/******************************************************************************/ + +var noMatchTime = time.Date(2100, 7, 1, 0, 0, 0, 0, time.UTC) + +/******************************************************************************/ + +// NewCronExpression() returns a new CronExpression pointer. It expects +// a well-formed cron expression. If a malformed cron expression is +// supplied, the result is undefined. +func NewCronExpression(cronLine string) *CronExpression { + cronLineNormalized := cronNormalize(cronLine) + + // Split into fields + cronFields := regexp.MustCompile(`\s+`).Split(cronLineNormalized, -1) + + // Our cron expression parser expects 7 fields: + // second minute hour dayofmonth month dayofweek year + // Standard cron is 6 fields with year field being optional + // minute hour dayofmonth month dayofweek {year} + // Thus... + // If we have 5 fields, append wildcard year field + if len(cronFields) < 6 { + cronFields = append(cronFields, "*") + } + // If we have 6 fields, prepend match-once second field + if len(cronFields) < 7 { + cronFields = append(cronFields, "") + copy(cronFields[1:], cronFields[0:]) + cronFields[0] = "0" + } + // We should have 7 fields at this point + if len(cronFields) != 7 { + panic("Malformed cron expression\n") + } + + // Generic parser can be used for most fields + cronExpr := &CronExpression{ + Expression: cronLine, + secondList: genericFieldParse(cronFields[0], 0, 59), + minuteList: genericFieldParse(cronFields[1], 0, 59), + hourList: genericFieldParse(cronFields[2], 0, 23), + monthList: genericFieldParse(cronFields[4], 1, 12), + yearList: genericFieldParse(cronFields[6], 1970, 2099), + } + + // Days of month/days of week is a bit more complicated, due + // to their extended syntax, and the fact that days per + // month is a variable quantity, and relation between + // days of week and days of month depends on the month/year. + cronExpr.dayofmonthFieldParse(cronFields[3]) + cronExpr.dayofweekFieldParse(cronFields[5]) + + return cronExpr +} + +/******************************************************************************/ + +// NextTimeFromCronString() returns the time stamp following fromTime which +// satisfies the cron expression cronLine. If no matching time stamp is found, +// using NoMatch() with the returned time stamp as argument will return true. +// +// If the same cron expression must be used repeatedly, it is better to use +// NewCronExpression() in order to avoid overhead of cron expression parsing. +func NextTimeFromCronString(cronLine string, fromTime time.Time) time.Time { + cronexpr := NewCronExpression(cronLine) + return cronexpr.NextTime(fromTime) +} + +/******************************************************************************/ + +// NextTimeNFromCronString() returns the n time stamps following fromTime which +// satisfy the cron expression cronLine. An empty list is returned if +// there is no matching time stamp. +// +// If the same cron expression must be used repeatedly, it is better to use +// NewCronExpression() in order to avoid overhead of cron expression parsing. +func NextTimeNFromCronString(cronLine string, fromTime time.Time, n int) []time.Time { + cronexpr := NewCronExpression(cronLine) + return cronexpr.NextTimeN(fromTime, n) +} + +/******************************************************************************/ + +// CronExpression.NextTime() returns the time stamp following fromTime which +// satisfies the cron expression. If no matching time stamp is found, +// using NoMatch() with the returned time stamp as argument will return true. +func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { + // Special case + if NoMatch(fromTime) { + return fromTime + } + + // First we need to ensure supplied time stamp matches + // the cron expression. If not, this means the supplied time + // stamp might be between matching time stamps, thus we move + // to closest matching time stamp without changing time stamp + + // year + v := fromTime.Year() + i := sort.SearchInts(cronexpr.yearList, v) + if i == len(cronexpr.yearList) { + return noMatchTime + } + if v != cronexpr.yearList[i] { + return cronexpr.nextYear(fromTime) + } + // month + v = int(fromTime.Month()) + i = sort.SearchInts(cronexpr.monthList, v) + if i == len(cronexpr.monthList) { + return cronexpr.nextYear(fromTime) + } + if v != cronexpr.monthList[i] { + return cronexpr.nextMonth(fromTime) + } + + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(fromTime.Year(), int(fromTime.Month())) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(fromTime) + } + + // day of month + v = fromTime.Day() + i = sort.SearchInts(cronexpr.actualDaysOfMonthList, v) + if i == len(cronexpr.actualDaysOfMonthList) { + return cronexpr.nextMonth(fromTime) + } + if v != cronexpr.actualDaysOfMonthList[i] { + return cronexpr.nextDayOfMonth(fromTime) + } + // hour + v = fromTime.Hour() + i = sort.SearchInts(cronexpr.hourList, v) + if i == len(cronexpr.hourList) { + return cronexpr.nextDayOfMonth(fromTime) + } + if v != cronexpr.hourList[i] { + return cronexpr.nextHour(fromTime) + } + // minute + v = fromTime.Minute() + i = sort.SearchInts(cronexpr.minuteList, v) + if i == len(cronexpr.minuteList) { + return cronexpr.nextHour(fromTime) + } + if v != cronexpr.minuteList[i] { + return cronexpr.nextMinute(fromTime) + } + // second + v = fromTime.Second() + i = sort.SearchInts(cronexpr.secondList, v) + if i == len(cronexpr.secondList) { + return cronexpr.nextMinute(fromTime) + } + + // If we reach this point, there is nothing better to do + // than to move to the next second + + return cronexpr.nextSecond(fromTime) +} + +/******************************************************************************/ + +// CronExpression.NextTimeN() returns an array of n time stamps following +// fromTime which satisfy the cron expression. An empty list is returned if +// there is no matching time stamp. +func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time { + if n <= 0 { + panic("CronExpression.NextTimeN(): invalid count") + } + nextTimes := make([]time.Time, 0) + fromTime = cronexpr.NextTime(fromTime) + for { + if NoMatch(fromTime) { + break + } + nextTimes = append(nextTimes, fromTime) + n -= 1 + if n == 0 { + break + } + fromTime = cronexpr.nextSecond(fromTime) + } + return nextTimes +} + +/******************************************************************************/ + +// NoMatch() returns whether t is a valid time stamp, from CronExpression point +// of view. +func NoMatch(t time.Time) bool { + // https://en.wikipedia.org/wiki/Cron#CRON_expression: 1970–2099 + return t.Year() >= 2100 +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextYear(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate year + i := sort.SearchInts(cronexpr.yearList, t.Year()+1) + if i == len(cronexpr.yearList) { + return noMatchTime + } + // Year changed, need to recalculate actual days of month + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(cronexpr.yearList[i], cronexpr.monthList[0]) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(time.Date( + cronexpr.yearList[i], + time.Month(cronexpr.monthList[0]), + 1, + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local)) + } + return time.Date( + cronexpr.yearList[i], + time.Month(cronexpr.monthList[0]), + cronexpr.actualDaysOfMonthList[0], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextMonth(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate month + i := sort.SearchInts(cronexpr.monthList, int(t.Month())+1) + if i == len(cronexpr.monthList) { + return cronexpr.nextYear(t) + } + // Month changed, need to recalculate actual days of month + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(t.Year(), cronexpr.monthList[i]) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(time.Date( + t.Year(), + time.Month(cronexpr.monthList[i]), + 1, + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local)) + } + + return time.Date( + t.Year(), + time.Month(cronexpr.monthList[i]), + cronexpr.actualDaysOfMonthList[0], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) calculateActualDaysOfMonth(year, month int) []int { + actualDaysOfMonthMap := make(map[int]bool) + timeOrigin := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) + lastDayOfMonth := timeOrigin.AddDate(0, 1, -1).Day() + + // As per crontab man page (http://linux.die.net/man/5/crontab#): + // "The day of a command's execution can be specified by two + // "fields - day of month, and day of week. If both fields are + // "restricted (ie, aren't *), the command will be run when + // "either field matches the current time" + if cronexpr.daysOfMonthRestricted || cronexpr.daysOfWeekRestricted == false { + // Last day of month + if cronexpr.lastDayOfMonth { + actualDaysOfMonthMap[lastDayOfMonth] = true + } + // Days of month + for v, _ := range cronexpr.daysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + // Work days of month + // As per Wikipedia: month boundaries are not crossed. + for v, _ := range cronexpr.workdaysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth { + // If saturday, then friday + if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Saturday { + if v > 1 { + v -= 1 + } else { + v += 2 + } + // If sunday, then monday + } else if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Sunday { + if v < lastDayOfMonth { + v += 1 + } else { + v -= 2 + } + } + actualDaysOfMonthMap[v] = true + } + } + } + + if cronexpr.daysOfWeekRestricted { + // How far first sunday is from first day of month + offset := 7 - int(timeOrigin.Weekday()) + // days of week + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : (7 * week_of_month) + (offset + day_of_week) % 7 + 1 + for w := 0; w <= 4; w += 1 { + for v, _ := range cronexpr.daysOfWeek { + v := 1 + w*7 + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + } + // days of week of specific week in the month + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : (7 * week_of_month) + (offset + day_of_week) % 7 + 1 + for v, _ := range cronexpr.specificWeekDaysOfWeek { + v := 1 + 7*(v/7) + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + // Last days of week of the month + lastWeekOrigin := timeOrigin.AddDate(0, 1, -7) + offset = 7 - int(lastWeekOrigin.Weekday()) + for v, _ := range cronexpr.lastWeekDaysOfWeek { + v := lastWeekOrigin.Day() + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + } + + return toList(actualDaysOfMonthMap) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextDayOfMonth(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate day of month + i := sort.SearchInts(cronexpr.actualDaysOfMonthList, t.Day()+1) + if i == len(cronexpr.actualDaysOfMonthList) { + return cronexpr.nextMonth(t) + } + + return time.Date( + t.Year(), + t.Month(), + cronexpr.actualDaysOfMonthList[i], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextHour(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate hour + i := sort.SearchInts(cronexpr.hourList, t.Hour()+1) + if i == len(cronexpr.hourList) { + return cronexpr.nextDayOfMonth(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + cronexpr.hourList[i], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextMinute(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate minute + i := sort.SearchInts(cronexpr.minuteList, t.Minute()+1) + if i == len(cronexpr.minuteList) { + return cronexpr.nextHour(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + t.Hour(), + cronexpr.minuteList[i], + cronexpr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextSecond(t time.Time) time.Time { + // nextSecond() assumes all other fields are exactly matched + // to the cron expression + + // Find index at which item in list is greater or equal to + // candidate second + i := sort.SearchInts(cronexpr.secondList, t.Second()+1) + if i == len(cronexpr.secondList) { + return cronexpr.nextMinute(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + t.Hour(), + t.Minute(), + cronexpr.secondList[i], + 0, + t.Location()) +} + +/******************************************************************************/ + +var cronNormalizer = strings.NewReplacer( + // Order is important! + "@yearly", "0 0 0 1 1 * *", + "@annually", "0 0 0 1 1 * *", + "@monthly", "0 0 0 1 * * *", + "@weekly", "0 0 0 * * 0 *", + "@daily", "0 0 0 * * * *", + "@hourly", "0 0 * * * * *", + "january", "1", + "february", "2", + "march", "3", + "april", "4", + "may", "5", + "june", "6", + "july", "7", + "august", "8", + "september", "9", + "october", "0", + "november", "1", + "december", "2", + "sunday", "0", + "monday", "1", + "tuesday", "2", + "wednesday", "3", + "thursday", "4", + "friday", "5", + "saturday", "6", + "jan", "1", + "feb", "2", + "mar", "3", + "apr", "4", + "jun", "6", + "jul", "7", + "aug", "8", + "sep", "9", + "oct", "0", + "nov", "1", + "dec", "2", + "sun", "0", + "mon", "1", + "tue", "2", + "wed", "3", + "thu", "4", + "fri", "5", + "sat", "6", + "?", "*") + +func cronNormalize(cronLine string) string { + cronLine = strings.TrimSpace(cronLine) + cronLine = strings.ToLower(cronLine) + cronLine = cronNormalizer.Replace(cronLine) + return cronLine +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) dayofweekFieldParse(cronField string) error { + // Defaults + cronexpr.daysOfWeekRestricted = true + cronexpr.lastWeekDaysOfWeek = make(map[int]bool) + cronexpr.daysOfWeek = make(map[int]bool) + + // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + cronexpr.daysOfWeekRestricted = (step > 1) + populateMany(cronexpr.daysOfWeek, 0, 6, step) + continue + } + // "-" + // week day interval for all weeks + i := strings.Index(s, "-") + if i >= 0 { + min := atoi(s[:i]) % 7 + max := atoi(s[i+1:]) % 7 + populateMany(cronexpr.daysOfWeek, min, max, step) + continue + } + // single value + // "l": week day for last week + i = strings.Index(s, "l") + if i >= 0 { + populateOne(cronexpr.lastWeekDaysOfWeek, atoi(s[:i])%7) + continue + } + // "#": week day for specific week + i = strings.Index(s, "#") + if i >= 0 { + // v#w + v := atoi(s[:i]) % 7 + w := atoi(s[i+1:]) + // v domain = [0,7] + // w domain = [1,5] + populateOne(cronexpr.specificWeekDaysOfWeek, (w-1)*7+(v%7)) + continue + } + // week day interval for all weeks + if step > 0 { + v := atoi(s) % 7 + populateMany(cronexpr.daysOfWeek, v, 6, step) + continue + } + // single week day for all weeks + v := atoi(s) % 7 + populateOne(cronexpr.daysOfWeek, v) + } + + return nil +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) dayofmonthFieldParse(cronField string) error { + // Defaults + cronexpr.daysOfMonthRestricted = true + cronexpr.lastDayOfMonth = false + + cronexpr.daysOfMonth = make(map[int]bool) // days of month map + cronexpr.workdaysOfMonth = make(map[int]bool) // work day of month map + + // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + cronexpr.daysOfMonthRestricted = (step > 1) + populateMany(cronexpr.daysOfMonth, 1, 31, step) + continue + } + // "-" + i := strings.Index(s, "-") + if i >= 0 { + populateMany(cronexpr.daysOfMonth, atoi(s[:i]), atoi(s[i+1:]), step) + continue + } + // single value + // "l": last day of month + if s == "l" { + cronexpr.lastDayOfMonth = true + continue + } + // "w": week day + i = strings.Index(s, "w") + if i >= 0 { + populateOne(cronexpr.workdaysOfMonth, atoi(s[:i])) + continue + } + // single value with interval + if step > 0 { + populateMany(cronexpr.daysOfMonth, atoi(s), 31, step) + continue + } + // single value + populateOne(cronexpr.daysOfMonth, atoi(s)) + } + + return nil +} + +/******************************************************************************/ + +func genericFieldParse(cronField string, min, max int) []int { + // Defaults + values := make(map[int]bool) + + // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + populateMany(values, min, max, step) + continue + } + // "-" + i := strings.Index(s, "-") + if i >= 0 { + populateMany(values, atoi(s[:i]), atoi(s[i+1:]), step) + continue + } + // single value with interval + if step > 0 { + populateMany(values, atoi(s), max, step) + continue + } + // single value + populateOne(values, atoi(s)) + } + + return toList(values) +} + +/******************************************************************************/ + +// Local helpers + +func extractInterval(s string) (int, string) { + step := 0 + i := strings.Index(s, "/") + if i >= 0 { + step = atoi(s[i+1:]) + s = s[:i] + } + return step, s +} + +func atoi(s string) int { + v, err := strconv.Atoi(s) + if err != nil { + panic(err) + } + return v +} + +func populateOne(values map[int]bool, v int) { + values[v] = true +} + +func populateMany(values map[int]bool, min, max, step int) { + if step == 0 { + step = 1 + } + for i := min; i <= max; i += step { + values[i] = true + } +} + +func toList(set map[int]bool) []int { + list := make([]int, len(set)) + i := 0 + for k, _ := range set { + list[i] = k + i += 1 + } + sort.Ints(list) + return list +} From 40271bc5f487ed32767196db683c6771df66cf09 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 09:03:10 -0400 Subject: [PATCH 003/105] first commit --- cronexpression.go | 726 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 726 insertions(+) create mode 100644 cronexpression.go diff --git a/cronexpression.go b/cronexpression.go new file mode 100644 index 0000000..6b8fa6b --- /dev/null +++ b/cronexpression.go @@ -0,0 +1,726 @@ +/*! + * Copyright 2013 Raymond Hill + * + * Project: github.com/gorhill/gocronexpression + * File: cronexpression.go + * Version: 1.0 + * License: GPL v3 see + * + */ + +package cronexpression + +/******************************************************************************/ + +import ( + "regexp" + "sort" + "strconv" + "strings" + "time" +) + +/******************************************************************************/ + +// A CronExpression represents a specific cron expression as defined on +// Wikipedia: https://en.wikipedia.org/wiki/Cron#CRON_expression +// +type CronExpression struct { + Expression string + secondList []int + minuteList []int + hourList []int + daysOfMonth map[int]bool + workdaysOfMonth map[int]bool + lastDayOfMonth bool + daysOfMonthRestricted bool + actualDaysOfMonthList []int + monthList []int + daysOfWeek map[int]bool + specificWeekDaysOfWeek map[int]bool + lastWeekDaysOfWeek map[int]bool + daysOfWeekRestricted bool + yearList []int +} + +/******************************************************************************/ + +var noMatchTime = time.Date(2100, 7, 1, 0, 0, 0, 0, time.UTC) + +/******************************************************************************/ + +// NewCronExpression() returns a new CronExpression pointer. It expects +// a well-formed cron expression. If a malformed cron expression is +// supplied, the result is undefined. +func NewCronExpression(cronLine string) *CronExpression { + cronLineNormalized := cronNormalize(cronLine) + + // Split into fields + cronFields := regexp.MustCompile(`\s+`).Split(cronLineNormalized, -1) + + // Our cron expression parser expects 7 fields: + // second minute hour dayofmonth month dayofweek year + // Standard cron is 6 fields with year field being optional + // minute hour dayofmonth month dayofweek {year} + // Thus... + // If we have 5 fields, append wildcard year field + if len(cronFields) < 6 { + cronFields = append(cronFields, "*") + } + // If we have 6 fields, prepend match-once second field + if len(cronFields) < 7 { + cronFields = append(cronFields, "") + copy(cronFields[1:], cronFields[0:]) + cronFields[0] = "0" + } + // We should have 7 fields at this point + if len(cronFields) != 7 { + panic("Malformed cron expression\n") + } + + // Generic parser can be used for most fields + cronExpr := &CronExpression{ + Expression: cronLine, + secondList: genericFieldParse(cronFields[0], 0, 59), + minuteList: genericFieldParse(cronFields[1], 0, 59), + hourList: genericFieldParse(cronFields[2], 0, 23), + monthList: genericFieldParse(cronFields[4], 1, 12), + yearList: genericFieldParse(cronFields[6], 1970, 2099), + } + + // Days of month/days of week is a bit more complicated, due + // to their extended syntax, and the fact that days per + // month is a variable quantity, and relation between + // days of week and days of month depends on the month/year. + cronExpr.dayofmonthFieldParse(cronFields[3]) + cronExpr.dayofweekFieldParse(cronFields[5]) + + return cronExpr +} + +/******************************************************************************/ + +// NextTimeFromCronString() returns the time stamp following fromTime which +// satisfies the cron expression cronLine. If no matching time stamp is found, +// using NoMatch() with the returned time stamp as argument will return true. +// +// If the same cron expression must be used repeatedly, it is better to use +// NewCronExpression() in order to avoid overhead of cron expression parsing. +func NextTimeFromCronString(cronLine string, fromTime time.Time) time.Time { + cronexpr := NewCronExpression(cronLine) + return cronexpr.NextTime(fromTime) +} + +/******************************************************************************/ + +// NextTimeNFromCronString() returns the n time stamps following fromTime which +// satisfy the cron expression cronLine. An empty list is returned if +// there is no matching time stamp. +// +// If the same cron expression must be used repeatedly, it is better to use +// NewCronExpression() in order to avoid overhead of cron expression parsing. +func NextTimeNFromCronString(cronLine string, fromTime time.Time, n int) []time.Time { + cronexpr := NewCronExpression(cronLine) + return cronexpr.NextTimeN(fromTime, n) +} + +/******************************************************************************/ + +// CronExpression.NextTime() returns the time stamp following fromTime which +// satisfies the cron expression. If no matching time stamp is found, +// using NoMatch() with the returned time stamp as argument will return true. +func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { + // Special case + if NoMatch(fromTime) { + return fromTime + } + + // First we need to ensure supplied time stamp matches + // the cron expression. If not, this means the supplied time + // stamp might be between matching time stamps, thus we move + // to closest matching time stamp without changing time stamp + + // year + v := fromTime.Year() + i := sort.SearchInts(cronexpr.yearList, v) + if i == len(cronexpr.yearList) { + return noMatchTime + } + if v != cronexpr.yearList[i] { + return cronexpr.nextYear(fromTime) + } + // month + v = int(fromTime.Month()) + i = sort.SearchInts(cronexpr.monthList, v) + if i == len(cronexpr.monthList) { + return cronexpr.nextYear(fromTime) + } + if v != cronexpr.monthList[i] { + return cronexpr.nextMonth(fromTime) + } + + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(fromTime.Year(), int(fromTime.Month())) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(fromTime) + } + + // day of month + v = fromTime.Day() + i = sort.SearchInts(cronexpr.actualDaysOfMonthList, v) + if i == len(cronexpr.actualDaysOfMonthList) { + return cronexpr.nextMonth(fromTime) + } + if v != cronexpr.actualDaysOfMonthList[i] { + return cronexpr.nextDayOfMonth(fromTime) + } + // hour + v = fromTime.Hour() + i = sort.SearchInts(cronexpr.hourList, v) + if i == len(cronexpr.hourList) { + return cronexpr.nextDayOfMonth(fromTime) + } + if v != cronexpr.hourList[i] { + return cronexpr.nextHour(fromTime) + } + // minute + v = fromTime.Minute() + i = sort.SearchInts(cronexpr.minuteList, v) + if i == len(cronexpr.minuteList) { + return cronexpr.nextHour(fromTime) + } + if v != cronexpr.minuteList[i] { + return cronexpr.nextMinute(fromTime) + } + // second + v = fromTime.Second() + i = sort.SearchInts(cronexpr.secondList, v) + if i == len(cronexpr.secondList) { + return cronexpr.nextMinute(fromTime) + } + + // If we reach this point, there is nothing better to do + // than to move to the next second + + return cronexpr.nextSecond(fromTime) +} + +/******************************************************************************/ + +// CronExpression.NextTimeN() returns an array of n time stamps following +// fromTime which satisfy the cron expression. An empty list is returned if +// there is no matching time stamp. +func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time { + if n <= 0 { + panic("CronExpression.NextTimeN(): invalid count") + } + nextTimes := make([]time.Time, 0) + fromTime = cronexpr.NextTime(fromTime) + for { + if NoMatch(fromTime) { + break + } + nextTimes = append(nextTimes, fromTime) + n -= 1 + if n == 0 { + break + } + fromTime = cronexpr.nextSecond(fromTime) + } + return nextTimes +} + +/******************************************************************************/ + +// NoMatch() returns whether t is a valid time stamp, from CronExpression point +// of view. +func NoMatch(t time.Time) bool { + // https://en.wikipedia.org/wiki/Cron#CRON_expression: 1970–2099 + return t.Year() >= 2100 +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextYear(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate year + i := sort.SearchInts(cronexpr.yearList, t.Year()+1) + if i == len(cronexpr.yearList) { + return noMatchTime + } + // Year changed, need to recalculate actual days of month + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(cronexpr.yearList[i], cronexpr.monthList[0]) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(time.Date( + cronexpr.yearList[i], + time.Month(cronexpr.monthList[0]), + 1, + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local)) + } + return time.Date( + cronexpr.yearList[i], + time.Month(cronexpr.monthList[0]), + cronexpr.actualDaysOfMonthList[0], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextMonth(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate month + i := sort.SearchInts(cronexpr.monthList, int(t.Month())+1) + if i == len(cronexpr.monthList) { + return cronexpr.nextYear(t) + } + // Month changed, need to recalculate actual days of month + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(t.Year(), cronexpr.monthList[i]) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(time.Date( + t.Year(), + time.Month(cronexpr.monthList[i]), + 1, + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local)) + } + + return time.Date( + t.Year(), + time.Month(cronexpr.monthList[i]), + cronexpr.actualDaysOfMonthList[0], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) calculateActualDaysOfMonth(year, month int) []int { + actualDaysOfMonthMap := make(map[int]bool) + timeOrigin := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) + lastDayOfMonth := timeOrigin.AddDate(0, 1, -1).Day() + + // As per crontab man page (http://linux.die.net/man/5/crontab#): + // "The day of a command's execution can be specified by two + // "fields - day of month, and day of week. If both fields are + // "restricted (ie, aren't *), the command will be run when + // "either field matches the current time" + if cronexpr.daysOfMonthRestricted || cronexpr.daysOfWeekRestricted == false { + // Last day of month + if cronexpr.lastDayOfMonth { + actualDaysOfMonthMap[lastDayOfMonth] = true + } + // Days of month + for v, _ := range cronexpr.daysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + // Work days of month + // As per Wikipedia: month boundaries are not crossed. + for v, _ := range cronexpr.workdaysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth { + // If saturday, then friday + if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Saturday { + if v > 1 { + v -= 1 + } else { + v += 2 + } + // If sunday, then monday + } else if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Sunday { + if v < lastDayOfMonth { + v += 1 + } else { + v -= 2 + } + } + actualDaysOfMonthMap[v] = true + } + } + } + + if cronexpr.daysOfWeekRestricted { + // How far first sunday is from first day of month + offset := 7 - int(timeOrigin.Weekday()) + // days of week + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : (7 * week_of_month) + (offset + day_of_week) % 7 + 1 + for w := 0; w <= 4; w += 1 { + for v, _ := range cronexpr.daysOfWeek { + v := 1 + w*7 + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + } + // days of week of specific week in the month + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : (7 * week_of_month) + (offset + day_of_week) % 7 + 1 + for v, _ := range cronexpr.specificWeekDaysOfWeek { + v := 1 + 7*(v/7) + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + // Last days of week of the month + lastWeekOrigin := timeOrigin.AddDate(0, 1, -7) + offset = 7 - int(lastWeekOrigin.Weekday()) + for v, _ := range cronexpr.lastWeekDaysOfWeek { + v := lastWeekOrigin.Day() + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + } + + return toList(actualDaysOfMonthMap) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextDayOfMonth(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate day of month + i := sort.SearchInts(cronexpr.actualDaysOfMonthList, t.Day()+1) + if i == len(cronexpr.actualDaysOfMonthList) { + return cronexpr.nextMonth(t) + } + + return time.Date( + t.Year(), + t.Month(), + cronexpr.actualDaysOfMonthList[i], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextHour(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate hour + i := sort.SearchInts(cronexpr.hourList, t.Hour()+1) + if i == len(cronexpr.hourList) { + return cronexpr.nextDayOfMonth(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + cronexpr.hourList[i], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextMinute(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate minute + i := sort.SearchInts(cronexpr.minuteList, t.Minute()+1) + if i == len(cronexpr.minuteList) { + return cronexpr.nextHour(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + t.Hour(), + cronexpr.minuteList[i], + cronexpr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) nextSecond(t time.Time) time.Time { + // nextSecond() assumes all other fields are exactly matched + // to the cron expression + + // Find index at which item in list is greater or equal to + // candidate second + i := sort.SearchInts(cronexpr.secondList, t.Second()+1) + if i == len(cronexpr.secondList) { + return cronexpr.nextMinute(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + t.Hour(), + t.Minute(), + cronexpr.secondList[i], + 0, + t.Location()) +} + +/******************************************************************************/ + +var cronNormalizer = strings.NewReplacer( + // Order is important! + "@yearly", "0 0 0 1 1 * *", + "@annually", "0 0 0 1 1 * *", + "@monthly", "0 0 0 1 * * *", + "@weekly", "0 0 0 * * 0 *", + "@daily", "0 0 0 * * * *", + "@hourly", "0 0 * * * * *", + "january", "1", + "february", "2", + "march", "3", + "april", "4", + "may", "5", + "june", "6", + "july", "7", + "august", "8", + "september", "9", + "october", "0", + "november", "1", + "december", "2", + "sunday", "0", + "monday", "1", + "tuesday", "2", + "wednesday", "3", + "thursday", "4", + "friday", "5", + "saturday", "6", + "jan", "1", + "feb", "2", + "mar", "3", + "apr", "4", + "jun", "6", + "jul", "7", + "aug", "8", + "sep", "9", + "oct", "0", + "nov", "1", + "dec", "2", + "sun", "0", + "mon", "1", + "tue", "2", + "wed", "3", + "thu", "4", + "fri", "5", + "sat", "6", + "?", "*") + +func cronNormalize(cronLine string) string { + cronLine = strings.TrimSpace(cronLine) + cronLine = strings.ToLower(cronLine) + cronLine = cronNormalizer.Replace(cronLine) + return cronLine +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) dayofweekFieldParse(cronField string) error { + // Defaults + cronexpr.daysOfWeekRestricted = true + cronexpr.lastWeekDaysOfWeek = make(map[int]bool) + cronexpr.daysOfWeek = make(map[int]bool) + + // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + cronexpr.daysOfWeekRestricted = (step > 1) + populateMany(cronexpr.daysOfWeek, 0, 6, step) + continue + } + // "-" + // week day interval for all weeks + i := strings.Index(s, "-") + if i >= 0 { + min := atoi(s[:i]) % 7 + max := atoi(s[i+1:]) % 7 + populateMany(cronexpr.daysOfWeek, min, max, step) + continue + } + // single value + // "l": week day for last week + i = strings.Index(s, "l") + if i >= 0 { + populateOne(cronexpr.lastWeekDaysOfWeek, atoi(s[:i])%7) + continue + } + // "#": week day for specific week + i = strings.Index(s, "#") + if i >= 0 { + // v#w + v := atoi(s[:i]) % 7 + w := atoi(s[i+1:]) + // v domain = [0,7] + // w domain = [1,5] + populateOne(cronexpr.specificWeekDaysOfWeek, (w-1)*7+(v%7)) + continue + } + // week day interval for all weeks + if step > 0 { + v := atoi(s) % 7 + populateMany(cronexpr.daysOfWeek, v, 6, step) + continue + } + // single week day for all weeks + v := atoi(s) % 7 + populateOne(cronexpr.daysOfWeek, v) + } + + return nil +} + +/******************************************************************************/ + +func (cronexpr *CronExpression) dayofmonthFieldParse(cronField string) error { + // Defaults + cronexpr.daysOfMonthRestricted = true + cronexpr.lastDayOfMonth = false + + cronexpr.daysOfMonth = make(map[int]bool) // days of month map + cronexpr.workdaysOfMonth = make(map[int]bool) // work day of month map + + // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + cronexpr.daysOfMonthRestricted = (step > 1) + populateMany(cronexpr.daysOfMonth, 1, 31, step) + continue + } + // "-" + i := strings.Index(s, "-") + if i >= 0 { + populateMany(cronexpr.daysOfMonth, atoi(s[:i]), atoi(s[i+1:]), step) + continue + } + // single value + // "l": last day of month + if s == "l" { + cronexpr.lastDayOfMonth = true + continue + } + // "w": week day + i = strings.Index(s, "w") + if i >= 0 { + populateOne(cronexpr.workdaysOfMonth, atoi(s[:i])) + continue + } + // single value with interval + if step > 0 { + populateMany(cronexpr.daysOfMonth, atoi(s), 31, step) + continue + } + // single value + populateOne(cronexpr.daysOfMonth, atoi(s)) + } + + return nil +} + +/******************************************************************************/ + +func genericFieldParse(cronField string, min, max int) []int { + // Defaults + values := make(map[int]bool) + + // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + populateMany(values, min, max, step) + continue + } + // "-" + i := strings.Index(s, "-") + if i >= 0 { + populateMany(values, atoi(s[:i]), atoi(s[i+1:]), step) + continue + } + // single value with interval + if step > 0 { + populateMany(values, atoi(s), max, step) + continue + } + // single value + populateOne(values, atoi(s)) + } + + return toList(values) +} + +/******************************************************************************/ + +// Local helpers + +func extractInterval(s string) (int, string) { + step := 0 + i := strings.Index(s, "/") + if i >= 0 { + step = atoi(s[i+1:]) + s = s[:i] + } + return step, s +} + +func atoi(s string) int { + v, err := strconv.Atoi(s) + if err != nil { + panic(err) + } + return v +} + +func populateOne(values map[int]bool, v int) { + values[v] = true +} + +func populateMany(values map[int]bool, min, max, step int) { + if step == 0 { + step = 1 + } + for i := min; i <= max; i += step { + values[i] = true + } +} + +func toList(set map[int]bool) []int { + list := make([]int, len(set)) + i := 0 + for k, _ := range set { + list[i] = k + i += 1 + } + sort.Ints(list) + return list +} From ff635a4dd33ee76c87796ef14a156a5c1685cef2 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 15:05:08 -0400 Subject: [PATCH 004/105] README.md --- README.md | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 9055cb3..b1ae6e2 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,24 @@ gocronexpression ================ -Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression +Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. + +Install +------- + + go get github.com/gorhill/cronexpression + +Usage +----- + +Import the library: + + import "github.com/gorhill/cronexpression" + import "time" + +Simplest way: + + ... + nextTime := cronexpression.NextTimeFromCronString("* * 29 2 *", time.Now()) + +Assuming *time.Now()* is "2013-08-29 09:28:00", then *nextTime* will be "Monday, February 29, 2016 00:00:00". From 612c9d3d632fd64d97dcf87ac4b2af71b2d19c86 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 15:05:08 -0400 Subject: [PATCH 005/105] README.md --- README.md | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 9055cb3..b1ae6e2 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,24 @@ gocronexpression ================ -Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression +Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. + +Install +------- + + go get github.com/gorhill/cronexpression + +Usage +----- + +Import the library: + + import "github.com/gorhill/cronexpression" + import "time" + +Simplest way: + + ... + nextTime := cronexpression.NextTimeFromCronString("* * 29 2 *", time.Now()) + +Assuming *time.Now()* is "2013-08-29 09:28:00", then *nextTime* will be "Monday, February 29, 2016 00:00:00". From 665aee27b744aebf7d10dcf00ff575a3f38559b7 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 15:15:59 -0400 Subject: [PATCH 006/105] added more details --- README.md | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index b1ae6e2..f8b6fd4 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,9 @@ gocronexpression Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +The reference documentation for this implementation is found at +https://en.wikipedia.org/wiki/Cron#CRON_expression + Install ------- @@ -18,7 +21,14 @@ Import the library: Simplest way: - ... - nextTime := cronexpression.NextTimeFromCronString("* * 29 2 *", time.Now()) + nextTime := cronexpression.NextTimeFromCronString("0 0 29 2 *", time.Now()) + +Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". + +If you need to reuse many times a cron expression in your code, it is more efficient +to create a `CronExpression` object once and keep a copy of it for reuse: + + cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") + nextTime := cronexpr.NextTime(time.Now()) + -Assuming *time.Now()* is "2013-08-29 09:28:00", then *nextTime* will be "Monday, February 29, 2016 00:00:00". From 8d401e72b1d77ff14b1644716d4c09d50053de8d Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 15:15:59 -0400 Subject: [PATCH 007/105] added more details --- README.md | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index b1ae6e2..f8b6fd4 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,9 @@ gocronexpression Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +The reference documentation for this implementation is found at +https://en.wikipedia.org/wiki/Cron#CRON_expression + Install ------- @@ -18,7 +21,14 @@ Import the library: Simplest way: - ... - nextTime := cronexpression.NextTimeFromCronString("* * 29 2 *", time.Now()) + nextTime := cronexpression.NextTimeFromCronString("0 0 29 2 *", time.Now()) + +Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". + +If you need to reuse many times a cron expression in your code, it is more efficient +to create a `CronExpression` object once and keep a copy of it for reuse: + + cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") + nextTime := cronexpr.NextTime(time.Now()) + -Assuming *time.Now()* is "2013-08-29 09:28:00", then *nextTime* will be "Monday, February 29, 2016 00:00:00". From 23f103fe8edc8de86e25ce32ceb3cd91d2fad5d3 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 15:30:54 -0400 Subject: [PATCH 008/105] added more details --- README.md | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index f8b6fd4..cc8b77a 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,18 @@ -gocronexpression -================ +cronexpression for Go +===================== Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. The reference documentation for this implementation is found at -https://en.wikipedia.org/wiki/Cron#CRON_expression +https://en.wikipedia.org/wiki/Cron#CRON_expression, with the following +difference: + +* Supports the second field (before minute field) +* If five fields are present, a wildcard year field is appended +* If six field are present, "0" is prepended as second field +* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday, like zero. +* `@reboot` is not supported, as it is meaningless for a cron expression parser library +* As of now, the behavior of the code is undetermined if a malformed cron expression is supplied (most likely, code will panic) Install ------- From e0efb2872b2364c3b2729648b7de3494a6da646f Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 15:30:54 -0400 Subject: [PATCH 009/105] added more details --- README.md | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index f8b6fd4..cc8b77a 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,18 @@ -gocronexpression -================ +cronexpression for Go +===================== Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. The reference documentation for this implementation is found at -https://en.wikipedia.org/wiki/Cron#CRON_expression +https://en.wikipedia.org/wiki/Cron#CRON_expression, with the following +difference: + +* Supports the second field (before minute field) +* If five fields are present, a wildcard year field is appended +* If six field are present, "0" is prepended as second field +* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday, like zero. +* `@reboot` is not supported, as it is meaningless for a cron expression parser library +* As of now, the behavior of the code is undetermined if a malformed cron expression is supplied (most likely, code will panic) Install ------- From 73c6d6012a3cff79f72c6fb31a48b84f49c8cd09 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 18:58:01 -0400 Subject: [PATCH 010/105] fleshing out --- README.md | 2 +- cronexpression.go | 2 +- cronexpression_test.go | 109 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 111 insertions(+), 2 deletions(-) create mode 100644 cronexpression_test.go diff --git a/README.md b/README.md index cc8b77a..2d67405 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ Go language (golang) cron expression parser. Given a cron expression and a time The reference documentation for this implementation is found at https://en.wikipedia.org/wiki/Cron#CRON_expression, with the following -difference: +differences: * Supports the second field (before minute field) * If five fields are present, a wildcard year field is appended diff --git a/cronexpression.go b/cronexpression.go index 6b8fa6b..2cb6574 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -1,7 +1,7 @@ /*! * Copyright 2013 Raymond Hill * - * Project: github.com/gorhill/gocronexpression + * Project: github.com/gorhill/cronexpression * File: cronexpression.go * Version: 1.0 * License: GPL v3 see diff --git a/cronexpression_test.go b/cronexpression_test.go new file mode 100644 index 0000000..002e0db --- /dev/null +++ b/cronexpression_test.go @@ -0,0 +1,109 @@ +/*! + * Copyright 2013 Raymond Hill + * + * Project: github.com/gorhill/cronexpression + * File: cronexpression_test.go + * Version: 1.0 + * License: GPL v3 see + * + */ + +package cronexpression_test + +/******************************************************************************/ + +import ( + "cronexpression" + "testing" + "time" +) + +/******************************************************************************/ + +type crontimes struct { + from string + next string +} + +type crontest struct { + expr string + layout string + times []crontimes +} + +var crontests = []crontest{ + // Seconds + { + "* * * * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:00:01"}, + {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 23:59:59", "2013-01-02 00:00:00"}, + {"2013-02-28 23:59:59", "2013-03-01 00:00:00"}, + {"2016-02-28 23:59:59", "2016-02-29 00:00:00"}, + {"2012-12-31 23:59:59", "2013-01-01 00:00:00"}, + }, + }, + + // Minutes + { + "* * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:01:00"}, + {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 00:59:00", "2013-01-01 01:00:00"}, + {"2013-01-01 23:59:00", "2013-01-02 00:00:00"}, + {"2013-02-28 23:59:00", "2013-03-01 00:00:00"}, + {"2016-02-28 23:59:00", "2016-02-29 00:00:00"}, + {"2012-12-31 23:59:00", "2013-01-01 00:00:00"}, + }, + }, + + // Minutes with intervals + { + "17-43/5 * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:17:00"}, + {"2013-01-01 00:16:59", "2013-01-01 00:17:00"}, + {"2013-01-01 00:30:00", "2013-01-01 00:32:00"}, + {"2013-01-01 00:50:00", "2013-01-01 01:17:00"}, + {"2013-01-01 23:50:00", "2013-01-02 00:17:00"}, + {"2013-02-28 23:50:00", "2013-03-01 00:17:00"}, + {"2016-02-28 23:50:00", "2016-02-29 00:17:00"}, + {"2012-12-31 23:50:00", "2013-01-01 00:17:00"}, + }, + }, + + // Minutes interval, list + { + "15-30/4,55 * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:15:00"}, + {"2013-01-01 00:16:00", "2013-01-01 00:19:00"}, + {"2013-01-01 00:30:00", "2013-01-01 00:55:00"}, + {"2013-01-01 00:55:00", "2013-01-01 01:15:00"}, + {"2013-01-01 23:55:00", "2013-01-02 00:15:00"}, + {"2013-02-28 23:55:00", "2013-03-01 00:15:00"}, + {"2016-02-28 23:55:00", "2016-02-29 00:15:00"}, + {"2012-12-31 23:55:00", "2013-01-01 00:15:00"}, + }, + }, + + // TODO: more tests +} + +func TestCronExpressions(t *testing.T) { + for _, test := range crontests { + for _, times := range test.times { + from, _ := time.Parse("2006-01-02 15:04:05", times.from) + next := cronexpression.NextTimeFromCronString(test.expr, from) + if next.Format(test.layout) != times.next { + t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, next.Format(test.layout)) + } + } + } +} From e15b9a67dee3a64dd77636c1a3936dcc401586b7 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 18:58:01 -0400 Subject: [PATCH 011/105] fleshing out --- README.md | 2 +- cronexpression.go | 2 +- cronexpression_test.go | 109 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 111 insertions(+), 2 deletions(-) create mode 100644 cronexpression_test.go diff --git a/README.md b/README.md index cc8b77a..2d67405 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ Go language (golang) cron expression parser. Given a cron expression and a time The reference documentation for this implementation is found at https://en.wikipedia.org/wiki/Cron#CRON_expression, with the following -difference: +differences: * Supports the second field (before minute field) * If five fields are present, a wildcard year field is appended diff --git a/cronexpression.go b/cronexpression.go index 6b8fa6b..2cb6574 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -1,7 +1,7 @@ /*! * Copyright 2013 Raymond Hill * - * Project: github.com/gorhill/gocronexpression + * Project: github.com/gorhill/cronexpression * File: cronexpression.go * Version: 1.0 * License: GPL v3 see diff --git a/cronexpression_test.go b/cronexpression_test.go new file mode 100644 index 0000000..002e0db --- /dev/null +++ b/cronexpression_test.go @@ -0,0 +1,109 @@ +/*! + * Copyright 2013 Raymond Hill + * + * Project: github.com/gorhill/cronexpression + * File: cronexpression_test.go + * Version: 1.0 + * License: GPL v3 see + * + */ + +package cronexpression_test + +/******************************************************************************/ + +import ( + "cronexpression" + "testing" + "time" +) + +/******************************************************************************/ + +type crontimes struct { + from string + next string +} + +type crontest struct { + expr string + layout string + times []crontimes +} + +var crontests = []crontest{ + // Seconds + { + "* * * * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:00:01"}, + {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 23:59:59", "2013-01-02 00:00:00"}, + {"2013-02-28 23:59:59", "2013-03-01 00:00:00"}, + {"2016-02-28 23:59:59", "2016-02-29 00:00:00"}, + {"2012-12-31 23:59:59", "2013-01-01 00:00:00"}, + }, + }, + + // Minutes + { + "* * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:01:00"}, + {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 00:59:00", "2013-01-01 01:00:00"}, + {"2013-01-01 23:59:00", "2013-01-02 00:00:00"}, + {"2013-02-28 23:59:00", "2013-03-01 00:00:00"}, + {"2016-02-28 23:59:00", "2016-02-29 00:00:00"}, + {"2012-12-31 23:59:00", "2013-01-01 00:00:00"}, + }, + }, + + // Minutes with intervals + { + "17-43/5 * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:17:00"}, + {"2013-01-01 00:16:59", "2013-01-01 00:17:00"}, + {"2013-01-01 00:30:00", "2013-01-01 00:32:00"}, + {"2013-01-01 00:50:00", "2013-01-01 01:17:00"}, + {"2013-01-01 23:50:00", "2013-01-02 00:17:00"}, + {"2013-02-28 23:50:00", "2013-03-01 00:17:00"}, + {"2016-02-28 23:50:00", "2016-02-29 00:17:00"}, + {"2012-12-31 23:50:00", "2013-01-01 00:17:00"}, + }, + }, + + // Minutes interval, list + { + "15-30/4,55 * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:15:00"}, + {"2013-01-01 00:16:00", "2013-01-01 00:19:00"}, + {"2013-01-01 00:30:00", "2013-01-01 00:55:00"}, + {"2013-01-01 00:55:00", "2013-01-01 01:15:00"}, + {"2013-01-01 23:55:00", "2013-01-02 00:15:00"}, + {"2013-02-28 23:55:00", "2013-03-01 00:15:00"}, + {"2016-02-28 23:55:00", "2016-02-29 00:15:00"}, + {"2012-12-31 23:55:00", "2013-01-01 00:15:00"}, + }, + }, + + // TODO: more tests +} + +func TestCronExpressions(t *testing.T) { + for _, test := range crontests { + for _, times := range test.times { + from, _ := time.Parse("2006-01-02 15:04:05", times.from) + next := cronexpression.NextTimeFromCronString(test.expr, from) + if next.Format(test.layout) != times.next { + t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, next.Format(test.layout)) + } + } + } +} From 4b1e599c97139fbef69ecaf038b8548ea7277073 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:37:04 -0400 Subject: [PATCH 012/105] fleshing out --- README.md | 63 ++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 53 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 2d67405..90b8ecb 100644 --- a/README.md +++ b/README.md @@ -1,27 +1,70 @@ cronexpression for Go ===================== +Cron expression parser in Go language (golang). -Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +Implementation +-------------- The reference documentation for this implementation is found at -https://en.wikipedia.org/wiki/Cron#CRON_expression, with the following -differences: +https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (laziness) with modifications where this implementation differs: -* Supports the second field (before minute field) + Field name Mandatory? Allowed values Allowed special characters + ---------- ---------- -------------- -------------------------- + Minutes Yes 0-59 * / , - + Hours Yes 0-23 * / , - + Day of month Yes 1-31 * / , - ? L W + Month Yes 1-12 or JAN-DEC * / , - + Day of week Yes 0-6 or SUN-SAT * / , - ? L # + Year No 1970–2099 * / , - + +Asterisk ( * ) +-------------- +The asterisk indicates that the cron expression matches for all values of the field. E.g., using an asterisk in the 4th field (month) indicates every month. + +Slash ( / ) +----------- +Slashes describe increments of ranges. For example `3-59/15` in the minute field indicate the third minute of the hour and every 15 minutes thereafter. The form `*/...` is equivalent to the form "first-last/...", that is, an increment over the largest possible range of the field. + +Comma ( , ) +----------- +Commas are used to separate items of a list. For example, using `MON,WED,FRI` in the 5th field (day of week) means Mondays, Wednesdays and Fridays. + +Hyphen ( - ) +------------ +Hyphens define ranges. For example, 2000-2010 indicates every year between 2000 and 2010 AD, inclusive. + +L +- +`L` stands for "last". When used in the day-of-week field, it allows you to specify constructs such as "the last Friday" (`5L`) of a given month. In the day-of-month field, it specifies the last day of the month. + +W +- +The `W` character is allowed for the day-of-month field. This character is used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify `15W` as the value for the day-of-month field, the meaning is: "the nearest weekday to the 15th of the month." So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th is a Sunday, the trigger fires on Monday the 16th. If the 15th is a Tuesday, then it fires on Tuesday the 15th. However if you specify `1W` as the value for day-of-month, and the 1st is a Saturday, the trigger fires on Monday the 3rd, as it does not 'jump' over the boundary of a month's days. The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. + +Hash ( # ) +---------- +`#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. + +Question mark ( ? ) +------------------- +Note: Question mark is a non-standard character and exists only in some cron implementations. It is used instead of `*` for leaving either day-of-month or day-of-week blank. + +With the following differences: + +* Supports optional second field (before minute field) * If five fields are present, a wildcard year field is appended -* If six field are present, "0" is prepended as second field -* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday, like zero. -* `@reboot` is not supported, as it is meaningless for a cron expression parser library -* As of now, the behavior of the code is undetermined if a malformed cron expression is supplied (most likely, code will panic) +* If six field are present, `0` is prepended as second field, that is, `* * * * * *` internally become `0 * * * * * *`. +* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). +* `@reboot` is not supported +* As of now, the behavior of the code is undetermined if a malformed cron expression is supplied Install ------- - go get github.com/gorhill/cronexpression Usage ----- - Import the library: import "github.com/gorhill/cronexpression" From db81c0f41dd91b85d4c0557a2c267e550f8a1bf7 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:37:04 -0400 Subject: [PATCH 013/105] fleshing out --- README.md | 63 ++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 53 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 2d67405..90b8ecb 100644 --- a/README.md +++ b/README.md @@ -1,27 +1,70 @@ cronexpression for Go ===================== +Cron expression parser in Go language (golang). -Go language (golang) cron expression parser. Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +Implementation +-------------- The reference documentation for this implementation is found at -https://en.wikipedia.org/wiki/Cron#CRON_expression, with the following -differences: +https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (laziness) with modifications where this implementation differs: -* Supports the second field (before minute field) + Field name Mandatory? Allowed values Allowed special characters + ---------- ---------- -------------- -------------------------- + Minutes Yes 0-59 * / , - + Hours Yes 0-23 * / , - + Day of month Yes 1-31 * / , - ? L W + Month Yes 1-12 or JAN-DEC * / , - + Day of week Yes 0-6 or SUN-SAT * / , - ? L # + Year No 1970–2099 * / , - + +Asterisk ( * ) +-------------- +The asterisk indicates that the cron expression matches for all values of the field. E.g., using an asterisk in the 4th field (month) indicates every month. + +Slash ( / ) +----------- +Slashes describe increments of ranges. For example `3-59/15` in the minute field indicate the third minute of the hour and every 15 minutes thereafter. The form `*/...` is equivalent to the form "first-last/...", that is, an increment over the largest possible range of the field. + +Comma ( , ) +----------- +Commas are used to separate items of a list. For example, using `MON,WED,FRI` in the 5th field (day of week) means Mondays, Wednesdays and Fridays. + +Hyphen ( - ) +------------ +Hyphens define ranges. For example, 2000-2010 indicates every year between 2000 and 2010 AD, inclusive. + +L +- +`L` stands for "last". When used in the day-of-week field, it allows you to specify constructs such as "the last Friday" (`5L`) of a given month. In the day-of-month field, it specifies the last day of the month. + +W +- +The `W` character is allowed for the day-of-month field. This character is used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify `15W` as the value for the day-of-month field, the meaning is: "the nearest weekday to the 15th of the month." So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th is a Sunday, the trigger fires on Monday the 16th. If the 15th is a Tuesday, then it fires on Tuesday the 15th. However if you specify `1W` as the value for day-of-month, and the 1st is a Saturday, the trigger fires on Monday the 3rd, as it does not 'jump' over the boundary of a month's days. The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. + +Hash ( # ) +---------- +`#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. + +Question mark ( ? ) +------------------- +Note: Question mark is a non-standard character and exists only in some cron implementations. It is used instead of `*` for leaving either day-of-month or day-of-week blank. + +With the following differences: + +* Supports optional second field (before minute field) * If five fields are present, a wildcard year field is appended -* If six field are present, "0" is prepended as second field -* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday, like zero. -* `@reboot` is not supported, as it is meaningless for a cron expression parser library -* As of now, the behavior of the code is undetermined if a malformed cron expression is supplied (most likely, code will panic) +* If six field are present, `0` is prepended as second field, that is, `* * * * * *` internally become `0 * * * * * *`. +* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). +* `@reboot` is not supported +* As of now, the behavior of the code is undetermined if a malformed cron expression is supplied Install ------- - go get github.com/gorhill/cronexpression Usage ----- - Import the library: import "github.com/gorhill/cronexpression" From 5b42adc89af9cf7965c6b519e2ab3f168827f518 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:39:08 -0400 Subject: [PATCH 014/105] fleshing out --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 90b8ecb..0276218 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,8 @@ Cron expression parser in Go language (golang). Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +In another project, I decided to use Cron syntax to encode scheduling information. Thus this standalone library to parse and execute cron expressions. + Implementation -------------- The reference documentation for this implementation is found at From af4a7c4204d291f064d3cf8b8aa1f4ef36b3dfde Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:39:08 -0400 Subject: [PATCH 015/105] fleshing out --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 90b8ecb..0276218 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,8 @@ Cron expression parser in Go language (golang). Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +In another project, I decided to use Cron syntax to encode scheduling information. Thus this standalone library to parse and execute cron expressions. + Implementation -------------- The reference documentation for this implementation is found at From 7ebc5905b97dff022f74ec47334d27e9741f1ebc Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:41:35 -0400 Subject: [PATCH 016/105] fleshing out --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 0276218..2a5c0d8 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (la Field name Mandatory? Allowed values Allowed special characters ---------- ---------- -------------- -------------------------- + Seconds No 0-59 * / , - Minutes Yes 0-59 * / , - Hours Yes 0-23 * / , - Day of month Yes 1-31 * / , - ? L W From 664335f344d1fee5f72becd98fa37ee147bd1967 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:41:35 -0400 Subject: [PATCH 017/105] fleshing out --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 0276218..2a5c0d8 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (la Field name Mandatory? Allowed values Allowed special characters ---------- ---------- -------------- -------------------------- + Seconds No 0-59 * / , - Minutes Yes 0-59 * / , - Hours Yes 0-23 * / , - Day of month Yes 1-31 * / , - ? L W From fdfb033476eba223a5aca781095e1ffa72b28ba7 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:48:59 -0400 Subject: [PATCH 018/105] fleshing out --- README.md | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 2a5c0d8..5653a4b 100644 --- a/README.md +++ b/README.md @@ -16,9 +16,9 @@ https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (la Seconds No 0-59 * / , - Minutes Yes 0-59 * / , - Hours Yes 0-23 * / , - - Day of month Yes 1-31 * / , - ? L W + Day of month Yes 1-31 * / , - L W Month Yes 1-12 or JAN-DEC * / , - - Day of week Yes 0-6 or SUN-SAT * / , - ? L # + Day of week Yes 0-6 or SUN-SAT * / , - L # Year No 1970–2099 * / , - Asterisk ( * ) @@ -49,13 +49,20 @@ Hash ( # ) ---------- `#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. -Question mark ( ? ) -------------------- -Note: Question mark is a non-standard character and exists only in some cron implementations. It is used instead of `*` for leaving either day-of-month or day-of-week blank. +Predefined cron expressions +--------------------------- +(Copied from https://en.wikipedia.org/wiki/Cron#Predefined_scheduling_definitions, with text modified according to this implementation) -With the following differences: + Entry Description Equivalent to + @annually Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * + @yearly Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * + @monthly Run once a month at midnight in the morning of the first of the month 0 0 0 1 * * * + @weekly Run once a week at midnight in the morning of Sunday 0 0 0 * * 0 * + @daily Run once a day at midnight 0 0 0 * * * * + @hourly Run once an hour at the beginning of the hour 0 0 * * * * * -* Supports optional second field (before minute field) +Other details +------------- * If five fields are present, a wildcard year field is appended * If six field are present, `0` is prepended as second field, that is, `* * * * * *` internally become `0 * * * * * *`. * Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). From 584af0dd083c644a8be53f2b4f03a9aaffb96315 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:48:59 -0400 Subject: [PATCH 019/105] fleshing out --- README.md | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 2a5c0d8..5653a4b 100644 --- a/README.md +++ b/README.md @@ -16,9 +16,9 @@ https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (la Seconds No 0-59 * / , - Minutes Yes 0-59 * / , - Hours Yes 0-23 * / , - - Day of month Yes 1-31 * / , - ? L W + Day of month Yes 1-31 * / , - L W Month Yes 1-12 or JAN-DEC * / , - - Day of week Yes 0-6 or SUN-SAT * / , - ? L # + Day of week Yes 0-6 or SUN-SAT * / , - L # Year No 1970–2099 * / , - Asterisk ( * ) @@ -49,13 +49,20 @@ Hash ( # ) ---------- `#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. -Question mark ( ? ) -------------------- -Note: Question mark is a non-standard character and exists only in some cron implementations. It is used instead of `*` for leaving either day-of-month or day-of-week blank. +Predefined cron expressions +--------------------------- +(Copied from https://en.wikipedia.org/wiki/Cron#Predefined_scheduling_definitions, with text modified according to this implementation) -With the following differences: + Entry Description Equivalent to + @annually Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * + @yearly Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * + @monthly Run once a month at midnight in the morning of the first of the month 0 0 0 1 * * * + @weekly Run once a week at midnight in the morning of Sunday 0 0 0 * * 0 * + @daily Run once a day at midnight 0 0 0 * * * * + @hourly Run once an hour at the beginning of the hour 0 0 * * * * * -* Supports optional second field (before minute field) +Other details +------------- * If five fields are present, a wildcard year field is appended * If six field are present, `0` is prepended as second field, that is, `* * * * * *` internally become `0 * * * * * *`. * Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). From c1b1ffb251d344564923f96053f30ce76b157b7e Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:53:58 -0400 Subject: [PATCH 020/105] fleshing out --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 5653a4b..b9b8cb2 100644 --- a/README.md +++ b/README.md @@ -60,13 +60,13 @@ Predefined cron expressions @weekly Run once a week at midnight in the morning of Sunday 0 0 0 * * 0 * @daily Run once a day at midnight 0 0 0 * * * * @hourly Run once an hour at the beginning of the hour 0 0 * * * * * + @reboot Not supported Other details ------------- -* If five fields are present, a wildcard year field is appended -* If six field are present, `0` is prepended as second field, that is, `* * * * * *` internally become `0 * * * * * *`. -* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). -* `@reboot` is not supported +* If only five fields are present, a wildcard year field is appended, that is, `* * * * *` internally become `0 * * * * * *`. +* If only six field are present, `0` is prepended as second field, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. +* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). This to comply with http://linux.die.net/man/5/crontab#. * As of now, the behavior of the code is undetermined if a malformed cron expression is supplied Install From ffde273e504cb1000e3278d423aa6cd5582d20e0 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:53:58 -0400 Subject: [PATCH 021/105] fleshing out --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 5653a4b..b9b8cb2 100644 --- a/README.md +++ b/README.md @@ -60,13 +60,13 @@ Predefined cron expressions @weekly Run once a week at midnight in the morning of Sunday 0 0 0 * * 0 * @daily Run once a day at midnight 0 0 0 * * * * @hourly Run once an hour at the beginning of the hour 0 0 * * * * * + @reboot Not supported Other details ------------- -* If five fields are present, a wildcard year field is appended -* If six field are present, `0` is prepended as second field, that is, `* * * * * *` internally become `0 * * * * * *`. -* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). -* `@reboot` is not supported +* If only five fields are present, a wildcard year field is appended, that is, `* * * * *` internally become `0 * * * * * *`. +* If only six field are present, `0` is prepended as second field, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. +* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). This to comply with http://linux.die.net/man/5/crontab#. * As of now, the behavior of the code is undetermined if a malformed cron expression is supplied Install From 1a6c1978db01f4b5b820dc3f7c7111575b30f0a1 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:55:54 -0400 Subject: [PATCH 022/105] fleshing out --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index b9b8cb2..0d23b1b 100644 --- a/README.md +++ b/README.md @@ -64,8 +64,8 @@ Predefined cron expressions Other details ------------- -* If only five fields are present, a wildcard year field is appended, that is, `* * * * *` internally become `0 * * * * * *`. -* If only six field are present, `0` is prepended as second field, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. +* If only six field are present, a `0` second field is prepended, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. +* If only five fields are present, a `0` second field is prepended and a wildcard year field is appended, that is, `* * * * *` internally become `0 * * * * * *`. * Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). This to comply with http://linux.die.net/man/5/crontab#. * As of now, the behavior of the code is undetermined if a malformed cron expression is supplied From 9774af70eac13fd5d38ce4980c6432a8644eaf93 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 19:55:54 -0400 Subject: [PATCH 023/105] fleshing out --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index b9b8cb2..0d23b1b 100644 --- a/README.md +++ b/README.md @@ -64,8 +64,8 @@ Predefined cron expressions Other details ------------- -* If only five fields are present, a wildcard year field is appended, that is, `* * * * *` internally become `0 * * * * * *`. -* If only six field are present, `0` is prepended as second field, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. +* If only six field are present, a `0` second field is prepended, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. +* If only five fields are present, a `0` second field is prepended and a wildcard year field is appended, that is, `* * * * *` internally become `0 * * * * * *`. * Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). This to comply with http://linux.die.net/man/5/crontab#. * As of now, the behavior of the code is undetermined if a malformed cron expression is supplied From 8fadb724ca0f3a3ff741698e2b5a1e416a674e3b Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:06:45 -0400 Subject: [PATCH 024/105] fleshing out --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 0d23b1b..ffb3917 100644 --- a/README.md +++ b/README.md @@ -91,5 +91,7 @@ to create a `CronExpression` object once and keep a copy of it for reuse: cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") nextTime := cronexpr.NextTime(time.Now()) + +`Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, `cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now()))` will return `true`, whereas `cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now()))` will return false (as of 2013-08-29...) From a8244603b572a665a5ea427d99ad94b843adaf94 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:06:45 -0400 Subject: [PATCH 025/105] fleshing out --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 0d23b1b..ffb3917 100644 --- a/README.md +++ b/README.md @@ -91,5 +91,7 @@ to create a `CronExpression` object once and keep a copy of it for reuse: cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") nextTime := cronexpr.NextTime(time.Now()) + +`Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, `cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now()))` will return `true`, whereas `cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now()))` will return false (as of 2013-08-29...) From 875583e5314e0a2c2c2dc78471f613767acaf544 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:07:47 -0400 Subject: [PATCH 026/105] fleshing out --- README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ffb3917..ff2cfe7 100644 --- a/README.md +++ b/README.md @@ -92,6 +92,10 @@ to create a `CronExpression` object once and keep a copy of it for reuse: cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") nextTime := cronexpr.NextTime(time.Now()) -`Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, `cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now()))` will return `true`, whereas `cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now()))` will return false (as of 2013-08-29...) +`Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, + cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) +will return `true`, whereas + cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) +will return false (as of 2013-08-29...) From 6d87e60fc4602e3f037cca84d6657acd415cdf08 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:07:47 -0400 Subject: [PATCH 027/105] fleshing out --- README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ffb3917..ff2cfe7 100644 --- a/README.md +++ b/README.md @@ -92,6 +92,10 @@ to create a `CronExpression` object once and keep a copy of it for reuse: cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") nextTime := cronexpr.NextTime(time.Now()) -`Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, `cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now()))` will return `true`, whereas `cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now()))` will return false (as of 2013-08-29...) +`Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, + cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) +will return `true`, whereas + cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) +will return false (as of 2013-08-29...) From f60006f5a91f796f21d2855f4715bf51fcc58c0a Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:08:22 -0400 Subject: [PATCH 028/105] fleshing out --- README.md | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index ff2cfe7..55c28aa 100644 --- a/README.md +++ b/README.md @@ -93,9 +93,12 @@ to create a `CronExpression` object once and keep a copy of it for reuse: nextTime := cronexpr.NextTime(time.Now()) `Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, - cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) -will return `true`, whereas - cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) -will return false (as of 2013-08-29...) - + + cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) + +will return `true`, whereas + + cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) + +will return false (as of 2013-08-29...) From 536d6c6cd241936e7f9ca5e9495df8e69090c90a Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:08:22 -0400 Subject: [PATCH 029/105] fleshing out --- README.md | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index ff2cfe7..55c28aa 100644 --- a/README.md +++ b/README.md @@ -93,9 +93,12 @@ to create a `CronExpression` object once and keep a copy of it for reuse: nextTime := cronexpr.NextTime(time.Now()) `Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, - cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) -will return `true`, whereas - cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) -will return false (as of 2013-08-29...) - + + cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) + +will return `true`, whereas + + cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) + +will return false (as of 2013-08-29...) From 867274cf67bf53bb2a2bdc94f9952be46d5845de Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:09:16 -0400 Subject: [PATCH 030/105] fleshing out --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 55c28aa..8968226 100644 --- a/README.md +++ b/README.md @@ -100,5 +100,5 @@ will return `true`, whereas cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) -will return false (as of 2013-08-29...) +will return `false` (as of 2013-08-29...) From 3ce59d04d0d459911f8e8b2ce03714a19a26d826 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:09:16 -0400 Subject: [PATCH 031/105] fleshing out --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 55c28aa..8968226 100644 --- a/README.md +++ b/README.md @@ -100,5 +100,5 @@ will return `true`, whereas cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) -will return false (as of 2013-08-29...) +will return `false` (as of 2013-08-29...) From 82e0763e2cabbbb6ad96d17e11f1c2bc1fa402af Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:10:42 -0400 Subject: [PATCH 032/105] fleshing out --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8968226..94b69aa 100644 --- a/README.md +++ b/README.md @@ -92,7 +92,7 @@ to create a `CronExpression` object once and keep a copy of it for reuse: cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") nextTime := cronexpr.NextTime(time.Now()) -`Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, +Use `cronexpression.NoMatch()` to find out whether a valid time was returned. For exemple, cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) From 16d55f80353f26accac9836bc9a0b58b44713601 Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 29 Aug 2013 20:10:42 -0400 Subject: [PATCH 033/105] fleshing out --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8968226..94b69aa 100644 --- a/README.md +++ b/README.md @@ -92,7 +92,7 @@ to create a `CronExpression` object once and keep a copy of it for reuse: cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") nextTime := cronexpr.NextTime(time.Now()) -`Use cronexpression.NoMatch(nextTime)` to find out whether a valid time was returned. For exemple, +Use `cronexpression.NoMatch()` to find out whether a valid time was returned. For exemple, cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) From 3ef71a99cab717fd23f05681e008ed68dcf69d56 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 07:36:30 -0400 Subject: [PATCH 034/105] fleshing out --- cronexpression.go | 4 ++-- cronexpression_test.go | 20 +++++++++++++++++--- 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/cronexpression.go b/cronexpression.go index 2cb6574..b64eb00 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -604,7 +604,7 @@ func (cronexpr *CronExpression) dayofmonthFieldParse(cronField string) error { cronexpr.daysOfMonth = make(map[int]bool) // days of month map cronexpr.workdaysOfMonth = make(map[int]bool) // work day of month map - // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + // Comma separator is used to mix different allowed syntax cronList := strings.Split(cronField, ",") for _, s := range cronList { // "/" @@ -651,7 +651,7 @@ func genericFieldParse(cronField string, min, max int) []int { // Defaults values := make(map[int]bool) - // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + // Comma separator is used to mix different allowed syntax cronList := strings.Split(cronField, ",") for _, s := range cronList { // "/" diff --git a/cronexpression_test.go b/cronexpression_test.go index 002e0db..5501baa 100644 --- a/cronexpression_test.go +++ b/cronexpression_test.go @@ -39,6 +39,7 @@ var crontests = []crontest{ []crontimes{ {"2013-01-01 00:00:00", "2013-01-01 00:00:01"}, {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 00:59:59", "2013-01-01 01:00:00"}, {"2013-01-01 23:59:59", "2013-01-02 00:00:00"}, {"2013-02-28 23:59:59", "2013-03-01 00:00:00"}, {"2016-02-28 23:59:59", "2016-02-29 00:00:00"}, @@ -61,7 +62,7 @@ var crontests = []crontest{ }, }, - // Minutes with intervals + // Minutes with interval { "17-43/5 * * * *", "2006-01-02 15:04:05", @@ -89,10 +90,22 @@ var crontests = []crontest{ {"2013-01-01 23:55:00", "2013-01-02 00:15:00"}, {"2013-02-28 23:55:00", "2013-03-01 00:15:00"}, {"2016-02-28 23:55:00", "2016-02-29 00:15:00"}, + {"2012-12-31 23:54:00", "2012-12-31 23:55:00"}, {"2012-12-31 23:55:00", "2013-01-01 00:15:00"}, }, }, + // Days of week + { + "0 0 * * MON", + "MON 2006-01-02 15:04", + []crontimes{ + {"2013-01-01 00:00:00", "MON 2013-01-07 00:00"}, + {"2013-01-28 00:00:00", "MON 2013-02-04 00:00"}, + {"2013-12-30 00:30:00", "MON 2014-01-06 00:00"}, + }, + }, + // TODO: more tests } @@ -101,8 +114,9 @@ func TestCronExpressions(t *testing.T) { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) next := cronexpression.NextTimeFromCronString(test.expr, from) - if next.Format(test.layout) != times.next { - t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, next.Format(test.layout)) + nextstr := next.Format(test.layout) + if nextstr != times.next { + t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) } } } From 1c56081e0027a04fff73faab025dbb4f96dd2dc4 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 07:36:30 -0400 Subject: [PATCH 035/105] fleshing out --- cronexpression.go | 4 ++-- cronexpression_test.go | 20 +++++++++++++++++--- 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/cronexpression.go b/cronexpression.go index 2cb6574..b64eb00 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -604,7 +604,7 @@ func (cronexpr *CronExpression) dayofmonthFieldParse(cronField string) error { cronexpr.daysOfMonth = make(map[int]bool) // days of month map cronexpr.workdaysOfMonth = make(map[int]bool) // work day of month map - // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + // Comma separator is used to mix different allowed syntax cronList := strings.Split(cronField, ",") for _, s := range cronList { // "/" @@ -651,7 +651,7 @@ func genericFieldParse(cronField string, min, max int) []int { // Defaults values := make(map[int]bool) - // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + // Comma separator is used to mix different allowed syntax cronList := strings.Split(cronField, ",") for _, s := range cronList { // "/" diff --git a/cronexpression_test.go b/cronexpression_test.go index 002e0db..5501baa 100644 --- a/cronexpression_test.go +++ b/cronexpression_test.go @@ -39,6 +39,7 @@ var crontests = []crontest{ []crontimes{ {"2013-01-01 00:00:00", "2013-01-01 00:00:01"}, {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 00:59:59", "2013-01-01 01:00:00"}, {"2013-01-01 23:59:59", "2013-01-02 00:00:00"}, {"2013-02-28 23:59:59", "2013-03-01 00:00:00"}, {"2016-02-28 23:59:59", "2016-02-29 00:00:00"}, @@ -61,7 +62,7 @@ var crontests = []crontest{ }, }, - // Minutes with intervals + // Minutes with interval { "17-43/5 * * * *", "2006-01-02 15:04:05", @@ -89,10 +90,22 @@ var crontests = []crontest{ {"2013-01-01 23:55:00", "2013-01-02 00:15:00"}, {"2013-02-28 23:55:00", "2013-03-01 00:15:00"}, {"2016-02-28 23:55:00", "2016-02-29 00:15:00"}, + {"2012-12-31 23:54:00", "2012-12-31 23:55:00"}, {"2012-12-31 23:55:00", "2013-01-01 00:15:00"}, }, }, + // Days of week + { + "0 0 * * MON", + "MON 2006-01-02 15:04", + []crontimes{ + {"2013-01-01 00:00:00", "MON 2013-01-07 00:00"}, + {"2013-01-28 00:00:00", "MON 2013-02-04 00:00"}, + {"2013-12-30 00:30:00", "MON 2014-01-06 00:00"}, + }, + }, + // TODO: more tests } @@ -101,8 +114,9 @@ func TestCronExpressions(t *testing.T) { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) next := cronexpression.NextTimeFromCronString(test.expr, from) - if next.Format(test.layout) != times.next { - t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, next.Format(test.layout)) + nextstr := next.Format(test.layout) + if nextstr != times.next { + t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) } } } From 8884f283a4cdbcf3283bba3a1bbd3d8d378c8088 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 08:00:00 -0400 Subject: [PATCH 036/105] oops typos, oct=10,nov=11,dec=12 not 1,2,3... --- cronexpression.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cronexpression.go b/cronexpression.go index b64eb00..304a985 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -515,9 +515,9 @@ var cronNormalizer = strings.NewReplacer( "jul", "7", "aug", "8", "sep", "9", - "oct", "0", - "nov", "1", - "dec", "2", + "oct", "10", + "nov", "11", + "dec", "12", "sun", "0", "mon", "1", "tue", "2", From 7613fbf12f2ef128322491f0931f639f471a0406 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 08:05:01 -0400 Subject: [PATCH 037/105] trivial --- README.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 94b69aa..b5ff827 100644 --- a/README.md +++ b/README.md @@ -4,12 +4,12 @@ Cron expression parser in Go language (golang). Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. -In another project, I decided to use Cron syntax to encode scheduling information. Thus this standalone library to parse and execute cron expressions. +In another project, I decided to use Cron syntax to encode scheduling information. Thus this standalone library to parse and apply time stamps to cron expressions. Implementation -------------- The reference documentation for this implementation is found at -https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (laziness) with modifications where this implementation differs: +https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (laziness!) with modifications where this implementation differs: Field name Mandatory? Allowed values Allowed special characters ---------- ---------- -------------- -------------------------- @@ -64,7 +64,7 @@ Predefined cron expressions Other details ------------- -* If only six field are present, a `0` second field is prepended, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. +* If only six fields are present, a `0` second field is prepended, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. * If only five fields are present, a `0` second field is prepended and a wildcard year field is appended, that is, `* * * * *` internally become `0 * * * * * *`. * Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). This to comply with http://linux.die.net/man/5/crontab#. * As of now, the behavior of the code is undetermined if a malformed cron expression is supplied @@ -91,8 +91,9 @@ to create a `CronExpression` object once and keep a copy of it for reuse: cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") nextTime := cronexpr.NextTime(time.Now()) + ... -Use `cronexpression.NoMatch()` to find out whether a valid time was returned. For exemple, +Use `cronexpression.NoMatch()` to find out whether a valid time was returned. For example, cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) From c805a2ea5cced8072c53f67f1dceb75e353221ef Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 08:12:14 -0400 Subject: [PATCH 038/105] Changed NextTimeFromCronString() to NextTimeFromString() --- README.md | 6 +++--- cronexpression.go | 8 ++++---- cronexpression_test.go | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index b5ff827..ad81ffb 100644 --- a/README.md +++ b/README.md @@ -82,7 +82,7 @@ Import the library: Simplest way: - nextTime := cronexpression.NextTimeFromCronString("0 0 29 2 *", time.Now()) + nextTime := cronexpression.NextTimeFromString("0 0 29 2 *", time.Now()) Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". @@ -95,11 +95,11 @@ to create a `CronExpression` object once and keep a copy of it for reuse: Use `cronexpression.NoMatch()` to find out whether a valid time was returned. For example, - cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 1980", time.Now())) + cronexpression.NoMatch(cronexpression.NextTimeFromString("* * * * * 1980", time.Now())) will return `true`, whereas - cronexpression.NoMatch(cronexpression.NextTimeFromCronString("* * * * * 2050", time.Now())) + cronexpression.NoMatch(cronexpression.NextTimeFromString("* * * * * 2050", time.Now())) will return `false` (as of 2013-08-29...) diff --git a/cronexpression.go b/cronexpression.go index 304a985..117b14f 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -100,26 +100,26 @@ func NewCronExpression(cronLine string) *CronExpression { /******************************************************************************/ -// NextTimeFromCronString() returns the time stamp following fromTime which +// NextTimeFromString() returns the time stamp following fromTime which // satisfies the cron expression cronLine. If no matching time stamp is found, // using NoMatch() with the returned time stamp as argument will return true. // // If the same cron expression must be used repeatedly, it is better to use // NewCronExpression() in order to avoid overhead of cron expression parsing. -func NextTimeFromCronString(cronLine string, fromTime time.Time) time.Time { +func NextTimeFromString(cronLine string, fromTime time.Time) time.Time { cronexpr := NewCronExpression(cronLine) return cronexpr.NextTime(fromTime) } /******************************************************************************/ -// NextTimeNFromCronString() returns the n time stamps following fromTime which +// NextTimeNFromString() returns the n time stamps following fromTime which // satisfy the cron expression cronLine. An empty list is returned if // there is no matching time stamp. // // If the same cron expression must be used repeatedly, it is better to use // NewCronExpression() in order to avoid overhead of cron expression parsing. -func NextTimeNFromCronString(cronLine string, fromTime time.Time, n int) []time.Time { +func NextTimeNFromString(cronLine string, fromTime time.Time, n int) []time.Time { cronexpr := NewCronExpression(cronLine) return cronexpr.NextTimeN(fromTime, n) } diff --git a/cronexpression_test.go b/cronexpression_test.go index 5501baa..7b73bc5 100644 --- a/cronexpression_test.go +++ b/cronexpression_test.go @@ -113,7 +113,7 @@ func TestCronExpressions(t *testing.T) { for _, test := range crontests { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) - next := cronexpression.NextTimeFromCronString(test.expr, from) + next := cronexpression.NextTimeFromString(test.expr, from) nextstr := next.Format(test.layout) if nextstr != times.next { t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) From 22a2cb9e9945c4d59a1f6e4685528a81d9216e08 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 08:16:18 -0400 Subject: [PATCH 039/105] Changed NextTimeFromString() to NextTime() --- README.md | 8 ++++---- cronexpression.go | 4 ++-- cronexpression_test.go | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index ad81ffb..b8b6765 100644 --- a/README.md +++ b/README.md @@ -82,11 +82,11 @@ Import the library: Simplest way: - nextTime := cronexpression.NextTimeFromString("0 0 29 2 *", time.Now()) + nextTime := cronexpression.NextTime("0 0 29 2 *", time.Now()) Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". -If you need to reuse many times a cron expression in your code, it is more efficient +If you need to reuse many times the same cron expression in your code, it is more efficient to create a `CronExpression` object once and keep a copy of it for reuse: cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") @@ -95,11 +95,11 @@ to create a `CronExpression` object once and keep a copy of it for reuse: Use `cronexpression.NoMatch()` to find out whether a valid time was returned. For example, - cronexpression.NoMatch(cronexpression.NextTimeFromString("* * * * * 1980", time.Now())) + cronexpression.NoMatch(cronexpression.NextTime("* * * * * 1980", time.Now())) will return `true`, whereas - cronexpression.NoMatch(cronexpression.NextTimeFromString("* * * * * 2050", time.Now())) + cronexpression.NoMatch(cronexpression.NextTime("* * * * * 2050", time.Now())) will return `false` (as of 2013-08-29...) diff --git a/cronexpression.go b/cronexpression.go index 117b14f..a8f88bf 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -106,7 +106,7 @@ func NewCronExpression(cronLine string) *CronExpression { // // If the same cron expression must be used repeatedly, it is better to use // NewCronExpression() in order to avoid overhead of cron expression parsing. -func NextTimeFromString(cronLine string, fromTime time.Time) time.Time { +func NextTime(cronLine string, fromTime time.Time) time.Time { cronexpr := NewCronExpression(cronLine) return cronexpr.NextTime(fromTime) } @@ -119,7 +119,7 @@ func NextTimeFromString(cronLine string, fromTime time.Time) time.Time { // // If the same cron expression must be used repeatedly, it is better to use // NewCronExpression() in order to avoid overhead of cron expression parsing. -func NextTimeNFromString(cronLine string, fromTime time.Time, n int) []time.Time { +func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time { cronexpr := NewCronExpression(cronLine) return cronexpr.NextTimeN(fromTime, n) } diff --git a/cronexpression_test.go b/cronexpression_test.go index 7b73bc5..451b09b 100644 --- a/cronexpression_test.go +++ b/cronexpression_test.go @@ -113,7 +113,7 @@ func TestCronExpressions(t *testing.T) { for _, test := range crontests { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) - next := cronexpression.NextTimeFromString(test.expr, from) + next := cronexpression.NextTime(test.expr, from) nextstr := next.Format(test.layout) if nextstr != times.next { t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) From 7ea56a88b3b72e92722cf102977832683760533a Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 08:19:58 -0400 Subject: [PATCH 040/105] fixed comments --- cronexpression.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cronexpression.go b/cronexpression.go index a8f88bf..0d2e73c 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -100,7 +100,7 @@ func NewCronExpression(cronLine string) *CronExpression { /******************************************************************************/ -// NextTimeFromString() returns the time stamp following fromTime which +// NextTime() returns the time stamp following fromTime which // satisfies the cron expression cronLine. If no matching time stamp is found, // using NoMatch() with the returned time stamp as argument will return true. // @@ -113,7 +113,7 @@ func NextTime(cronLine string, fromTime time.Time) time.Time { /******************************************************************************/ -// NextTimeNFromString() returns the n time stamps following fromTime which +// NextTimeN() returns the n time stamps following fromTime which // satisfy the cron expression cronLine. An empty list is returned if // there is no matching time stamp. // From fc59c37234739735ac9546df60817c92967682d0 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 08:26:18 -0400 Subject: [PATCH 041/105] fleshing out comments --- cronexpression.go | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/cronexpression.go b/cronexpression.go index 0d2e73c..4b1e012 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -135,10 +135,15 @@ func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { return fromTime } - // First we need to ensure supplied time stamp matches + // Since cronexpr.nextSecond()-cronexpr.nextMonth() expects that the + // supplied time stamp is a perfect match to the underlying cron + // expression, and since this function is an entry point where `fromTime` + // does not necessarily matches the underlying cron expression, + // we first need to ensure supplied time stamp matches // the cron expression. If not, this means the supplied time - // stamp might be between matching time stamps, thus we move - // to closest matching time stamp without changing time stamp + // stamp falls in between matching time stamps, thus we move + // to closest future matching time stamp without changing time + // stamp // year v := fromTime.Year() @@ -359,7 +364,7 @@ func (cronexpr *CronExpression) calculateActualDaysOfMonth(year, month int) []in offset := 7 - int(timeOrigin.Weekday()) // days of week // offset : (7 - day_of_week_of_1st_day_of_month) - // target : (7 * week_of_month) + (offset + day_of_week) % 7 + 1 + // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 for w := 0; w <= 4; w += 1 { for v, _ := range cronexpr.daysOfWeek { v := 1 + w*7 + (offset+v)%7 @@ -370,7 +375,7 @@ func (cronexpr *CronExpression) calculateActualDaysOfMonth(year, month int) []in } // days of week of specific week in the month // offset : (7 - day_of_week_of_1st_day_of_month) - // target : (7 * week_of_month) + (offset + day_of_week) % 7 + 1 + // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 for v, _ := range cronexpr.specificWeekDaysOfWeek { v := 1 + 7*(v/7) + (offset+v)%7 if v <= lastDayOfMonth { From 8c1493f10593e92867c3c3f975f4fcc4fcd9d6ae Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 08:59:49 -0400 Subject: [PATCH 042/105] added API documentation --- README.md | 50 ++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 36 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index b8b6765..decb302 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,8 @@ Given a cron expression and a time stamp, you can get the next time stamp which In another project, I decided to use Cron syntax to encode scheduling information. Thus this standalone library to parse and apply time stamps to cron expressions. +The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. + Implementation -------------- The reference documentation for this implementation is found at @@ -21,32 +23,25 @@ https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (la Day of week Yes 0-6 or SUN-SAT * / , - L # Year No 1970–2099 * / , - -Asterisk ( * ) --------------- +### Asterisk ( * ) The asterisk indicates that the cron expression matches for all values of the field. E.g., using an asterisk in the 4th field (month) indicates every month. -Slash ( / ) ------------ +### Slash ( / ) Slashes describe increments of ranges. For example `3-59/15` in the minute field indicate the third minute of the hour and every 15 minutes thereafter. The form `*/...` is equivalent to the form "first-last/...", that is, an increment over the largest possible range of the field. -Comma ( , ) ------------ +### Comma ( , ) Commas are used to separate items of a list. For example, using `MON,WED,FRI` in the 5th field (day of week) means Mondays, Wednesdays and Fridays. -Hyphen ( - ) ------------- +### Hyphen ( - ) Hyphens define ranges. For example, 2000-2010 indicates every year between 2000 and 2010 AD, inclusive. -L -- +### L `L` stands for "last". When used in the day-of-week field, it allows you to specify constructs such as "the last Friday" (`5L`) of a given month. In the day-of-month field, it specifies the last day of the month. -W -- +### W The `W` character is allowed for the day-of-month field. This character is used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify `15W` as the value for the day-of-month field, the meaning is: "the nearest weekday to the 15th of the month." So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th is a Sunday, the trigger fires on Monday the 16th. If the 15th is a Tuesday, then it fires on Tuesday the 15th. However if you specify `1W` as the value for day-of-month, and the 1st is a Saturday, the trigger fires on Monday the 3rd, as it does not 'jump' over the boundary of a month's days. The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. -Hash ( # ) ----------- +### Hash ( # ) `#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. Predefined cron expressions @@ -103,3 +98,30 @@ will return `true`, whereas will return `false` (as of 2013-08-29...) +API +--- + +### func NextTime(cronLine string, fromTime time.Time) time.Time + +Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression string `cronLine`. + +### func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time + +Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression string `cronLine`. The time stamps in the returned slice are in chronological ascending order. + +### func NewCronExpression(cronLine string) *CronExpression + +Return a new `CronExpression` pointer which will interpret the cron expression string `cronLine`. + +### func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time + +Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression `cronexpr`. + +### func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time + +Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression `cronexpr`. The time stamps in the returned slice are in chronological ascending order. + +### func NoMatch(t time.Time) bool + +Returns `true` if time stamp `t` is not a valid time stamp from `CronExpression` point of view. An invalid time stamp is returned by this library whenever no matching time stamp is found given a specific cron expression. + From 4a7dc735f4e7c08131ddc4185c7a22cefac576ac Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 09:02:49 -0400 Subject: [PATCH 043/105] prettier? --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index decb302..238e481 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ The time-matching algorithm in this implementation is efficient, it avoids as mu Implementation -------------- The reference documentation for this implementation is found at -https://en.wikipedia.org/wiki/Cron#CRON_expression, which I copy/pasted here (laziness!) with modifications where this implementation differs: +, which I copy/pasted here (laziness!) with modifications where this implementation differs: Field name Mandatory? Allowed values Allowed special characters ---------- ---------- -------------- -------------------------- @@ -46,7 +46,7 @@ The `W` character is allowed for the day-of-month field. This character is used Predefined cron expressions --------------------------- -(Copied from https://en.wikipedia.org/wiki/Cron#Predefined_scheduling_definitions, with text modified according to this implementation) +(Copied from , with text modified according to this implementation) Entry Description Equivalent to @annually Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * @@ -101,27 +101,27 @@ will return `false` (as of 2013-08-29...) API --- -### func NextTime(cronLine string, fromTime time.Time) time.Time +#### func NextTime(cronLine string, fromTime time.Time) time.Time Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression string `cronLine`. -### func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time +#### func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression string `cronLine`. The time stamps in the returned slice are in chronological ascending order. -### func NewCronExpression(cronLine string) *CronExpression +#### func NewCronExpression(cronLine string) *CronExpression Return a new `CronExpression` pointer which will interpret the cron expression string `cronLine`. -### func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time +#### func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression `cronexpr`. -### func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time +#### func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression `cronexpr`. The time stamps in the returned slice are in chronological ascending order. -### func NoMatch(t time.Time) bool +#### func NoMatch(t time.Time) bool Returns `true` if time stamp `t` is not a valid time stamp from `CronExpression` point of view. An invalid time stamp is returned by this library whenever no matching time stamp is found given a specific cron expression. From ce6e92ee9fbf6ec7089d2a04eaaff076b8dbfa2e Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 09:03:42 -0400 Subject: [PATCH 044/105] fine tuning --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 238e481..6ed5b86 100644 --- a/README.md +++ b/README.md @@ -23,25 +23,25 @@ The reference documentation for this implementation is found at Day of week Yes 0-6 or SUN-SAT * / , - L # Year No 1970–2099 * / , - -### Asterisk ( * ) +#### Asterisk ( * ) The asterisk indicates that the cron expression matches for all values of the field. E.g., using an asterisk in the 4th field (month) indicates every month. -### Slash ( / ) +#### Slash ( / ) Slashes describe increments of ranges. For example `3-59/15` in the minute field indicate the third minute of the hour and every 15 minutes thereafter. The form `*/...` is equivalent to the form "first-last/...", that is, an increment over the largest possible range of the field. -### Comma ( , ) +#### Comma ( , ) Commas are used to separate items of a list. For example, using `MON,WED,FRI` in the 5th field (day of week) means Mondays, Wednesdays and Fridays. -### Hyphen ( - ) +#### Hyphen ( - ) Hyphens define ranges. For example, 2000-2010 indicates every year between 2000 and 2010 AD, inclusive. -### L +#### L `L` stands for "last". When used in the day-of-week field, it allows you to specify constructs such as "the last Friday" (`5L`) of a given month. In the day-of-month field, it specifies the last day of the month. -### W +#### W The `W` character is allowed for the day-of-month field. This character is used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify `15W` as the value for the day-of-month field, the meaning is: "the nearest weekday to the 15th of the month." So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th is a Sunday, the trigger fires on Monday the 16th. If the 15th is a Tuesday, then it fires on Tuesday the 15th. However if you specify `1W` as the value for day-of-month, and the 1st is a Saturday, the trigger fires on Monday the 3rd, as it does not 'jump' over the boundary of a month's days. The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. -### Hash ( # ) +#### Hash ( # ) `#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. Predefined cron expressions From 1b7b1a8d9bffb64784c0ac5cfd351aab43751f45 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 09:14:25 -0400 Subject: [PATCH 045/105] fleshing out --- README.md | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 6ed5b86..d4e7562 100644 --- a/README.md +++ b/README.md @@ -2,9 +2,9 @@ cronexpression for Go ===================== Cron expression parser in Go language (golang). -Given a cron expression and a time stamp, you can get the next time stamp which satisfy the cron expression. +Given a cron expression and a time stamp, you can get the next time stamp which satisfies the cron expression. -In another project, I decided to use Cron syntax to encode scheduling information. Thus this standalone library to parse and apply time stamps to cron expressions. +In another project, I decided to use cron expression syntax to encode scheduling information. Thus this standalone library to parse and apply time stamps to cron expressions. The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. @@ -109,6 +109,18 @@ Given a time stamp `fromTime`, return the closest following time stamp which mat Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression string `cronLine`. The time stamps in the returned slice are in chronological ascending order. +Example: + + cronexpression.NextTimeN("0 0 0 29 2 ? *", time.Now(), 5) + +will result in the following time stamps being returned (as of 2013-08-30): + + 2016-02-29 00:00:00 + 2020-02-29 00:00:00 + 2024-02-29 00:00:00 + 2028-02-29 00:00:00 + 2032-02-29 00:00:00 + #### func NewCronExpression(cronLine string) *CronExpression Return a new `CronExpression` pointer which will interpret the cron expression string `cronLine`. From 80d5bd7cc8191321ab25db31f76ef44b3c4642bc Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 09:17:21 -0400 Subject: [PATCH 046/105] fleshing out --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index d4e7562..d2e03aa 100644 --- a/README.md +++ b/README.md @@ -103,11 +103,11 @@ API #### func NextTime(cronLine string, fromTime time.Time) time.Time -Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression string `cronLine`. +Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression string `cronLine`. The `time.Location` of the returned time stamp is the same as `fromTime`. #### func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time -Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression string `cronLine`. The time stamps in the returned slice are in chronological ascending order. +Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression string `cronLine`. The time stamps in the returned slice are in chronological ascending order. The `time.Location` of the returned time stamps is the same as `fromTime`. Example: @@ -127,11 +127,11 @@ Return a new `CronExpression` pointer which will interpret the cron expression s #### func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time -Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression `cronexpr`. +Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression `cronexpr`. The `time.Location` of the returned time stamp is the same as `fromTime`. #### func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time -Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression `cronexpr`. The time stamps in the returned slice are in chronological ascending order. +Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression `cronexpr`. The time stamps in the returned slice are in chronological ascending order. The `time.Location` of the returned time stamps is the same as `fromTime`. #### func NoMatch(t time.Time) bool From a62fefeb17d624b600bd0b59ab804cb636067970 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 09:44:11 -0400 Subject: [PATCH 047/105] use go doc style --- README.md | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index d2e03aa..876f183 100644 --- a/README.md +++ b/README.md @@ -101,11 +101,15 @@ will return `false` (as of 2013-08-29...) API --- -#### func NextTime(cronLine string, fromTime time.Time) time.Time +#### func NextTime + + func NextTime(cronLine string, fromTime time.Time) time.Time Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression string `cronLine`. The `time.Location` of the returned time stamp is the same as `fromTime`. -#### func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time +#### func NextTimeN + + func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression string `cronLine`. The time stamps in the returned slice are in chronological ascending order. The `time.Location` of the returned time stamps is the same as `fromTime`. @@ -121,19 +125,27 @@ will result in the following time stamps being returned (as of 2013-08-30): 2028-02-29 00:00:00 2032-02-29 00:00:00 -#### func NewCronExpression(cronLine string) *CronExpression +#### func NewCronExpression + + func NewCronExpression(cronLine string) *CronExpression Return a new `CronExpression` pointer which will interpret the cron expression string `cronLine`. -#### func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time +#### func (*CronExpression) NextTime + + func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression `cronexpr`. The `time.Location` of the returned time stamp is the same as `fromTime`. -#### func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time +#### func (*CronExpression) NextTimeN + + func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression `cronexpr`. The time stamps in the returned slice are in chronological ascending order. The `time.Location` of the returned time stamps is the same as `fromTime`. -#### func NoMatch(t time.Time) bool +#### func NoMatch + + func NoMatch(t time.Time) bool Returns `true` if time stamp `t` is not a valid time stamp from `CronExpression` point of view. An invalid time stamp is returned by this library whenever no matching time stamp is found given a specific cron expression. From 3b9b5eb646755228b1e55c7ee80667048bfde07f Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 10:10:02 -0400 Subject: [PATCH 048/105] fixed time layout --- cronexpression_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cronexpression_test.go b/cronexpression_test.go index 451b09b..e3da33e 100644 --- a/cronexpression_test.go +++ b/cronexpression_test.go @@ -98,11 +98,11 @@ var crontests = []crontest{ // Days of week { "0 0 * * MON", - "MON 2006-01-02 15:04", + "Mon 2006-01-02 15:04", []crontimes{ - {"2013-01-01 00:00:00", "MON 2013-01-07 00:00"}, - {"2013-01-28 00:00:00", "MON 2013-02-04 00:00"}, - {"2013-12-30 00:30:00", "MON 2014-01-06 00:00"}, + {"2013-01-01 00:00:00", "Mon 2013-01-07 00:00"}, + {"2013-01-28 00:00:00", "Mon 2013-02-04 00:00"}, + {"2013-12-30 00:30:00", "Mon 2014-01-06 00:00"}, }, }, From 59e169474660f9dcc8e2cae0b066ba2fa0d5a053 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 10:57:51 -0400 Subject: [PATCH 049/105] better example --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 876f183..db7e9ac 100644 --- a/README.md +++ b/README.md @@ -60,7 +60,7 @@ Predefined cron expressions Other details ------------- * If only six fields are present, a `0` second field is prepended, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. -* If only five fields are present, a `0` second field is prepended and a wildcard year field is appended, that is, `* * * * *` internally become `0 * * * * * *`. +* If only five fields are present, a `0` second field is prepended and a wildcard year field is appended, that is, `* * * * Mon` internally become `0 * * * * Mon *`. * Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). This to comply with http://linux.die.net/man/5/crontab#. * As of now, the behavior of the code is undetermined if a malformed cron expression is supplied From bca585d9243677d5815a28cff1801f4892596cd8 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 11:09:36 -0400 Subject: [PATCH 050/105] ah yes, forgot to use go fmt --- cronexpression.go | 1094 ++++++++++++++++++++-------------------- cronexpression_test.go | 164 +++--- 2 files changed, 629 insertions(+), 629 deletions(-) diff --git a/cronexpression.go b/cronexpression.go index 4b1e012..8c14c56 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -13,11 +13,11 @@ package cronexpression /******************************************************************************/ import ( - "regexp" - "sort" - "strconv" - "strings" - "time" + "regexp" + "sort" + "strconv" + "strings" + "time" ) /******************************************************************************/ @@ -26,21 +26,21 @@ import ( // Wikipedia: https://en.wikipedia.org/wiki/Cron#CRON_expression // type CronExpression struct { - Expression string - secondList []int - minuteList []int - hourList []int - daysOfMonth map[int]bool - workdaysOfMonth map[int]bool - lastDayOfMonth bool - daysOfMonthRestricted bool - actualDaysOfMonthList []int - monthList []int - daysOfWeek map[int]bool - specificWeekDaysOfWeek map[int]bool - lastWeekDaysOfWeek map[int]bool - daysOfWeekRestricted bool - yearList []int + Expression string + secondList []int + minuteList []int + hourList []int + daysOfMonth map[int]bool + workdaysOfMonth map[int]bool + lastDayOfMonth bool + daysOfMonthRestricted bool + actualDaysOfMonthList []int + monthList []int + daysOfWeek map[int]bool + specificWeekDaysOfWeek map[int]bool + lastWeekDaysOfWeek map[int]bool + daysOfWeekRestricted bool + yearList []int } /******************************************************************************/ @@ -53,49 +53,49 @@ var noMatchTime = time.Date(2100, 7, 1, 0, 0, 0, 0, time.UTC) // a well-formed cron expression. If a malformed cron expression is // supplied, the result is undefined. func NewCronExpression(cronLine string) *CronExpression { - cronLineNormalized := cronNormalize(cronLine) + cronLineNormalized := cronNormalize(cronLine) - // Split into fields - cronFields := regexp.MustCompile(`\s+`).Split(cronLineNormalized, -1) + // Split into fields + cronFields := regexp.MustCompile(`\s+`).Split(cronLineNormalized, -1) - // Our cron expression parser expects 7 fields: - // second minute hour dayofmonth month dayofweek year - // Standard cron is 6 fields with year field being optional - // minute hour dayofmonth month dayofweek {year} - // Thus... - // If we have 5 fields, append wildcard year field - if len(cronFields) < 6 { - cronFields = append(cronFields, "*") - } - // If we have 6 fields, prepend match-once second field - if len(cronFields) < 7 { - cronFields = append(cronFields, "") - copy(cronFields[1:], cronFields[0:]) - cronFields[0] = "0" - } - // We should have 7 fields at this point - if len(cronFields) != 7 { - panic("Malformed cron expression\n") - } + // Our cron expression parser expects 7 fields: + // second minute hour dayofmonth month dayofweek year + // Standard cron is 6 fields with year field being optional + // minute hour dayofmonth month dayofweek {year} + // Thus... + // If we have 5 fields, append wildcard year field + if len(cronFields) < 6 { + cronFields = append(cronFields, "*") + } + // If we have 6 fields, prepend match-once second field + if len(cronFields) < 7 { + cronFields = append(cronFields, "") + copy(cronFields[1:], cronFields[0:]) + cronFields[0] = "0" + } + // We should have 7 fields at this point + if len(cronFields) != 7 { + panic("Malformed cron expression\n") + } - // Generic parser can be used for most fields - cronExpr := &CronExpression{ - Expression: cronLine, - secondList: genericFieldParse(cronFields[0], 0, 59), - minuteList: genericFieldParse(cronFields[1], 0, 59), - hourList: genericFieldParse(cronFields[2], 0, 23), - monthList: genericFieldParse(cronFields[4], 1, 12), - yearList: genericFieldParse(cronFields[6], 1970, 2099), - } + // Generic parser can be used for most fields + cronExpr := &CronExpression{ + Expression: cronLine, + secondList: genericFieldParse(cronFields[0], 0, 59), + minuteList: genericFieldParse(cronFields[1], 0, 59), + hourList: genericFieldParse(cronFields[2], 0, 23), + monthList: genericFieldParse(cronFields[4], 1, 12), + yearList: genericFieldParse(cronFields[6], 1970, 2099), + } - // Days of month/days of week is a bit more complicated, due - // to their extended syntax, and the fact that days per - // month is a variable quantity, and relation between - // days of week and days of month depends on the month/year. - cronExpr.dayofmonthFieldParse(cronFields[3]) - cronExpr.dayofweekFieldParse(cronFields[5]) + // Days of month/days of week is a bit more complicated, due + // to their extended syntax, and the fact that days per + // month is a variable quantity, and relation between + // days of week and days of month depends on the month/year. + cronExpr.dayofmonthFieldParse(cronFields[3]) + cronExpr.dayofweekFieldParse(cronFields[5]) - return cronExpr + return cronExpr } /******************************************************************************/ @@ -107,8 +107,8 @@ func NewCronExpression(cronLine string) *CronExpression { // If the same cron expression must be used repeatedly, it is better to use // NewCronExpression() in order to avoid overhead of cron expression parsing. func NextTime(cronLine string, fromTime time.Time) time.Time { - cronexpr := NewCronExpression(cronLine) - return cronexpr.NextTime(fromTime) + cronexpr := NewCronExpression(cronLine) + return cronexpr.NextTime(fromTime) } /******************************************************************************/ @@ -120,8 +120,8 @@ func NextTime(cronLine string, fromTime time.Time) time.Time { // If the same cron expression must be used repeatedly, it is better to use // NewCronExpression() in order to avoid overhead of cron expression parsing. func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time { - cronexpr := NewCronExpression(cronLine) - return cronexpr.NextTimeN(fromTime, n) + cronexpr := NewCronExpression(cronLine) + return cronexpr.NextTimeN(fromTime, n) } /******************************************************************************/ @@ -130,83 +130,83 @@ func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time { // satisfies the cron expression. If no matching time stamp is found, // using NoMatch() with the returned time stamp as argument will return true. func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { - // Special case - if NoMatch(fromTime) { - return fromTime - } + // Special case + if NoMatch(fromTime) { + return fromTime + } - // Since cronexpr.nextSecond()-cronexpr.nextMonth() expects that the - // supplied time stamp is a perfect match to the underlying cron - // expression, and since this function is an entry point where `fromTime` - // does not necessarily matches the underlying cron expression, - // we first need to ensure supplied time stamp matches - // the cron expression. If not, this means the supplied time - // stamp falls in between matching time stamps, thus we move - // to closest future matching time stamp without changing time - // stamp + // Since cronexpr.nextSecond()-cronexpr.nextMonth() expects that the + // supplied time stamp is a perfect match to the underlying cron + // expression, and since this function is an entry point where `fromTime` + // does not necessarily matches the underlying cron expression, + // we first need to ensure supplied time stamp matches + // the cron expression. If not, this means the supplied time + // stamp falls in between matching time stamps, thus we move + // to closest future matching immediately upon encountering a mismatching + // time stamp. - // year - v := fromTime.Year() - i := sort.SearchInts(cronexpr.yearList, v) - if i == len(cronexpr.yearList) { - return noMatchTime - } - if v != cronexpr.yearList[i] { - return cronexpr.nextYear(fromTime) - } - // month - v = int(fromTime.Month()) - i = sort.SearchInts(cronexpr.monthList, v) - if i == len(cronexpr.monthList) { - return cronexpr.nextYear(fromTime) - } - if v != cronexpr.monthList[i] { - return cronexpr.nextMonth(fromTime) - } + // year + v := fromTime.Year() + i := sort.SearchInts(cronexpr.yearList, v) + if i == len(cronexpr.yearList) { + return noMatchTime + } + if v != cronexpr.yearList[i] { + return cronexpr.nextYear(fromTime) + } + // month + v = int(fromTime.Month()) + i = sort.SearchInts(cronexpr.monthList, v) + if i == len(cronexpr.monthList) { + return cronexpr.nextYear(fromTime) + } + if v != cronexpr.monthList[i] { + return cronexpr.nextMonth(fromTime) + } - cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(fromTime.Year(), int(fromTime.Month())) - if len(cronexpr.actualDaysOfMonthList) == 0 { - return cronexpr.nextMonth(fromTime) - } + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(fromTime.Year(), int(fromTime.Month())) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(fromTime) + } - // day of month - v = fromTime.Day() - i = sort.SearchInts(cronexpr.actualDaysOfMonthList, v) - if i == len(cronexpr.actualDaysOfMonthList) { - return cronexpr.nextMonth(fromTime) - } - if v != cronexpr.actualDaysOfMonthList[i] { - return cronexpr.nextDayOfMonth(fromTime) - } - // hour - v = fromTime.Hour() - i = sort.SearchInts(cronexpr.hourList, v) - if i == len(cronexpr.hourList) { - return cronexpr.nextDayOfMonth(fromTime) - } - if v != cronexpr.hourList[i] { - return cronexpr.nextHour(fromTime) - } - // minute - v = fromTime.Minute() - i = sort.SearchInts(cronexpr.minuteList, v) - if i == len(cronexpr.minuteList) { - return cronexpr.nextHour(fromTime) - } - if v != cronexpr.minuteList[i] { - return cronexpr.nextMinute(fromTime) - } - // second - v = fromTime.Second() - i = sort.SearchInts(cronexpr.secondList, v) - if i == len(cronexpr.secondList) { - return cronexpr.nextMinute(fromTime) - } + // day of month + v = fromTime.Day() + i = sort.SearchInts(cronexpr.actualDaysOfMonthList, v) + if i == len(cronexpr.actualDaysOfMonthList) { + return cronexpr.nextMonth(fromTime) + } + if v != cronexpr.actualDaysOfMonthList[i] { + return cronexpr.nextDayOfMonth(fromTime) + } + // hour + v = fromTime.Hour() + i = sort.SearchInts(cronexpr.hourList, v) + if i == len(cronexpr.hourList) { + return cronexpr.nextDayOfMonth(fromTime) + } + if v != cronexpr.hourList[i] { + return cronexpr.nextHour(fromTime) + } + // minute + v = fromTime.Minute() + i = sort.SearchInts(cronexpr.minuteList, v) + if i == len(cronexpr.minuteList) { + return cronexpr.nextHour(fromTime) + } + if v != cronexpr.minuteList[i] { + return cronexpr.nextMinute(fromTime) + } + // second + v = fromTime.Second() + i = sort.SearchInts(cronexpr.secondList, v) + if i == len(cronexpr.secondList) { + return cronexpr.nextMinute(fromTime) + } - // If we reach this point, there is nothing better to do - // than to move to the next second + // If we reach this point, there is nothing better to do + // than to move to the next second - return cronexpr.nextSecond(fromTime) + return cronexpr.nextSecond(fromTime) } /******************************************************************************/ @@ -215,23 +215,23 @@ func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { // fromTime which satisfy the cron expression. An empty list is returned if // there is no matching time stamp. func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time { - if n <= 0 { - panic("CronExpression.NextTimeN(): invalid count") - } - nextTimes := make([]time.Time, 0) - fromTime = cronexpr.NextTime(fromTime) - for { - if NoMatch(fromTime) { - break - } - nextTimes = append(nextTimes, fromTime) - n -= 1 - if n == 0 { - break - } - fromTime = cronexpr.nextSecond(fromTime) - } - return nextTimes + if n <= 0 { + panic("CronExpression.NextTimeN(): invalid count") + } + nextTimes := make([]time.Time, 0) + fromTime = cronexpr.NextTime(fromTime) + for { + if NoMatch(fromTime) { + break + } + nextTimes = append(nextTimes, fromTime) + n -= 1 + if n == 0 { + break + } + fromTime = cronexpr.nextSecond(fromTime) + } + return nextTimes } /******************************************************************************/ @@ -239,449 +239,449 @@ func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time // NoMatch() returns whether t is a valid time stamp, from CronExpression point // of view. func NoMatch(t time.Time) bool { - // https://en.wikipedia.org/wiki/Cron#CRON_expression: 1970–2099 - return t.Year() >= 2100 + // https://en.wikipedia.org/wiki/Cron#CRON_expression: 1970–2099 + return t.Year() >= 2100 } /******************************************************************************/ func (cronexpr *CronExpression) nextYear(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate year - i := sort.SearchInts(cronexpr.yearList, t.Year()+1) - if i == len(cronexpr.yearList) { - return noMatchTime - } - // Year changed, need to recalculate actual days of month - cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(cronexpr.yearList[i], cronexpr.monthList[0]) - if len(cronexpr.actualDaysOfMonthList) == 0 { - return cronexpr.nextMonth(time.Date( - cronexpr.yearList[i], - time.Month(cronexpr.monthList[0]), - 1, - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], - 0, - time.Local)) - } - return time.Date( - cronexpr.yearList[i], - time.Month(cronexpr.monthList[0]), - cronexpr.actualDaysOfMonthList[0], - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], - 0, - time.Local) + // Find index at which item in list is greater or equal to + // candidate year + i := sort.SearchInts(cronexpr.yearList, t.Year()+1) + if i == len(cronexpr.yearList) { + return noMatchTime + } + // Year changed, need to recalculate actual days of month + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(cronexpr.yearList[i], cronexpr.monthList[0]) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(time.Date( + cronexpr.yearList[i], + time.Month(cronexpr.monthList[0]), + 1, + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local)) + } + return time.Date( + cronexpr.yearList[i], + time.Month(cronexpr.monthList[0]), + cronexpr.actualDaysOfMonthList[0], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local) } /******************************************************************************/ func (cronexpr *CronExpression) nextMonth(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate month - i := sort.SearchInts(cronexpr.monthList, int(t.Month())+1) - if i == len(cronexpr.monthList) { - return cronexpr.nextYear(t) - } - // Month changed, need to recalculate actual days of month - cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(t.Year(), cronexpr.monthList[i]) - if len(cronexpr.actualDaysOfMonthList) == 0 { - return cronexpr.nextMonth(time.Date( - t.Year(), - time.Month(cronexpr.monthList[i]), - 1, - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], - 0, - time.Local)) - } + // Find index at which item in list is greater or equal to + // candidate month + i := sort.SearchInts(cronexpr.monthList, int(t.Month())+1) + if i == len(cronexpr.monthList) { + return cronexpr.nextYear(t) + } + // Month changed, need to recalculate actual days of month + cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(t.Year(), cronexpr.monthList[i]) + if len(cronexpr.actualDaysOfMonthList) == 0 { + return cronexpr.nextMonth(time.Date( + t.Year(), + time.Month(cronexpr.monthList[i]), + 1, + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local)) + } - return time.Date( - t.Year(), - time.Month(cronexpr.monthList[i]), - cronexpr.actualDaysOfMonthList[0], - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], - 0, - time.Local) + return time.Date( + t.Year(), + time.Month(cronexpr.monthList[i]), + cronexpr.actualDaysOfMonthList[0], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + time.Local) } /******************************************************************************/ func (cronexpr *CronExpression) calculateActualDaysOfMonth(year, month int) []int { - actualDaysOfMonthMap := make(map[int]bool) - timeOrigin := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) - lastDayOfMonth := timeOrigin.AddDate(0, 1, -1).Day() + actualDaysOfMonthMap := make(map[int]bool) + timeOrigin := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) + lastDayOfMonth := timeOrigin.AddDate(0, 1, -1).Day() - // As per crontab man page (http://linux.die.net/man/5/crontab#): - // "The day of a command's execution can be specified by two - // "fields - day of month, and day of week. If both fields are - // "restricted (ie, aren't *), the command will be run when - // "either field matches the current time" - if cronexpr.daysOfMonthRestricted || cronexpr.daysOfWeekRestricted == false { - // Last day of month - if cronexpr.lastDayOfMonth { - actualDaysOfMonthMap[lastDayOfMonth] = true - } - // Days of month - for v, _ := range cronexpr.daysOfMonth { - // Ignore days beyond end of month - if v <= lastDayOfMonth { - actualDaysOfMonthMap[v] = true - } - } - // Work days of month - // As per Wikipedia: month boundaries are not crossed. - for v, _ := range cronexpr.workdaysOfMonth { - // Ignore days beyond end of month - if v <= lastDayOfMonth { - // If saturday, then friday - if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Saturday { - if v > 1 { - v -= 1 - } else { - v += 2 - } - // If sunday, then monday - } else if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Sunday { - if v < lastDayOfMonth { - v += 1 - } else { - v -= 2 - } - } - actualDaysOfMonthMap[v] = true - } - } - } + // As per crontab man page (http://linux.die.net/man/5/crontab#): + // "The day of a command's execution can be specified by two + // "fields - day of month, and day of week. If both fields are + // "restricted (ie, aren't *), the command will be run when + // "either field matches the current time" + if cronexpr.daysOfMonthRestricted || cronexpr.daysOfWeekRestricted == false { + // Last day of month + if cronexpr.lastDayOfMonth { + actualDaysOfMonthMap[lastDayOfMonth] = true + } + // Days of month + for v, _ := range cronexpr.daysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + // Work days of month + // As per Wikipedia: month boundaries are not crossed. + for v, _ := range cronexpr.workdaysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth { + // If saturday, then friday + if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Saturday { + if v > 1 { + v -= 1 + } else { + v += 2 + } + // If sunday, then monday + } else if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Sunday { + if v < lastDayOfMonth { + v += 1 + } else { + v -= 2 + } + } + actualDaysOfMonthMap[v] = true + } + } + } - if cronexpr.daysOfWeekRestricted { - // How far first sunday is from first day of month - offset := 7 - int(timeOrigin.Weekday()) - // days of week - // offset : (7 - day_of_week_of_1st_day_of_month) - // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for w := 0; w <= 4; w += 1 { - for v, _ := range cronexpr.daysOfWeek { - v := 1 + w*7 + (offset+v)%7 - if v <= lastDayOfMonth { - actualDaysOfMonthMap[v] = true - } - } - } - // days of week of specific week in the month - // offset : (7 - day_of_week_of_1st_day_of_month) - // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for v, _ := range cronexpr.specificWeekDaysOfWeek { - v := 1 + 7*(v/7) + (offset+v)%7 - if v <= lastDayOfMonth { - actualDaysOfMonthMap[v] = true - } - } - // Last days of week of the month - lastWeekOrigin := timeOrigin.AddDate(0, 1, -7) - offset = 7 - int(lastWeekOrigin.Weekday()) - for v, _ := range cronexpr.lastWeekDaysOfWeek { - v := lastWeekOrigin.Day() + (offset+v)%7 - if v <= lastDayOfMonth { - actualDaysOfMonthMap[v] = true - } - } - } + if cronexpr.daysOfWeekRestricted { + // How far first sunday is from first day of month + offset := 7 - int(timeOrigin.Weekday()) + // days of week + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 + for w := 0; w <= 4; w += 1 { + for v, _ := range cronexpr.daysOfWeek { + v := 1 + w*7 + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + } + // days of week of specific week in the month + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 + for v, _ := range cronexpr.specificWeekDaysOfWeek { + v := 1 + 7*(v/7) + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + // Last days of week of the month + lastWeekOrigin := timeOrigin.AddDate(0, 1, -7) + offset = 7 - int(lastWeekOrigin.Weekday()) + for v, _ := range cronexpr.lastWeekDaysOfWeek { + v := lastWeekOrigin.Day() + (offset+v)%7 + if v <= lastDayOfMonth { + actualDaysOfMonthMap[v] = true + } + } + } - return toList(actualDaysOfMonthMap) + return toList(actualDaysOfMonthMap) } /******************************************************************************/ func (cronexpr *CronExpression) nextDayOfMonth(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate day of month - i := sort.SearchInts(cronexpr.actualDaysOfMonthList, t.Day()+1) - if i == len(cronexpr.actualDaysOfMonthList) { - return cronexpr.nextMonth(t) - } + // Find index at which item in list is greater or equal to + // candidate day of month + i := sort.SearchInts(cronexpr.actualDaysOfMonthList, t.Day()+1) + if i == len(cronexpr.actualDaysOfMonthList) { + return cronexpr.nextMonth(t) + } - return time.Date( - t.Year(), - t.Month(), - cronexpr.actualDaysOfMonthList[i], - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], - 0, - t.Location()) + return time.Date( + t.Year(), + t.Month(), + cronexpr.actualDaysOfMonthList[i], + cronexpr.hourList[0], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + t.Location()) } /******************************************************************************/ func (cronexpr *CronExpression) nextHour(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate hour - i := sort.SearchInts(cronexpr.hourList, t.Hour()+1) - if i == len(cronexpr.hourList) { - return cronexpr.nextDayOfMonth(t) - } + // Find index at which item in list is greater or equal to + // candidate hour + i := sort.SearchInts(cronexpr.hourList, t.Hour()+1) + if i == len(cronexpr.hourList) { + return cronexpr.nextDayOfMonth(t) + } - return time.Date( - t.Year(), - t.Month(), - t.Day(), - cronexpr.hourList[i], - cronexpr.minuteList[0], - cronexpr.secondList[0], - 0, - t.Location()) + return time.Date( + t.Year(), + t.Month(), + t.Day(), + cronexpr.hourList[i], + cronexpr.minuteList[0], + cronexpr.secondList[0], + 0, + t.Location()) } /******************************************************************************/ func (cronexpr *CronExpression) nextMinute(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate minute - i := sort.SearchInts(cronexpr.minuteList, t.Minute()+1) - if i == len(cronexpr.minuteList) { - return cronexpr.nextHour(t) - } + // Find index at which item in list is greater or equal to + // candidate minute + i := sort.SearchInts(cronexpr.minuteList, t.Minute()+1) + if i == len(cronexpr.minuteList) { + return cronexpr.nextHour(t) + } - return time.Date( - t.Year(), - t.Month(), - t.Day(), - t.Hour(), - cronexpr.minuteList[i], - cronexpr.secondList[0], - 0, - t.Location()) + return time.Date( + t.Year(), + t.Month(), + t.Day(), + t.Hour(), + cronexpr.minuteList[i], + cronexpr.secondList[0], + 0, + t.Location()) } /******************************************************************************/ func (cronexpr *CronExpression) nextSecond(t time.Time) time.Time { - // nextSecond() assumes all other fields are exactly matched - // to the cron expression + // nextSecond() assumes all other fields are exactly matched + // to the cron expression - // Find index at which item in list is greater or equal to - // candidate second - i := sort.SearchInts(cronexpr.secondList, t.Second()+1) - if i == len(cronexpr.secondList) { - return cronexpr.nextMinute(t) - } + // Find index at which item in list is greater or equal to + // candidate second + i := sort.SearchInts(cronexpr.secondList, t.Second()+1) + if i == len(cronexpr.secondList) { + return cronexpr.nextMinute(t) + } - return time.Date( - t.Year(), - t.Month(), - t.Day(), - t.Hour(), - t.Minute(), - cronexpr.secondList[i], - 0, - t.Location()) + return time.Date( + t.Year(), + t.Month(), + t.Day(), + t.Hour(), + t.Minute(), + cronexpr.secondList[i], + 0, + t.Location()) } /******************************************************************************/ var cronNormalizer = strings.NewReplacer( - // Order is important! - "@yearly", "0 0 0 1 1 * *", - "@annually", "0 0 0 1 1 * *", - "@monthly", "0 0 0 1 * * *", - "@weekly", "0 0 0 * * 0 *", - "@daily", "0 0 0 * * * *", - "@hourly", "0 0 * * * * *", - "january", "1", - "february", "2", - "march", "3", - "april", "4", - "may", "5", - "june", "6", - "july", "7", - "august", "8", - "september", "9", - "october", "0", - "november", "1", - "december", "2", - "sunday", "0", - "monday", "1", - "tuesday", "2", - "wednesday", "3", - "thursday", "4", - "friday", "5", - "saturday", "6", - "jan", "1", - "feb", "2", - "mar", "3", - "apr", "4", - "jun", "6", - "jul", "7", - "aug", "8", - "sep", "9", - "oct", "10", - "nov", "11", - "dec", "12", - "sun", "0", - "mon", "1", - "tue", "2", - "wed", "3", - "thu", "4", - "fri", "5", - "sat", "6", - "?", "*") + // Order is important! + "@yearly", "0 0 0 1 1 * *", + "@annually", "0 0 0 1 1 * *", + "@monthly", "0 0 0 1 * * *", + "@weekly", "0 0 0 * * 0 *", + "@daily", "0 0 0 * * * *", + "@hourly", "0 0 * * * * *", + "january", "1", + "february", "2", + "march", "3", + "april", "4", + "may", "5", + "june", "6", + "july", "7", + "august", "8", + "september", "9", + "october", "0", + "november", "1", + "december", "2", + "sunday", "0", + "monday", "1", + "tuesday", "2", + "wednesday", "3", + "thursday", "4", + "friday", "5", + "saturday", "6", + "jan", "1", + "feb", "2", + "mar", "3", + "apr", "4", + "jun", "6", + "jul", "7", + "aug", "8", + "sep", "9", + "oct", "10", + "nov", "11", + "dec", "12", + "sun", "0", + "mon", "1", + "tue", "2", + "wed", "3", + "thu", "4", + "fri", "5", + "sat", "6", + "?", "*") func cronNormalize(cronLine string) string { - cronLine = strings.TrimSpace(cronLine) - cronLine = strings.ToLower(cronLine) - cronLine = cronNormalizer.Replace(cronLine) - return cronLine + cronLine = strings.TrimSpace(cronLine) + cronLine = strings.ToLower(cronLine) + cronLine = cronNormalizer.Replace(cronLine) + return cronLine } /******************************************************************************/ func (cronexpr *CronExpression) dayofweekFieldParse(cronField string) error { - // Defaults - cronexpr.daysOfWeekRestricted = true - cronexpr.lastWeekDaysOfWeek = make(map[int]bool) - cronexpr.daysOfWeek = make(map[int]bool) + // Defaults + cronexpr.daysOfWeekRestricted = true + cronexpr.lastWeekDaysOfWeek = make(map[int]bool) + cronexpr.daysOfWeek = make(map[int]bool) - // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" - cronList := strings.Split(cronField, ",") - for _, s := range cronList { - // "/" - step, s := extractInterval(s) - // "*" - if s == "*" { - cronexpr.daysOfWeekRestricted = (step > 1) - populateMany(cronexpr.daysOfWeek, 0, 6, step) - continue - } - // "-" - // week day interval for all weeks - i := strings.Index(s, "-") - if i >= 0 { - min := atoi(s[:i]) % 7 - max := atoi(s[i+1:]) % 7 - populateMany(cronexpr.daysOfWeek, min, max, step) - continue - } - // single value - // "l": week day for last week - i = strings.Index(s, "l") - if i >= 0 { - populateOne(cronexpr.lastWeekDaysOfWeek, atoi(s[:i])%7) - continue - } - // "#": week day for specific week - i = strings.Index(s, "#") - if i >= 0 { - // v#w - v := atoi(s[:i]) % 7 - w := atoi(s[i+1:]) - // v domain = [0,7] - // w domain = [1,5] - populateOne(cronexpr.specificWeekDaysOfWeek, (w-1)*7+(v%7)) - continue - } - // week day interval for all weeks - if step > 0 { - v := atoi(s) % 7 - populateMany(cronexpr.daysOfWeek, v, 6, step) - continue - } - // single week day for all weeks - v := atoi(s) % 7 - populateOne(cronexpr.daysOfWeek, v) - } + // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + cronexpr.daysOfWeekRestricted = (step > 1) + populateMany(cronexpr.daysOfWeek, 0, 6, step) + continue + } + // "-" + // week day interval for all weeks + i := strings.Index(s, "-") + if i >= 0 { + min := atoi(s[:i]) % 7 + max := atoi(s[i+1:]) % 7 + populateMany(cronexpr.daysOfWeek, min, max, step) + continue + } + // single value + // "l": week day for last week + i = strings.Index(s, "l") + if i >= 0 { + populateOne(cronexpr.lastWeekDaysOfWeek, atoi(s[:i])%7) + continue + } + // "#": week day for specific week + i = strings.Index(s, "#") + if i >= 0 { + // v#w + v := atoi(s[:i]) % 7 + w := atoi(s[i+1:]) + // v domain = [0,7] + // w domain = [1,5] + populateOne(cronexpr.specificWeekDaysOfWeek, (w-1)*7+(v%7)) + continue + } + // week day interval for all weeks + if step > 0 { + v := atoi(s) % 7 + populateMany(cronexpr.daysOfWeek, v, 6, step) + continue + } + // single week day for all weeks + v := atoi(s) % 7 + populateOne(cronexpr.daysOfWeek, v) + } - return nil + return nil } /******************************************************************************/ func (cronexpr *CronExpression) dayofmonthFieldParse(cronField string) error { - // Defaults - cronexpr.daysOfMonthRestricted = true - cronexpr.lastDayOfMonth = false + // Defaults + cronexpr.daysOfMonthRestricted = true + cronexpr.lastDayOfMonth = false - cronexpr.daysOfMonth = make(map[int]bool) // days of month map - cronexpr.workdaysOfMonth = make(map[int]bool) // work day of month map + cronexpr.daysOfMonth = make(map[int]bool) // days of month map + cronexpr.workdaysOfMonth = make(map[int]bool) // work day of month map - // Comma separator is used to mix different allowed syntax - cronList := strings.Split(cronField, ",") - for _, s := range cronList { - // "/" - step, s := extractInterval(s) - // "*" - if s == "*" { - cronexpr.daysOfMonthRestricted = (step > 1) - populateMany(cronexpr.daysOfMonth, 1, 31, step) - continue - } - // "-" - i := strings.Index(s, "-") - if i >= 0 { - populateMany(cronexpr.daysOfMonth, atoi(s[:i]), atoi(s[i+1:]), step) - continue - } - // single value - // "l": last day of month - if s == "l" { - cronexpr.lastDayOfMonth = true - continue - } - // "w": week day - i = strings.Index(s, "w") - if i >= 0 { - populateOne(cronexpr.workdaysOfMonth, atoi(s[:i])) - continue - } - // single value with interval - if step > 0 { - populateMany(cronexpr.daysOfMonth, atoi(s), 31, step) - continue - } - // single value - populateOne(cronexpr.daysOfMonth, atoi(s)) - } + // Comma separator is used to mix different allowed syntax + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + cronexpr.daysOfMonthRestricted = (step > 1) + populateMany(cronexpr.daysOfMonth, 1, 31, step) + continue + } + // "-" + i := strings.Index(s, "-") + if i >= 0 { + populateMany(cronexpr.daysOfMonth, atoi(s[:i]), atoi(s[i+1:]), step) + continue + } + // single value + // "l": last day of month + if s == "l" { + cronexpr.lastDayOfMonth = true + continue + } + // "w": week day + i = strings.Index(s, "w") + if i >= 0 { + populateOne(cronexpr.workdaysOfMonth, atoi(s[:i])) + continue + } + // single value with interval + if step > 0 { + populateMany(cronexpr.daysOfMonth, atoi(s), 31, step) + continue + } + // single value + populateOne(cronexpr.daysOfMonth, atoi(s)) + } - return nil + return nil } /******************************************************************************/ func genericFieldParse(cronField string, min, max int) []int { - // Defaults - values := make(map[int]bool) + // Defaults + values := make(map[int]bool) - // Comma separator is used to mix different allowed syntax - cronList := strings.Split(cronField, ",") - for _, s := range cronList { - // "/" - step, s := extractInterval(s) - // "*" - if s == "*" { - populateMany(values, min, max, step) - continue - } - // "-" - i := strings.Index(s, "-") - if i >= 0 { - populateMany(values, atoi(s[:i]), atoi(s[i+1:]), step) - continue - } - // single value with interval - if step > 0 { - populateMany(values, atoi(s), max, step) - continue - } - // single value - populateOne(values, atoi(s)) - } + // Comma separator is used to mix different allowed syntax + cronList := strings.Split(cronField, ",") + for _, s := range cronList { + // "/" + step, s := extractInterval(s) + // "*" + if s == "*" { + populateMany(values, min, max, step) + continue + } + // "-" + i := strings.Index(s, "-") + if i >= 0 { + populateMany(values, atoi(s[:i]), atoi(s[i+1:]), step) + continue + } + // single value with interval + if step > 0 { + populateMany(values, atoi(s), max, step) + continue + } + // single value + populateOne(values, atoi(s)) + } - return toList(values) + return toList(values) } /******************************************************************************/ @@ -689,43 +689,43 @@ func genericFieldParse(cronField string, min, max int) []int { // Local helpers func extractInterval(s string) (int, string) { - step := 0 - i := strings.Index(s, "/") - if i >= 0 { - step = atoi(s[i+1:]) - s = s[:i] - } - return step, s + step := 0 + i := strings.Index(s, "/") + if i >= 0 { + step = atoi(s[i+1:]) + s = s[:i] + } + return step, s } func atoi(s string) int { - v, err := strconv.Atoi(s) - if err != nil { - panic(err) - } - return v + v, err := strconv.Atoi(s) + if err != nil { + panic(err) + } + return v } func populateOne(values map[int]bool, v int) { - values[v] = true + values[v] = true } func populateMany(values map[int]bool, min, max, step int) { - if step == 0 { - step = 1 - } - for i := min; i <= max; i += step { - values[i] = true - } + if step == 0 { + step = 1 + } + for i := min; i <= max; i += step { + values[i] = true + } } func toList(set map[int]bool) []int { - list := make([]int, len(set)) - i := 0 - for k, _ := range set { - list[i] = k - i += 1 - } - sort.Ints(list) - return list + list := make([]int, len(set)) + i := 0 + for k, _ := range set { + list[i] = k + i += 1 + } + sort.Ints(list) + return list } diff --git a/cronexpression_test.go b/cronexpression_test.go index e3da33e..ad803db 100644 --- a/cronexpression_test.go +++ b/cronexpression_test.go @@ -21,103 +21,103 @@ import ( /******************************************************************************/ type crontimes struct { - from string - next string + from string + next string } type crontest struct { - expr string - layout string - times []crontimes + expr string + layout string + times []crontimes } var crontests = []crontest{ - // Seconds - { - "* * * * * * *", - "2006-01-02 15:04:05", - []crontimes{ - {"2013-01-01 00:00:00", "2013-01-01 00:00:01"}, - {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, - {"2013-01-01 00:59:59", "2013-01-01 01:00:00"}, - {"2013-01-01 23:59:59", "2013-01-02 00:00:00"}, - {"2013-02-28 23:59:59", "2013-03-01 00:00:00"}, - {"2016-02-28 23:59:59", "2016-02-29 00:00:00"}, - {"2012-12-31 23:59:59", "2013-01-01 00:00:00"}, - }, - }, + // Seconds + { + "* * * * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:00:01"}, + {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 00:59:59", "2013-01-01 01:00:00"}, + {"2013-01-01 23:59:59", "2013-01-02 00:00:00"}, + {"2013-02-28 23:59:59", "2013-03-01 00:00:00"}, + {"2016-02-28 23:59:59", "2016-02-29 00:00:00"}, + {"2012-12-31 23:59:59", "2013-01-01 00:00:00"}, + }, + }, - // Minutes - { - "* * * * *", - "2006-01-02 15:04:05", - []crontimes{ - {"2013-01-01 00:00:00", "2013-01-01 00:01:00"}, - {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, - {"2013-01-01 00:59:00", "2013-01-01 01:00:00"}, - {"2013-01-01 23:59:00", "2013-01-02 00:00:00"}, - {"2013-02-28 23:59:00", "2013-03-01 00:00:00"}, - {"2016-02-28 23:59:00", "2016-02-29 00:00:00"}, - {"2012-12-31 23:59:00", "2013-01-01 00:00:00"}, - }, - }, + // Minutes + { + "* * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:01:00"}, + {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 00:59:00", "2013-01-01 01:00:00"}, + {"2013-01-01 23:59:00", "2013-01-02 00:00:00"}, + {"2013-02-28 23:59:00", "2013-03-01 00:00:00"}, + {"2016-02-28 23:59:00", "2016-02-29 00:00:00"}, + {"2012-12-31 23:59:00", "2013-01-01 00:00:00"}, + }, + }, - // Minutes with interval - { - "17-43/5 * * * *", - "2006-01-02 15:04:05", - []crontimes{ - {"2013-01-01 00:00:00", "2013-01-01 00:17:00"}, - {"2013-01-01 00:16:59", "2013-01-01 00:17:00"}, - {"2013-01-01 00:30:00", "2013-01-01 00:32:00"}, - {"2013-01-01 00:50:00", "2013-01-01 01:17:00"}, - {"2013-01-01 23:50:00", "2013-01-02 00:17:00"}, - {"2013-02-28 23:50:00", "2013-03-01 00:17:00"}, - {"2016-02-28 23:50:00", "2016-02-29 00:17:00"}, - {"2012-12-31 23:50:00", "2013-01-01 00:17:00"}, - }, - }, + // Minutes with interval + { + "17-43/5 * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:17:00"}, + {"2013-01-01 00:16:59", "2013-01-01 00:17:00"}, + {"2013-01-01 00:30:00", "2013-01-01 00:32:00"}, + {"2013-01-01 00:50:00", "2013-01-01 01:17:00"}, + {"2013-01-01 23:50:00", "2013-01-02 00:17:00"}, + {"2013-02-28 23:50:00", "2013-03-01 00:17:00"}, + {"2016-02-28 23:50:00", "2016-02-29 00:17:00"}, + {"2012-12-31 23:50:00", "2013-01-01 00:17:00"}, + }, + }, - // Minutes interval, list - { - "15-30/4,55 * * * *", - "2006-01-02 15:04:05", - []crontimes{ - {"2013-01-01 00:00:00", "2013-01-01 00:15:00"}, - {"2013-01-01 00:16:00", "2013-01-01 00:19:00"}, - {"2013-01-01 00:30:00", "2013-01-01 00:55:00"}, - {"2013-01-01 00:55:00", "2013-01-01 01:15:00"}, - {"2013-01-01 23:55:00", "2013-01-02 00:15:00"}, - {"2013-02-28 23:55:00", "2013-03-01 00:15:00"}, - {"2016-02-28 23:55:00", "2016-02-29 00:15:00"}, - {"2012-12-31 23:54:00", "2012-12-31 23:55:00"}, - {"2012-12-31 23:55:00", "2013-01-01 00:15:00"}, - }, - }, + // Minutes interval, list + { + "15-30/4,55 * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:15:00"}, + {"2013-01-01 00:16:00", "2013-01-01 00:19:00"}, + {"2013-01-01 00:30:00", "2013-01-01 00:55:00"}, + {"2013-01-01 00:55:00", "2013-01-01 01:15:00"}, + {"2013-01-01 23:55:00", "2013-01-02 00:15:00"}, + {"2013-02-28 23:55:00", "2013-03-01 00:15:00"}, + {"2016-02-28 23:55:00", "2016-02-29 00:15:00"}, + {"2012-12-31 23:54:00", "2012-12-31 23:55:00"}, + {"2012-12-31 23:55:00", "2013-01-01 00:15:00"}, + }, + }, - // Days of week - { - "0 0 * * MON", - "Mon 2006-01-02 15:04", - []crontimes{ - {"2013-01-01 00:00:00", "Mon 2013-01-07 00:00"}, - {"2013-01-28 00:00:00", "Mon 2013-02-04 00:00"}, - {"2013-12-30 00:30:00", "Mon 2014-01-06 00:00"}, - }, - }, + // Days of week + { + "0 0 * * MON", + "Mon 2006-01-02 15:04", + []crontimes{ + {"2013-01-01 00:00:00", "Mon 2013-01-07 00:00"}, + {"2013-01-28 00:00:00", "Mon 2013-02-04 00:00"}, + {"2013-12-30 00:30:00", "Mon 2014-01-06 00:00"}, + }, + }, - // TODO: more tests + // TODO: more tests } func TestCronExpressions(t *testing.T) { for _, test := range crontests { - for _, times := range test.times { - from, _ := time.Parse("2006-01-02 15:04:05", times.from) - next := cronexpression.NextTime(test.expr, from) - nextstr := next.Format(test.layout) - if nextstr != times.next { - t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) - } + for _, times := range test.times { + from, _ := time.Parse("2006-01-02 15:04:05", times.from) + next := cronexpression.NextTime(test.expr, from) + nextstr := next.Format(test.layout) + if nextstr != times.next { + t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) + } } } } From eefaec07583092cb7e3b85af0856cda9862202e1 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 11:18:33 -0400 Subject: [PATCH 051/105] added missing package comment, as per issue 2 --- cronexpression.go | 1 + 1 file changed, 1 insertion(+) diff --git a/cronexpression.go b/cronexpression.go index 8c14c56..0f6e783 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -8,6 +8,7 @@ * */ +// Package cronexpression parses cron time expressions. package cronexpression /******************************************************************************/ From d3a85f92d82041b188f5f137e855c3257e7058ee Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 11:40:02 -0400 Subject: [PATCH 052/105] added package doc, as per issue 2 --- cronexpression.go | 50 +++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/cronexpression.go b/cronexpression.go index 0f6e783..2c47424 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -23,11 +23,10 @@ import ( /******************************************************************************/ -// A CronExpression represents a specific cron expression as defined on +// A CronExpression represents a specific cron time expression as defined on // Wikipedia: https://en.wikipedia.org/wiki/Cron#CRON_expression -// type CronExpression struct { - Expression string + expression string secondList []int minuteList []int hourList []int @@ -74,14 +73,15 @@ func NewCronExpression(cronLine string) *CronExpression { copy(cronFields[1:], cronFields[0:]) cronFields[0] = "0" } - // We should have 7 fields at this point - if len(cronFields) != 7 { + // At this point, we should have at least 7 fields. Fields beyond the + // seventh one, if any, are ignored. + if len(cronFields) < 7 { panic("Malformed cron expression\n") } // Generic parser can be used for most fields cronExpr := &CronExpression{ - Expression: cronLine, + expression: cronLine, secondList: genericFieldParse(cronFields[0], 0, 59), minuteList: genericFieldParse(cronFields[1], 0, 59), hourList: genericFieldParse(cronFields[2], 0, 23), @@ -101,12 +101,9 @@ func NewCronExpression(cronLine string) *CronExpression { /******************************************************************************/ -// NextTime() returns the time stamp following fromTime which -// satisfies the cron expression cronLine. If no matching time stamp is found, -// using NoMatch() with the returned time stamp as argument will return true. -// -// If the same cron expression must be used repeatedly, it is better to use -// NewCronExpression() in order to avoid overhead of cron expression parsing. +// Given a time stamp `fromTime`, return the closest following time stamp +// which matches the cron expression string .. `cronLine`. The `time.Location` +// of the returned time stamp is the same as `fromTime`. func NextTime(cronLine string, fromTime time.Time) time.Time { cronexpr := NewCronExpression(cronLine) return cronexpr.NextTime(fromTime) @@ -114,12 +111,10 @@ func NextTime(cronLine string, fromTime time.Time) time.Time { /******************************************************************************/ -// NextTimeN() returns the n time stamps following fromTime which -// satisfy the cron expression cronLine. An empty list is returned if -// there is no matching time stamp. -// -// If the same cron expression must be used repeatedly, it is better to use -// NewCronExpression() in order to avoid overhead of cron expression parsing. +// Given a time stamp `fromTime`, return a slice of `n` closest following time +// stamps which match the cron expression string `cronLine`. The time stamps in +// the returned slice are in chronological ascending order. The `time.Location` +// of the returned time stamps is the same as `fromTime`. func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time { cronexpr := NewCronExpression(cronLine) return cronexpr.NextTimeN(fromTime, n) @@ -127,9 +122,9 @@ func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time { /******************************************************************************/ -// CronExpression.NextTime() returns the time stamp following fromTime which -// satisfies the cron expression. If no matching time stamp is found, -// using NoMatch() with the returned time stamp as argument will return true. +// Given a time stamp `fromTime`, return the closest following time stamp which +// matches the cron expression `cronexpr`. The `time.Location` of the returned +// time stamp is the same as `fromTime`. func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { // Special case if NoMatch(fromTime) { @@ -212,9 +207,10 @@ func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { /******************************************************************************/ -// CronExpression.NextTimeN() returns an array of n time stamps following -// fromTime which satisfy the cron expression. An empty list is returned if -// there is no matching time stamp. +// Given a time stamp `fromTime`, return a slice of `n` closest following time +// stamps which match the cron expression `cronexpr`. The time stamps in the +// returned slice are in chronological ascending order. The `time.Location` of +// the returned time stamps is the same as `fromTime`. func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time { if n <= 0 { panic("CronExpression.NextTimeN(): invalid count") @@ -237,8 +233,10 @@ func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time /******************************************************************************/ -// NoMatch() returns whether t is a valid time stamp, from CronExpression point -// of view. +// Returns `true` if time stamp `t` is not a valid time stamp from +// `CronExpression` point of view. An invalid time stamp is returned by this +// library whenever no matching time stamp is found given a specific cron +// expression. func NoMatch(t time.Time) bool { // https://en.wikipedia.org/wiki/Cron#CRON_expression: 1970–2099 return t.Year() >= 2100 From ae9c090812f213554cfaf1f4771a093410218239 Mon Sep 17 00:00:00 2001 From: gorhill Date: Fri, 30 Aug 2013 15:10:15 -0400 Subject: [PATCH 053/105] no need for NoMatch(), existing time.IsZero() does the job well --- README.md | 12 +++--------- cronexpression.go | 23 ++++------------------- 2 files changed, 7 insertions(+), 28 deletions(-) diff --git a/README.md b/README.md index db7e9ac..2461466 100644 --- a/README.md +++ b/README.md @@ -88,13 +88,13 @@ to create a `CronExpression` object once and keep a copy of it for reuse: nextTime := cronexpr.NextTime(time.Now()) ... -Use `cronexpression.NoMatch()` to find out whether a valid time was returned. For example, +Use `nextTime.IsZero()` to find out whether a valid time was returned. For example, - cronexpression.NoMatch(cronexpression.NextTime("* * * * * 1980", time.Now())) + cronexpression.NextTime("* * * * * 1980", time.Now()).IsZero() will return `true`, whereas - cronexpression.NoMatch(cronexpression.NextTime("* * * * * 2050", time.Now())) + cronexpression.NextTime("* * * * * 2050", time.Now()).IsZero() will return `false` (as of 2013-08-29...) @@ -143,9 +143,3 @@ Given a time stamp `fromTime`, return the closest following time stamp which mat Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression `cronexpr`. The time stamps in the returned slice are in chronological ascending order. The `time.Location` of the returned time stamps is the same as `fromTime`. -#### func NoMatch - - func NoMatch(t time.Time) bool - -Returns `true` if time stamp `t` is not a valid time stamp from `CronExpression` point of view. An invalid time stamp is returned by this library whenever no matching time stamp is found given a specific cron expression. - diff --git a/cronexpression.go b/cronexpression.go index 2c47424..3433bdb 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -45,10 +45,6 @@ type CronExpression struct { /******************************************************************************/ -var noMatchTime = time.Date(2100, 7, 1, 0, 0, 0, 0, time.UTC) - -/******************************************************************************/ - // NewCronExpression() returns a new CronExpression pointer. It expects // a well-formed cron expression. If a malformed cron expression is // supplied, the result is undefined. @@ -127,7 +123,7 @@ func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time { // time stamp is the same as `fromTime`. func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { // Special case - if NoMatch(fromTime) { + if fromTime.IsZero() { return fromTime } @@ -145,7 +141,7 @@ func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { v := fromTime.Year() i := sort.SearchInts(cronexpr.yearList, v) if i == len(cronexpr.yearList) { - return noMatchTime + return time.Time{} } if v != cronexpr.yearList[i] { return cronexpr.nextYear(fromTime) @@ -218,7 +214,7 @@ func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time nextTimes := make([]time.Time, 0) fromTime = cronexpr.NextTime(fromTime) for { - if NoMatch(fromTime) { + if fromTime.IsZero() { break } nextTimes = append(nextTimes, fromTime) @@ -233,23 +229,12 @@ func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time /******************************************************************************/ -// Returns `true` if time stamp `t` is not a valid time stamp from -// `CronExpression` point of view. An invalid time stamp is returned by this -// library whenever no matching time stamp is found given a specific cron -// expression. -func NoMatch(t time.Time) bool { - // https://en.wikipedia.org/wiki/Cron#CRON_expression: 1970–2099 - return t.Year() >= 2100 -} - -/******************************************************************************/ - func (cronexpr *CronExpression) nextYear(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate year i := sort.SearchInts(cronexpr.yearList, t.Year()+1) if i == len(cronexpr.yearList) { - return noMatchTime + return time.Time{} } // Year changed, need to recalculate actual days of month cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(cronexpr.yearList[i], cronexpr.monthList[0]) From 47d3d6e5435215b29a4a3bcc5eeda594af78f58b Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 08:06:59 -0400 Subject: [PATCH 054/105] changed naming convention as per https://groups.google.com/d/msg/golang-nuts/la6mB5xG1L4/W3aJaIRkZxUJ --- README.md | 58 +++++++++-------------------------- cronexpression.go | 69 ++++++++++++++++++------------------------ cronexpression_test.go | 6 ++-- 3 files changed, 47 insertions(+), 86 deletions(-) diff --git a/README.md b/README.md index 2461466..3741fd5 100644 --- a/README.md +++ b/README.md @@ -77,47 +77,32 @@ Import the library: Simplest way: - nextTime := cronexpression.NextTime("0 0 29 2 *", time.Now()) + nextTime := cronexpression.Parse("0 0 29 2 *").Next(time.Now()) Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". -If you need to reuse many times the same cron expression in your code, it is more efficient -to create a `CronExpression` object once and keep a copy of it for reuse: +You can keep the returned Expression pointer around if you want to reuse it: - cronexpr := cronexpression.NewCronExpression("0 0 29 2 *") - nextTime := cronexpr.NextTime(time.Now()) + cronexpr := cronexpression.Parse("0 0 29 2 *") + nextTime := cronexpr.Next(time.Now()) ... + nextTime := cronexpr.Next(nextTime) -Use `nextTime.IsZero()` to find out whether a valid time was returned. For example, +Use `time.IsZero()` to find out whether a valid time was returned. For example, - cronexpression.NextTime("* * * * * 1980", time.Now()).IsZero() + cronexpression.Next("* * * * * 1980", time.Now()).IsZero() will return `true`, whereas - cronexpression.NextTime("* * * * * 2050", time.Now()).IsZero() + cronexpression.Next("* * * * * 2050", time.Now()).IsZero() will return `false` (as of 2013-08-29...) -API ---- +You may also query for `n` next time stamps: -#### func NextTime + cronexpression.Parse("0 0 29 2 *").NextN(time.Now(), 5) - func NextTime(cronLine string, fromTime time.Time) time.Time - -Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression string `cronLine`. The `time.Location` of the returned time stamp is the same as `fromTime`. - -#### func NextTimeN - - func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time - -Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression string `cronLine`. The time stamps in the returned slice are in chronological ascending order. The `time.Location` of the returned time stamps is the same as `fromTime`. - -Example: - - cronexpression.NextTimeN("0 0 0 29 2 ? *", time.Now(), 5) - -will result in the following time stamps being returned (as of 2013-08-30): +which returns a slice of time.Time objects, containing the following time stamps (as of 2013-08-30): 2016-02-29 00:00:00 2020-02-29 00:00:00 @@ -125,21 +110,6 @@ will result in the following time stamps being returned (as of 2013-08-30): 2028-02-29 00:00:00 2032-02-29 00:00:00 -#### func NewCronExpression - - func NewCronExpression(cronLine string) *CronExpression - -Return a new `CronExpression` pointer which will interpret the cron expression string `cronLine`. - -#### func (*CronExpression) NextTime - - func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time - -Given a time stamp `fromTime`, return the closest following time stamp which matches the cron expression `cronexpr`. The `time.Location` of the returned time stamp is the same as `fromTime`. - -#### func (*CronExpression) NextTimeN - - func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time - -Given a time stamp `fromTime`, return a slice of `n` closest following time stamps which match the cron expression `cronexpr`. The time stamps in the returned slice are in chronological ascending order. The `time.Location` of the returned time stamps is the same as `fromTime`. - +API +--- + diff --git a/cronexpression.go b/cronexpression.go index 3433bdb..eaae8cd 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -23,9 +23,9 @@ import ( /******************************************************************************/ -// A CronExpression represents a specific cron time expression as defined on +// A Expression represents a specific cron time expression as defined on // Wikipedia: https://en.wikipedia.org/wiki/Cron#CRON_expression -type CronExpression struct { +type Expression struct { expression string secondList []int minuteList []int @@ -45,10 +45,22 @@ type CronExpression struct { /******************************************************************************/ -// NewCronExpression() returns a new CronExpression pointer. It expects +// Check whether the cron expression `cronLine` is valid. If not valid, the +// index in the `cronLine` string at which there is an error is returned. +func Check(cronLine string) int { + + // Split into fields + _ = regexp.MustCompile(`\s+`).Split(cronLine, -1) + + return -1 +} + +/******************************************************************************/ + +// Parse() returns a new Expression pointer. It expects // a well-formed cron expression. If a malformed cron expression is // supplied, the result is undefined. -func NewCronExpression(cronLine string) *CronExpression { +func Parse(cronLine string) *Expression { cronLineNormalized := cronNormalize(cronLine) // Split into fields @@ -76,7 +88,7 @@ func NewCronExpression(cronLine string) *CronExpression { } // Generic parser can be used for most fields - cronExpr := &CronExpression{ + cronExpr := &Expression{ expression: cronLine, secondList: genericFieldParse(cronFields[0], 0, 59), minuteList: genericFieldParse(cronFields[1], 0, 59), @@ -97,31 +109,10 @@ func NewCronExpression(cronLine string) *CronExpression { /******************************************************************************/ -// Given a time stamp `fromTime`, return the closest following time stamp -// which matches the cron expression string .. `cronLine`. The `time.Location` -// of the returned time stamp is the same as `fromTime`. -func NextTime(cronLine string, fromTime time.Time) time.Time { - cronexpr := NewCronExpression(cronLine) - return cronexpr.NextTime(fromTime) -} - -/******************************************************************************/ - -// Given a time stamp `fromTime`, return a slice of `n` closest following time -// stamps which match the cron expression string `cronLine`. The time stamps in -// the returned slice are in chronological ascending order. The `time.Location` -// of the returned time stamps is the same as `fromTime`. -func NextTimeN(cronLine string, fromTime time.Time, n int) []time.Time { - cronexpr := NewCronExpression(cronLine) - return cronexpr.NextTimeN(fromTime, n) -} - -/******************************************************************************/ - // Given a time stamp `fromTime`, return the closest following time stamp which // matches the cron expression `cronexpr`. The `time.Location` of the returned // time stamp is the same as `fromTime`. -func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { +func (cronexpr *Expression) Next(fromTime time.Time) time.Time { // Special case if fromTime.IsZero() { return fromTime @@ -207,12 +198,12 @@ func (cronexpr *CronExpression) NextTime(fromTime time.Time) time.Time { // stamps which match the cron expression `cronexpr`. The time stamps in the // returned slice are in chronological ascending order. The `time.Location` of // the returned time stamps is the same as `fromTime`. -func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time { +func (cronexpr *Expression) NextN(fromTime time.Time, n int) []time.Time { if n <= 0 { - panic("CronExpression.NextTimeN(): invalid count") + panic("Expression.NextN(): invalid count") } nextTimes := make([]time.Time, 0) - fromTime = cronexpr.NextTime(fromTime) + fromTime = cronexpr.Next(fromTime) for { if fromTime.IsZero() { break @@ -229,7 +220,7 @@ func (cronexpr *CronExpression) NextTimeN(fromTime time.Time, n int) []time.Time /******************************************************************************/ -func (cronexpr *CronExpression) nextYear(t time.Time) time.Time { +func (cronexpr *Expression) nextYear(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate year i := sort.SearchInts(cronexpr.yearList, t.Year()+1) @@ -262,7 +253,7 @@ func (cronexpr *CronExpression) nextYear(t time.Time) time.Time { /******************************************************************************/ -func (cronexpr *CronExpression) nextMonth(t time.Time) time.Time { +func (cronexpr *Expression) nextMonth(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate month i := sort.SearchInts(cronexpr.monthList, int(t.Month())+1) @@ -296,7 +287,7 @@ func (cronexpr *CronExpression) nextMonth(t time.Time) time.Time { /******************************************************************************/ -func (cronexpr *CronExpression) calculateActualDaysOfMonth(year, month int) []int { +func (cronexpr *Expression) calculateActualDaysOfMonth(year, month int) []int { actualDaysOfMonthMap := make(map[int]bool) timeOrigin := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) lastDayOfMonth := timeOrigin.AddDate(0, 1, -1).Day() @@ -382,7 +373,7 @@ func (cronexpr *CronExpression) calculateActualDaysOfMonth(year, month int) []in /******************************************************************************/ -func (cronexpr *CronExpression) nextDayOfMonth(t time.Time) time.Time { +func (cronexpr *Expression) nextDayOfMonth(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate day of month i := sort.SearchInts(cronexpr.actualDaysOfMonthList, t.Day()+1) @@ -403,7 +394,7 @@ func (cronexpr *CronExpression) nextDayOfMonth(t time.Time) time.Time { /******************************************************************************/ -func (cronexpr *CronExpression) nextHour(t time.Time) time.Time { +func (cronexpr *Expression) nextHour(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate hour i := sort.SearchInts(cronexpr.hourList, t.Hour()+1) @@ -424,7 +415,7 @@ func (cronexpr *CronExpression) nextHour(t time.Time) time.Time { /******************************************************************************/ -func (cronexpr *CronExpression) nextMinute(t time.Time) time.Time { +func (cronexpr *Expression) nextMinute(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate minute i := sort.SearchInts(cronexpr.minuteList, t.Minute()+1) @@ -445,7 +436,7 @@ func (cronexpr *CronExpression) nextMinute(t time.Time) time.Time { /******************************************************************************/ -func (cronexpr *CronExpression) nextSecond(t time.Time) time.Time { +func (cronexpr *Expression) nextSecond(t time.Time) time.Time { // nextSecond() assumes all other fields are exactly matched // to the cron expression @@ -525,7 +516,7 @@ func cronNormalize(cronLine string) string { /******************************************************************************/ -func (cronexpr *CronExpression) dayofweekFieldParse(cronField string) error { +func (cronexpr *Expression) dayofweekFieldParse(cronField string) error { // Defaults cronexpr.daysOfWeekRestricted = true cronexpr.lastWeekDaysOfWeek = make(map[int]bool) @@ -585,7 +576,7 @@ func (cronexpr *CronExpression) dayofweekFieldParse(cronField string) error { /******************************************************************************/ -func (cronexpr *CronExpression) dayofmonthFieldParse(cronField string) error { +func (cronexpr *Expression) dayofmonthFieldParse(cronField string) error { // Defaults cronexpr.daysOfMonthRestricted = true cronexpr.lastDayOfMonth = false diff --git a/cronexpression_test.go b/cronexpression_test.go index ad803db..3bd76fe 100644 --- a/cronexpression_test.go +++ b/cronexpression_test.go @@ -109,14 +109,14 @@ var crontests = []crontest{ // TODO: more tests } -func TestCronExpressions(t *testing.T) { +func TestExpressions(t *testing.T) { for _, test := range crontests { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) - next := cronexpression.NextTime(test.expr, from) + next := cronexpression.Parse(test.expr).Next(from) nextstr := next.Format(test.layout) if nextstr != times.next { - t.Errorf("(\"%s\").NextTime(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) + t.Errorf("(\"%s\").Next(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) } } } From a22eb7d9e6be2c9028abac6e849eaabf22aa51f3 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 08:15:58 -0400 Subject: [PATCH 055/105] forgot to change remnant of old naming convention --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 3741fd5..b19cb7f 100644 --- a/README.md +++ b/README.md @@ -90,11 +90,11 @@ You can keep the returned Expression pointer around if you want to reuse it: Use `time.IsZero()` to find out whether a valid time was returned. For example, - cronexpression.Next("* * * * * 1980", time.Now()).IsZero() + cronexpression.Parse("* * * * * 1980").Next(time.Now()).IsZero() will return `true`, whereas - cronexpression.Next("* * * * * 2050", time.Now()).IsZero() + cronexpression.Parse("* * * * * 2050").Next(time.Now()).IsZero() will return `false` (as of 2013-08-29...) From e41acb76c843dc72e120d8a5a78089d612cb597b Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 08:17:25 -0400 Subject: [PATCH 056/105] oops, removed unfinished work re Check() --- cronexpression.go | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/cronexpression.go b/cronexpression.go index eaae8cd..964842d 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -45,18 +45,6 @@ type Expression struct { /******************************************************************************/ -// Check whether the cron expression `cronLine` is valid. If not valid, the -// index in the `cronLine` string at which there is an error is returned. -func Check(cronLine string) int { - - // Split into fields - _ = regexp.MustCompile(`\s+`).Split(cronLine, -1) - - return -1 -} - -/******************************************************************************/ - // Parse() returns a new Expression pointer. It expects // a well-formed cron expression. If a malformed cron expression is // supplied, the result is undefined. From 8af06bafc96e3a38c8ba2b524b5b3a0e7e535e27 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 08:23:51 -0400 Subject: [PATCH 057/105] more work for renaming convention as per https://groups.google.com/d/msg/golang-nuts/la6mB5xG1L4/W3aJaIRkZxUJ --- README.md | 6 +- cronexpression.go | 258 +++++++++++++++++++++++----------------------- 2 files changed, 132 insertions(+), 132 deletions(-) diff --git a/README.md b/README.md index b19cb7f..e2b97e3 100644 --- a/README.md +++ b/README.md @@ -83,10 +83,10 @@ Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02 You can keep the returned Expression pointer around if you want to reuse it: - cronexpr := cronexpression.Parse("0 0 29 2 *") - nextTime := cronexpr.Next(time.Now()) + expr := cronexpression.Parse("0 0 29 2 *") + nextTime := expr.Next(time.Now()) ... - nextTime := cronexpr.Next(nextTime) + nextTime := expr.Next(nextTime) Use `time.IsZero()` to find out whether a valid time was returned. For example, diff --git a/cronexpression.go b/cronexpression.go index 964842d..d3c3d52 100644 --- a/cronexpression.go +++ b/cronexpression.go @@ -98,15 +98,15 @@ func Parse(cronLine string) *Expression { /******************************************************************************/ // Given a time stamp `fromTime`, return the closest following time stamp which -// matches the cron expression `cronexpr`. The `time.Location` of the returned +// matches the cron expression `expr`. The `time.Location` of the returned // time stamp is the same as `fromTime`. -func (cronexpr *Expression) Next(fromTime time.Time) time.Time { +func (expr *Expression) Next(fromTime time.Time) time.Time { // Special case if fromTime.IsZero() { return fromTime } - // Since cronexpr.nextSecond()-cronexpr.nextMonth() expects that the + // Since expr.nextSecond()-expr.nextMonth() expects that the // supplied time stamp is a perfect match to the underlying cron // expression, and since this function is an entry point where `fromTime` // does not necessarily matches the underlying cron expression, @@ -118,80 +118,80 @@ func (cronexpr *Expression) Next(fromTime time.Time) time.Time { // year v := fromTime.Year() - i := sort.SearchInts(cronexpr.yearList, v) - if i == len(cronexpr.yearList) { + i := sort.SearchInts(expr.yearList, v) + if i == len(expr.yearList) { return time.Time{} } - if v != cronexpr.yearList[i] { - return cronexpr.nextYear(fromTime) + if v != expr.yearList[i] { + return expr.nextYear(fromTime) } // month v = int(fromTime.Month()) - i = sort.SearchInts(cronexpr.monthList, v) - if i == len(cronexpr.monthList) { - return cronexpr.nextYear(fromTime) + i = sort.SearchInts(expr.monthList, v) + if i == len(expr.monthList) { + return expr.nextYear(fromTime) } - if v != cronexpr.monthList[i] { - return cronexpr.nextMonth(fromTime) + if v != expr.monthList[i] { + return expr.nextMonth(fromTime) } - cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(fromTime.Year(), int(fromTime.Month())) - if len(cronexpr.actualDaysOfMonthList) == 0 { - return cronexpr.nextMonth(fromTime) + expr.actualDaysOfMonthList = expr.calculateActualDaysOfMonth(fromTime.Year(), int(fromTime.Month())) + if len(expr.actualDaysOfMonthList) == 0 { + return expr.nextMonth(fromTime) } // day of month v = fromTime.Day() - i = sort.SearchInts(cronexpr.actualDaysOfMonthList, v) - if i == len(cronexpr.actualDaysOfMonthList) { - return cronexpr.nextMonth(fromTime) + i = sort.SearchInts(expr.actualDaysOfMonthList, v) + if i == len(expr.actualDaysOfMonthList) { + return expr.nextMonth(fromTime) } - if v != cronexpr.actualDaysOfMonthList[i] { - return cronexpr.nextDayOfMonth(fromTime) + if v != expr.actualDaysOfMonthList[i] { + return expr.nextDayOfMonth(fromTime) } // hour v = fromTime.Hour() - i = sort.SearchInts(cronexpr.hourList, v) - if i == len(cronexpr.hourList) { - return cronexpr.nextDayOfMonth(fromTime) + i = sort.SearchInts(expr.hourList, v) + if i == len(expr.hourList) { + return expr.nextDayOfMonth(fromTime) } - if v != cronexpr.hourList[i] { - return cronexpr.nextHour(fromTime) + if v != expr.hourList[i] { + return expr.nextHour(fromTime) } // minute v = fromTime.Minute() - i = sort.SearchInts(cronexpr.minuteList, v) - if i == len(cronexpr.minuteList) { - return cronexpr.nextHour(fromTime) + i = sort.SearchInts(expr.minuteList, v) + if i == len(expr.minuteList) { + return expr.nextHour(fromTime) } - if v != cronexpr.minuteList[i] { - return cronexpr.nextMinute(fromTime) + if v != expr.minuteList[i] { + return expr.nextMinute(fromTime) } // second v = fromTime.Second() - i = sort.SearchInts(cronexpr.secondList, v) - if i == len(cronexpr.secondList) { - return cronexpr.nextMinute(fromTime) + i = sort.SearchInts(expr.secondList, v) + if i == len(expr.secondList) { + return expr.nextMinute(fromTime) } // If we reach this point, there is nothing better to do // than to move to the next second - return cronexpr.nextSecond(fromTime) + return expr.nextSecond(fromTime) } /******************************************************************************/ // Given a time stamp `fromTime`, return a slice of `n` closest following time -// stamps which match the cron expression `cronexpr`. The time stamps in the +// stamps which match the cron expression `expr`. The time stamps in the // returned slice are in chronological ascending order. The `time.Location` of // the returned time stamps is the same as `fromTime`. -func (cronexpr *Expression) NextN(fromTime time.Time, n int) []time.Time { +func (expr *Expression) NextN(fromTime time.Time, n int) []time.Time { if n <= 0 { panic("Expression.NextN(): invalid count") } nextTimes := make([]time.Time, 0) - fromTime = cronexpr.Next(fromTime) + fromTime = expr.Next(fromTime) for { if fromTime.IsZero() { break @@ -201,81 +201,81 @@ func (cronexpr *Expression) NextN(fromTime time.Time, n int) []time.Time { if n == 0 { break } - fromTime = cronexpr.nextSecond(fromTime) + fromTime = expr.nextSecond(fromTime) } return nextTimes } /******************************************************************************/ -func (cronexpr *Expression) nextYear(t time.Time) time.Time { +func (expr *Expression) nextYear(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate year - i := sort.SearchInts(cronexpr.yearList, t.Year()+1) - if i == len(cronexpr.yearList) { + i := sort.SearchInts(expr.yearList, t.Year()+1) + if i == len(expr.yearList) { return time.Time{} } // Year changed, need to recalculate actual days of month - cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(cronexpr.yearList[i], cronexpr.monthList[0]) - if len(cronexpr.actualDaysOfMonthList) == 0 { - return cronexpr.nextMonth(time.Date( - cronexpr.yearList[i], - time.Month(cronexpr.monthList[0]), + expr.actualDaysOfMonthList = expr.calculateActualDaysOfMonth(expr.yearList[i], expr.monthList[0]) + if len(expr.actualDaysOfMonthList) == 0 { + return expr.nextMonth(time.Date( + expr.yearList[i], + time.Month(expr.monthList[0]), 1, - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], 0, time.Local)) } return time.Date( - cronexpr.yearList[i], - time.Month(cronexpr.monthList[0]), - cronexpr.actualDaysOfMonthList[0], - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], + expr.yearList[i], + time.Month(expr.monthList[0]), + expr.actualDaysOfMonthList[0], + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], 0, time.Local) } /******************************************************************************/ -func (cronexpr *Expression) nextMonth(t time.Time) time.Time { +func (expr *Expression) nextMonth(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate month - i := sort.SearchInts(cronexpr.monthList, int(t.Month())+1) - if i == len(cronexpr.monthList) { - return cronexpr.nextYear(t) + i := sort.SearchInts(expr.monthList, int(t.Month())+1) + if i == len(expr.monthList) { + return expr.nextYear(t) } // Month changed, need to recalculate actual days of month - cronexpr.actualDaysOfMonthList = cronexpr.calculateActualDaysOfMonth(t.Year(), cronexpr.monthList[i]) - if len(cronexpr.actualDaysOfMonthList) == 0 { - return cronexpr.nextMonth(time.Date( + expr.actualDaysOfMonthList = expr.calculateActualDaysOfMonth(t.Year(), expr.monthList[i]) + if len(expr.actualDaysOfMonthList) == 0 { + return expr.nextMonth(time.Date( t.Year(), - time.Month(cronexpr.monthList[i]), + time.Month(expr.monthList[i]), 1, - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], 0, time.Local)) } return time.Date( t.Year(), - time.Month(cronexpr.monthList[i]), - cronexpr.actualDaysOfMonthList[0], - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], + time.Month(expr.monthList[i]), + expr.actualDaysOfMonthList[0], + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], 0, time.Local) } /******************************************************************************/ -func (cronexpr *Expression) calculateActualDaysOfMonth(year, month int) []int { +func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { actualDaysOfMonthMap := make(map[int]bool) timeOrigin := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) lastDayOfMonth := timeOrigin.AddDate(0, 1, -1).Day() @@ -285,13 +285,13 @@ func (cronexpr *Expression) calculateActualDaysOfMonth(year, month int) []int { // "fields - day of month, and day of week. If both fields are // "restricted (ie, aren't *), the command will be run when // "either field matches the current time" - if cronexpr.daysOfMonthRestricted || cronexpr.daysOfWeekRestricted == false { + if expr.daysOfMonthRestricted || expr.daysOfWeekRestricted == false { // Last day of month - if cronexpr.lastDayOfMonth { + if expr.lastDayOfMonth { actualDaysOfMonthMap[lastDayOfMonth] = true } // Days of month - for v, _ := range cronexpr.daysOfMonth { + for v, _ := range expr.daysOfMonth { // Ignore days beyond end of month if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -299,7 +299,7 @@ func (cronexpr *Expression) calculateActualDaysOfMonth(year, month int) []int { } // Work days of month // As per Wikipedia: month boundaries are not crossed. - for v, _ := range cronexpr.workdaysOfMonth { + for v, _ := range expr.workdaysOfMonth { // Ignore days beyond end of month if v <= lastDayOfMonth { // If saturday, then friday @@ -322,14 +322,14 @@ func (cronexpr *Expression) calculateActualDaysOfMonth(year, month int) []int { } } - if cronexpr.daysOfWeekRestricted { + if expr.daysOfWeekRestricted { // How far first sunday is from first day of month offset := 7 - int(timeOrigin.Weekday()) // days of week // offset : (7 - day_of_week_of_1st_day_of_month) // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 for w := 0; w <= 4; w += 1 { - for v, _ := range cronexpr.daysOfWeek { + for v, _ := range expr.daysOfWeek { v := 1 + w*7 + (offset+v)%7 if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -339,7 +339,7 @@ func (cronexpr *Expression) calculateActualDaysOfMonth(year, month int) []int { // days of week of specific week in the month // offset : (7 - day_of_week_of_1st_day_of_month) // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for v, _ := range cronexpr.specificWeekDaysOfWeek { + for v, _ := range expr.specificWeekDaysOfWeek { v := 1 + 7*(v/7) + (offset+v)%7 if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -348,7 +348,7 @@ func (cronexpr *Expression) calculateActualDaysOfMonth(year, month int) []int { // Last days of week of the month lastWeekOrigin := timeOrigin.AddDate(0, 1, -7) offset = 7 - int(lastWeekOrigin.Weekday()) - for v, _ := range cronexpr.lastWeekDaysOfWeek { + for v, _ := range expr.lastWeekDaysOfWeek { v := lastWeekOrigin.Day() + (offset+v)%7 if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -361,54 +361,54 @@ func (cronexpr *Expression) calculateActualDaysOfMonth(year, month int) []int { /******************************************************************************/ -func (cronexpr *Expression) nextDayOfMonth(t time.Time) time.Time { +func (expr *Expression) nextDayOfMonth(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate day of month - i := sort.SearchInts(cronexpr.actualDaysOfMonthList, t.Day()+1) - if i == len(cronexpr.actualDaysOfMonthList) { - return cronexpr.nextMonth(t) + i := sort.SearchInts(expr.actualDaysOfMonthList, t.Day()+1) + if i == len(expr.actualDaysOfMonthList) { + return expr.nextMonth(t) } return time.Date( t.Year(), t.Month(), - cronexpr.actualDaysOfMonthList[i], - cronexpr.hourList[0], - cronexpr.minuteList[0], - cronexpr.secondList[0], + expr.actualDaysOfMonthList[i], + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], 0, t.Location()) } /******************************************************************************/ -func (cronexpr *Expression) nextHour(t time.Time) time.Time { +func (expr *Expression) nextHour(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate hour - i := sort.SearchInts(cronexpr.hourList, t.Hour()+1) - if i == len(cronexpr.hourList) { - return cronexpr.nextDayOfMonth(t) + i := sort.SearchInts(expr.hourList, t.Hour()+1) + if i == len(expr.hourList) { + return expr.nextDayOfMonth(t) } return time.Date( t.Year(), t.Month(), t.Day(), - cronexpr.hourList[i], - cronexpr.minuteList[0], - cronexpr.secondList[0], + expr.hourList[i], + expr.minuteList[0], + expr.secondList[0], 0, t.Location()) } /******************************************************************************/ -func (cronexpr *Expression) nextMinute(t time.Time) time.Time { +func (expr *Expression) nextMinute(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate minute - i := sort.SearchInts(cronexpr.minuteList, t.Minute()+1) - if i == len(cronexpr.minuteList) { - return cronexpr.nextHour(t) + i := sort.SearchInts(expr.minuteList, t.Minute()+1) + if i == len(expr.minuteList) { + return expr.nextHour(t) } return time.Date( @@ -416,23 +416,23 @@ func (cronexpr *Expression) nextMinute(t time.Time) time.Time { t.Month(), t.Day(), t.Hour(), - cronexpr.minuteList[i], - cronexpr.secondList[0], + expr.minuteList[i], + expr.secondList[0], 0, t.Location()) } /******************************************************************************/ -func (cronexpr *Expression) nextSecond(t time.Time) time.Time { +func (expr *Expression) nextSecond(t time.Time) time.Time { // nextSecond() assumes all other fields are exactly matched // to the cron expression // Find index at which item in list is greater or equal to // candidate second - i := sort.SearchInts(cronexpr.secondList, t.Second()+1) - if i == len(cronexpr.secondList) { - return cronexpr.nextMinute(t) + i := sort.SearchInts(expr.secondList, t.Second()+1) + if i == len(expr.secondList) { + return expr.nextMinute(t) } return time.Date( @@ -441,7 +441,7 @@ func (cronexpr *Expression) nextSecond(t time.Time) time.Time { t.Day(), t.Hour(), t.Minute(), - cronexpr.secondList[i], + expr.secondList[i], 0, t.Location()) } @@ -504,11 +504,11 @@ func cronNormalize(cronLine string) string { /******************************************************************************/ -func (cronexpr *Expression) dayofweekFieldParse(cronField string) error { +func (expr *Expression) dayofweekFieldParse(cronField string) error { // Defaults - cronexpr.daysOfWeekRestricted = true - cronexpr.lastWeekDaysOfWeek = make(map[int]bool) - cronexpr.daysOfWeek = make(map[int]bool) + expr.daysOfWeekRestricted = true + expr.lastWeekDaysOfWeek = make(map[int]bool) + expr.daysOfWeek = make(map[int]bool) // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" cronList := strings.Split(cronField, ",") @@ -517,8 +517,8 @@ func (cronexpr *Expression) dayofweekFieldParse(cronField string) error { step, s := extractInterval(s) // "*" if s == "*" { - cronexpr.daysOfWeekRestricted = (step > 1) - populateMany(cronexpr.daysOfWeek, 0, 6, step) + expr.daysOfWeekRestricted = (step > 1) + populateMany(expr.daysOfWeek, 0, 6, step) continue } // "-" @@ -527,14 +527,14 @@ func (cronexpr *Expression) dayofweekFieldParse(cronField string) error { if i >= 0 { min := atoi(s[:i]) % 7 max := atoi(s[i+1:]) % 7 - populateMany(cronexpr.daysOfWeek, min, max, step) + populateMany(expr.daysOfWeek, min, max, step) continue } // single value // "l": week day for last week i = strings.Index(s, "l") if i >= 0 { - populateOne(cronexpr.lastWeekDaysOfWeek, atoi(s[:i])%7) + populateOne(expr.lastWeekDaysOfWeek, atoi(s[:i])%7) continue } // "#": week day for specific week @@ -545,18 +545,18 @@ func (cronexpr *Expression) dayofweekFieldParse(cronField string) error { w := atoi(s[i+1:]) // v domain = [0,7] // w domain = [1,5] - populateOne(cronexpr.specificWeekDaysOfWeek, (w-1)*7+(v%7)) + populateOne(expr.specificWeekDaysOfWeek, (w-1)*7+(v%7)) continue } // week day interval for all weeks if step > 0 { v := atoi(s) % 7 - populateMany(cronexpr.daysOfWeek, v, 6, step) + populateMany(expr.daysOfWeek, v, 6, step) continue } // single week day for all weeks v := atoi(s) % 7 - populateOne(cronexpr.daysOfWeek, v) + populateOne(expr.daysOfWeek, v) } return nil @@ -564,13 +564,13 @@ func (cronexpr *Expression) dayofweekFieldParse(cronField string) error { /******************************************************************************/ -func (cronexpr *Expression) dayofmonthFieldParse(cronField string) error { +func (expr *Expression) dayofmonthFieldParse(cronField string) error { // Defaults - cronexpr.daysOfMonthRestricted = true - cronexpr.lastDayOfMonth = false + expr.daysOfMonthRestricted = true + expr.lastDayOfMonth = false - cronexpr.daysOfMonth = make(map[int]bool) // days of month map - cronexpr.workdaysOfMonth = make(map[int]bool) // work day of month map + expr.daysOfMonth = make(map[int]bool) // days of month map + expr.workdaysOfMonth = make(map[int]bool) // work day of month map // Comma separator is used to mix different allowed syntax cronList := strings.Split(cronField, ",") @@ -579,35 +579,35 @@ func (cronexpr *Expression) dayofmonthFieldParse(cronField string) error { step, s := extractInterval(s) // "*" if s == "*" { - cronexpr.daysOfMonthRestricted = (step > 1) - populateMany(cronexpr.daysOfMonth, 1, 31, step) + expr.daysOfMonthRestricted = (step > 1) + populateMany(expr.daysOfMonth, 1, 31, step) continue } // "-" i := strings.Index(s, "-") if i >= 0 { - populateMany(cronexpr.daysOfMonth, atoi(s[:i]), atoi(s[i+1:]), step) + populateMany(expr.daysOfMonth, atoi(s[:i]), atoi(s[i+1:]), step) continue } // single value // "l": last day of month if s == "l" { - cronexpr.lastDayOfMonth = true + expr.lastDayOfMonth = true continue } // "w": week day i = strings.Index(s, "w") if i >= 0 { - populateOne(cronexpr.workdaysOfMonth, atoi(s[:i])) + populateOne(expr.workdaysOfMonth, atoi(s[:i])) continue } // single value with interval if step > 0 { - populateMany(cronexpr.daysOfMonth, atoi(s), 31, step) + populateMany(expr.daysOfMonth, atoi(s), 31, step) continue } // single value - populateOne(cronexpr.daysOfMonth, atoi(s)) + populateOne(expr.daysOfMonth, atoi(s)) } return nil From 457a81697ecdc75e81f518579232b56c8074c63e Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 08:24:52 -0400 Subject: [PATCH 058/105] code typo --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e2b97e3..b67cfd0 100644 --- a/README.md +++ b/README.md @@ -86,7 +86,7 @@ You can keep the returned Expression pointer around if you want to reuse it: expr := cronexpression.Parse("0 0 29 2 *") nextTime := expr.Next(time.Now()) ... - nextTime := expr.Next(nextTime) + nextTime = expr.Next(nextTime) Use `time.IsZero()` to find out whether a valid time was returned. For example, From 6190b9d9dba1c8795565e9e2bf054fb966b98162 Mon Sep 17 00:00:00 2001 From: Raymond Hill Date: Sat, 31 Aug 2013 08:50:51 -0400 Subject: [PATCH 059/105] Rename cronexpression.go to cronexpr.go --- cronexpression.go => cronexpr.go | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename cronexpression.go => cronexpr.go (100%) diff --git a/cronexpression.go b/cronexpr.go similarity index 100% rename from cronexpression.go rename to cronexpr.go From a7091b7c64e4b21956289521754fb27f0fb8bafb Mon Sep 17 00:00:00 2001 From: Raymond Hill Date: Sat, 31 Aug 2013 08:51:11 -0400 Subject: [PATCH 060/105] Rename cronexpression_test.go to cronexpr_test.go --- cronexpression_test.go => cronexpr_test.go | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename cronexpression_test.go => cronexpr_test.go (100%) diff --git a/cronexpression_test.go b/cronexpr_test.go similarity index 100% rename from cronexpression_test.go rename to cronexpr_test.go From 83135b3c5c4ea02e1ef1a3846922b4ac92fdab05 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 09:00:12 -0400 Subject: [PATCH 061/105] renaming cronexpression to cronexpr --- cronexpr.go | 13 +++++++++---- cronexpr_test.go | 10 +++++----- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/cronexpr.go b/cronexpr.go index d3c3d52..5909aa1 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -1,15 +1,15 @@ /*! * Copyright 2013 Raymond Hill * - * Project: github.com/gorhill/cronexpression - * File: cronexpression.go + * Project: github.com/gorhill/cronexpr + * File: cronexpr.go * Version: 1.0 * License: GPL v3 see * */ -// Package cronexpression parses cron time expressions. -package cronexpression +// Package cronexpr parses cron time expressions. +package cronexpr /******************************************************************************/ @@ -100,6 +100,8 @@ func Parse(cronLine string) *Expression { // Given a time stamp `fromTime`, return the closest following time stamp which // matches the cron expression `expr`. The `time.Location` of the returned // time stamp is the same as `fromTime`. +// +// A nil time.Time object is returned if no matching time stamp exists. func (expr *Expression) Next(fromTime time.Time) time.Time { // Special case if fromTime.IsZero() { @@ -186,6 +188,9 @@ func (expr *Expression) Next(fromTime time.Time) time.Time { // stamps which match the cron expression `expr`. The time stamps in the // returned slice are in chronological ascending order. The `time.Location` of // the returned time stamps is the same as `fromTime`. +// +// A slice with less than `n` entries (up to zero) is returned if not +// enough existing matching time stamps which exist. func (expr *Expression) NextN(fromTime time.Time, n int) []time.Time { if n <= 0 { panic("Expression.NextN(): invalid count") diff --git a/cronexpr_test.go b/cronexpr_test.go index 3bd76fe..da84633 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -1,19 +1,19 @@ /*! * Copyright 2013 Raymond Hill * - * Project: github.com/gorhill/cronexpression - * File: cronexpression_test.go + * Project: github.com/gorhill/cronexpr + * File: cronexpr_test.go * Version: 1.0 * License: GPL v3 see * */ -package cronexpression_test +package cronexpr_test /******************************************************************************/ import ( - "cronexpression" + "cronexpr" "testing" "time" ) @@ -113,7 +113,7 @@ func TestExpressions(t *testing.T) { for _, test := range crontests { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) - next := cronexpression.Parse(test.expr).Next(from) + next := cronexpr.Parse(test.expr).Next(from) nextstr := next.Format(test.layout) if nextstr != times.next { t.Errorf("(\"%s\").Next(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) From 022ba1e5bfc81eb0f8e78712e201b2935c7403a5 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 09:00:46 -0400 Subject: [PATCH 062/105] renaming cronexpression to cronexpr --- README.md | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index b67cfd0..40562cf 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,5 @@ -cronexpression for Go -===================== -Cron expression parser in Go language (golang). - +Golang Cron expression parser +============================= Given a cron expression and a time stamp, you can get the next time stamp which satisfies the cron expression. In another project, I decided to use cron expression syntax to encode scheduling information. Thus this standalone library to parse and apply time stamps to cron expressions. @@ -66,41 +64,41 @@ Other details Install ------- - go get github.com/gorhill/cronexpression + go get github.com/gorhill/cronexpr Usage ----- Import the library: - import "github.com/gorhill/cronexpression" + import "github.com/gorhill/cronexpr" import "time" Simplest way: - nextTime := cronexpression.Parse("0 0 29 2 *").Next(time.Now()) + nextTime := cronexpr.Parse("0 0 29 2 *").Next(time.Now()) Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". You can keep the returned Expression pointer around if you want to reuse it: - expr := cronexpression.Parse("0 0 29 2 *") + expr := cronexpr.Parse("0 0 29 2 *") nextTime := expr.Next(time.Now()) ... nextTime = expr.Next(nextTime) Use `time.IsZero()` to find out whether a valid time was returned. For example, - cronexpression.Parse("* * * * * 1980").Next(time.Now()).IsZero() + cronexpr.Parse("* * * * * 1980").Next(time.Now()).IsZero() will return `true`, whereas - cronexpression.Parse("* * * * * 2050").Next(time.Now()).IsZero() + cronexpr.Parse("* * * * * 2050").Next(time.Now()).IsZero() will return `false` (as of 2013-08-29...) You may also query for `n` next time stamps: - cronexpression.Parse("0 0 29 2 *").NextN(time.Now(), 5) + cronexpr.Parse("0 0 29 2 *").NextN(time.Now(), 5) which returns a slice of time.Time objects, containing the following time stamps (as of 2013-08-30): @@ -112,4 +110,4 @@ which returns a slice of time.Time objects, containing the following time stamps API --- - + From 2594aadb14be86d17cc156ffdeef8d58f7c9bc98 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 09:05:45 -0400 Subject: [PATCH 063/105] fleshing out doc --- cronexpr.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/cronexpr.go b/cronexpr.go index 5909aa1..2cca953 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -45,9 +45,10 @@ type Expression struct { /******************************************************************************/ -// Parse() returns a new Expression pointer. It expects -// a well-formed cron expression. If a malformed cron expression is -// supplied, the result is undefined. +// Returns a new Expression pointer. It expects a well-formed cron expression. +// If a malformed cron expression is supplied, the result is undefined. See +// for documentation +// about what is a well-formed cron expression from this library point of view. func Parse(cronLine string) *Expression { cronLineNormalized := cronNormalize(cronLine) From 5c3ec34a8d4cede756d1ac1bd965aae7d147e58c Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 09:07:23 -0400 Subject: [PATCH 064/105] fleshing out doc --- cronexpr.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cronexpr.go b/cronexpr.go index 2cca953..0af7247 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -23,8 +23,8 @@ import ( /******************************************************************************/ -// A Expression represents a specific cron time expression as defined on -// Wikipedia: https://en.wikipedia.org/wiki/Cron#CRON_expression +// A Expression represents a specific cron time expression as defined at +// type Expression struct { expression string secondList []int From 68fd2b282b3d533d323f316d100490d84e1083fd Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 13:08:04 -0400 Subject: [PATCH 065/105] fixed time zone bug --- cronexpr.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cronexpr.go b/cronexpr.go index 0af7247..c5c417e 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -232,7 +232,7 @@ func (expr *Expression) nextYear(t time.Time) time.Time { expr.minuteList[0], expr.secondList[0], 0, - time.Local)) + t.Location())) } return time.Date( expr.yearList[i], @@ -242,7 +242,7 @@ func (expr *Expression) nextYear(t time.Time) time.Time { expr.minuteList[0], expr.secondList[0], 0, - time.Local) + t.Location()) } /******************************************************************************/ @@ -265,7 +265,7 @@ func (expr *Expression) nextMonth(t time.Time) time.Time { expr.minuteList[0], expr.secondList[0], 0, - time.Local)) + t.Location())) } return time.Date( @@ -276,7 +276,7 @@ func (expr *Expression) nextMonth(t time.Time) time.Time { expr.minuteList[0], expr.secondList[0], 0, - time.Local) + t.Location()) } /******************************************************************************/ From dc9d12775f339e85dda3121047afa7e91f94933a Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 14:57:24 -0400 Subject: [PATCH 066/105] reference to companion command-line utility --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 40562cf..9ab5f39 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,8 @@ In another project, I decided to use cron expression syntax to encode scheduling The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. +There is also a companion command-line utility to evaluate cron time expressions: . + Implementation -------------- The reference documentation for this implementation is found at From 1998268a1c31c54b8085bab7fac267bc1fdee57d Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 31 Aug 2013 15:05:03 -0400 Subject: [PATCH 067/105] go fmt'ed --- cronexpr_test.go | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/cronexpr_test.go b/cronexpr_test.go index da84633..e9f0e1d 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -116,8 +116,21 @@ func TestExpressions(t *testing.T) { next := cronexpr.Parse(test.expr).Next(from) nextstr := next.Format(test.layout) if nextstr != times.next { - t.Errorf("(\"%s\").Next(\"%s\") = \"%s\", got \"%s\"", test.expr, times.from, times.next, nextstr) + t.Errorf(`("%s").Next("%s") = "%s", got "%s"`, test.expr, times.from, times.next, nextstr) } } } } + +func TestZero(t *testing.T) { + from, _ := time.Parse("2006-01-02", "2013-08-31") + next := cronexpr.Parse("* * * * * 1980").Next(from) + if next.IsZero() == false { + t.Error(`("* * * * * 1980").Next("2013-08-31") returned 'false', expected 'true'`) + } + + next = cronexpr.Parse("* * * * * 2050").Next(from) + if next.IsZero() == true { + t.Error(`("* * * * * 2050").Next("2013-08-31") returned 'true', expected 'false'`) + } +} From 718fc4c0ab0ed5389c83272c0ac1c779d9ed0d8d Mon Sep 17 00:00:00 2001 From: gorhill Date: Sun, 1 Sep 2013 09:24:01 -0400 Subject: [PATCH 068/105] changes as suggested at https://groups.google.com/d/msg/golang-nuts/la6mB5xG1L4/5V0L2GqF_1oJ --- README.md | 2 +- cronexpr.go | 75 ++++++++++++++++++++++++------------------------ cronexpr_test.go | 12 ++++++-- example_test.go | 37 ++++++++++++++++++++++++ 4 files changed, 85 insertions(+), 41 deletions(-) create mode 100644 example_test.go diff --git a/README.md b/README.md index 9ab5f39..624887f 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ In another project, I decided to use cron expression syntax to encode scheduling The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. -There is also a companion command-line utility to evaluate cron time expressions: . +There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). Implementation -------------- diff --git a/cronexpr.go b/cronexpr.go index c5c417e..a3d16b3 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -45,7 +45,7 @@ type Expression struct { /******************************************************************************/ -// Returns a new Expression pointer. It expects a well-formed cron expression. +// Parse returns a new Expression pointer. It expects a well-formed cron expression. // If a malformed cron expression is supplied, the result is undefined. See // for documentation // about what is a well-formed cron expression from this library point of view. @@ -98,11 +98,14 @@ func Parse(cronLine string) *Expression { /******************************************************************************/ -// Given a time stamp `fromTime`, return the closest following time stamp which -// matches the cron expression `expr`. The `time.Location` of the returned -// time stamp is the same as `fromTime`. +// Next returns the closest time instant immediately following `fromTime` which +// matches the cron expression `expr`. // -// A nil time.Time object is returned if no matching time stamp exists. +// The `time.Location` of the returned time instant is the same as that of +// `fromTime`. +// +// The zero value of time.Time is returned if no matching time instant exists +// or if a `fromTime` is itself a zero value. func (expr *Expression) Next(fromTime time.Time) time.Time { // Special case if fromTime.IsZero() { @@ -185,29 +188,31 @@ func (expr *Expression) Next(fromTime time.Time) time.Time { /******************************************************************************/ -// Given a time stamp `fromTime`, return a slice of `n` closest following time -// stamps which match the cron expression `expr`. The time stamps in the -// returned slice are in chronological ascending order. The `time.Location` of -// the returned time stamps is the same as `fromTime`. +// NextN return a slice of `n` closest time instants immediately following +// `fromTime` which match the cron expression `expr`. // -// A slice with less than `n` entries (up to zero) is returned if not -// enough existing matching time stamps which exist. -func (expr *Expression) NextN(fromTime time.Time, n int) []time.Time { - if n <= 0 { - panic("Expression.NextN(): invalid count") - } +// The time instants in the returned slice are in chronological ascending order. +// The `time.Location` of the returned time instants is the same as that of +// `fromTime`. +// +// A slice with len between [0-`n`] is returned, that is, if not enough existing +// matching time instants exist, the number of returned entries will be less +// than `n`. +func (expr *Expression) NextN(fromTime time.Time, n uint) []time.Time { nextTimes := make([]time.Time, 0) - fromTime = expr.Next(fromTime) - for { - if fromTime.IsZero() { - break + if n > 0 { + fromTime = expr.Next(fromTime) + for { + if fromTime.IsZero() { + break + } + nextTimes = append(nextTimes, fromTime) + n -= 1 + if n == 0 { + break + } + fromTime = expr.nextSecond(fromTime) } - nextTimes = append(nextTimes, fromTime) - n -= 1 - if n == 0 { - break - } - fromTime = expr.nextSecond(fromTime) } return nextTimes } @@ -297,7 +302,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { actualDaysOfMonthMap[lastDayOfMonth] = true } // Days of month - for v, _ := range expr.daysOfMonth { + for v := range expr.daysOfMonth { // Ignore days beyond end of month if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -305,7 +310,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { } // Work days of month // As per Wikipedia: month boundaries are not crossed. - for v, _ := range expr.workdaysOfMonth { + for v := range expr.workdaysOfMonth { // Ignore days beyond end of month if v <= lastDayOfMonth { // If saturday, then friday @@ -335,7 +340,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { // offset : (7 - day_of_week_of_1st_day_of_month) // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 for w := 0; w <= 4; w += 1 { - for v, _ := range expr.daysOfWeek { + for v := range expr.daysOfWeek { v := 1 + w*7 + (offset+v)%7 if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -345,7 +350,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { // days of week of specific week in the month // offset : (7 - day_of_week_of_1st_day_of_month) // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for v, _ := range expr.specificWeekDaysOfWeek { + for v := range expr.specificWeekDaysOfWeek { v := 1 + 7*(v/7) + (offset+v)%7 if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -354,7 +359,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { // Last days of week of the month lastWeekOrigin := timeOrigin.AddDate(0, 1, -7) offset = 7 - int(lastWeekOrigin.Weekday()) - for v, _ := range expr.lastWeekDaysOfWeek { + for v := range expr.lastWeekDaysOfWeek { v := lastWeekOrigin.Day() + (offset+v)%7 if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -510,7 +515,7 @@ func cronNormalize(cronLine string) string { /******************************************************************************/ -func (expr *Expression) dayofweekFieldParse(cronField string) error { +func (expr *Expression) dayofweekFieldParse(cronField string) { // Defaults expr.daysOfWeekRestricted = true expr.lastWeekDaysOfWeek = make(map[int]bool) @@ -564,13 +569,11 @@ func (expr *Expression) dayofweekFieldParse(cronField string) error { v := atoi(s) % 7 populateOne(expr.daysOfWeek, v) } - - return nil } /******************************************************************************/ -func (expr *Expression) dayofmonthFieldParse(cronField string) error { +func (expr *Expression) dayofmonthFieldParse(cronField string) { // Defaults expr.daysOfMonthRestricted = true expr.lastDayOfMonth = false @@ -615,8 +618,6 @@ func (expr *Expression) dayofmonthFieldParse(cronField string) error { // single value populateOne(expr.daysOfMonth, atoi(s)) } - - return nil } /******************************************************************************/ @@ -691,7 +692,7 @@ func populateMany(values map[int]bool, min, max, step int) { func toList(set map[int]bool) []int { list := make([]int, len(set)) i := 0 - for k, _ := range set { + for k := range set { list[i] = k i += 1 } diff --git a/cronexpr_test.go b/cronexpr_test.go index e9f0e1d..b874480 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -13,7 +13,8 @@ package cronexpr_test /******************************************************************************/ import ( - "cronexpr" + "github.com/gorhill/cronexpr" + "testing" "time" ) @@ -126,11 +127,16 @@ func TestZero(t *testing.T) { from, _ := time.Parse("2006-01-02", "2013-08-31") next := cronexpr.Parse("* * * * * 1980").Next(from) if next.IsZero() == false { - t.Error(`("* * * * * 1980").Next("2013-08-31") returned 'false', expected 'true'`) + t.Error(`("* * * * * 1980").Next("2013-08-31").IsZero() returned 'false', expected 'true'`) } next = cronexpr.Parse("* * * * * 2050").Next(from) if next.IsZero() == true { - t.Error(`("* * * * * 2050").Next("2013-08-31") returned 'true', expected 'false'`) + t.Error(`("* * * * * 2050").Next("2013-08-31").IsZero() returned 'true', expected 'false'`) + } + + next = cronexpr.Parse("* * * * * 2099").Next(time.Time{}) + if next.IsZero() == false { + t.Error(`("* * * * * 2014").Next(time.Time{}).IsZero() returned 'true', expected 'false'`) } } diff --git a/example_test.go b/example_test.go new file mode 100644 index 0000000..ca4871a --- /dev/null +++ b/example_test.go @@ -0,0 +1,37 @@ +/*! + * Copyright 2013 Raymond Hill + * + * Project: github.com/gorhill/example_test.go + * File: example_test.go + * Version: 1.0 + * License: GPL v3 see + * + */ + +package cronexpr_test + +/******************************************************************************/ + +import ( + "github.com/gorhill/cronexpr" + + "fmt" + "time" +) + +/******************************************************************************/ + +// ExampleParse +func ExampleParse() { + t := time.Date(2013, time.August, 31, 0, 0, 0, 0, time.UTC) + nextTimes := cronexpr.Parse("0 0 29 2 *").NextN(t, 5) + for i := range nextTimes { + fmt.Println(nextTimes[i].Format(time.RFC1123)) + // Output: + // Mon, 29 Feb 2016 00:00:00 UTC + // Sat, 29 Feb 2020 00:00:00 UTC + // Thu, 29 Feb 2024 00:00:00 UTC + // Tue, 29 Feb 2028 00:00:00 UTC + // Sun, 29 Feb 2032 00:00:00 UTC + } +} From b353b8f1d8d6c14ed0cd74e3ca4e6ae5e6381b51 Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 2 Sep 2013 08:02:14 -0400 Subject: [PATCH 069/105] fixed specific weekdays of week, wasn't working --- cronexpr.go | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/cronexpr.go b/cronexpr.go index a3d16b3..62f1bc8 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -37,8 +37,8 @@ type Expression struct { actualDaysOfMonthList []int monthList []int daysOfWeek map[int]bool - specificWeekDaysOfWeek map[int]bool - lastWeekDaysOfWeek map[int]bool + specificWeekdaysOfWeek map[int]bool + lastWeekdaysOfWeek map[int]bool daysOfWeekRestricted bool yearList []int } @@ -188,7 +188,7 @@ func (expr *Expression) Next(fromTime time.Time) time.Time { /******************************************************************************/ -// NextN return a slice of `n` closest time instants immediately following +// NextN returns a slice of `n` closest time instants immediately following // `fromTime` which match the cron expression `expr`. // // The time instants in the returned slice are in chronological ascending order. @@ -350,7 +350,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { // days of week of specific week in the month // offset : (7 - day_of_week_of_1st_day_of_month) // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for v := range expr.specificWeekDaysOfWeek { + for v := range expr.specificWeekdaysOfWeek { v := 1 + 7*(v/7) + (offset+v)%7 if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -359,7 +359,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { // Last days of week of the month lastWeekOrigin := timeOrigin.AddDate(0, 1, -7) offset = 7 - int(lastWeekOrigin.Weekday()) - for v := range expr.lastWeekDaysOfWeek { + for v := range expr.lastWeekdaysOfWeek { v := lastWeekOrigin.Day() + (offset+v)%7 if v <= lastDayOfMonth { actualDaysOfMonthMap[v] = true @@ -518,8 +518,9 @@ func cronNormalize(cronLine string) string { func (expr *Expression) dayofweekFieldParse(cronField string) { // Defaults expr.daysOfWeekRestricted = true - expr.lastWeekDaysOfWeek = make(map[int]bool) expr.daysOfWeek = make(map[int]bool) + expr.lastWeekdaysOfWeek = make(map[int]bool) + expr.specificWeekdaysOfWeek = make(map[int]bool) // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" cronList := strings.Split(cronField, ",") @@ -545,7 +546,7 @@ func (expr *Expression) dayofweekFieldParse(cronField string) { // "l": week day for last week i = strings.Index(s, "l") if i >= 0 { - populateOne(expr.lastWeekDaysOfWeek, atoi(s[:i])%7) + populateOne(expr.lastWeekdaysOfWeek, atoi(s[:i])%7) continue } // "#": week day for specific week @@ -556,7 +557,7 @@ func (expr *Expression) dayofweekFieldParse(cronField string) { w := atoi(s[i+1:]) // v domain = [0,7] // w domain = [1,5] - populateOne(expr.specificWeekDaysOfWeek, (w-1)*7+(v%7)) + populateOne(expr.specificWeekdaysOfWeek, (w-1)*7+(v%7)) continue } // week day interval for all weeks From ed7ab266081ecc0f2058c9e47b70127ce9d7f048 Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 2 Sep 2013 08:05:09 -0400 Subject: [PATCH 070/105] added test for specific weekdays of week --- cronexpr_test.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/cronexpr_test.go b/cronexpr_test.go index b874480..25ec128 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -107,6 +107,15 @@ var crontests = []crontest{ }, }, + // Specific weekdays of week + { + "0 0 * * 6#5", + "Mon 2006-01-02 15:04", + []crontimes{ + {"2013-09-02 00:00:00", "Sat 2013-11-30 00:00"}, + }, + }, + // TODO: more tests } From 4f0ef128480e7d42c74aa34ea31c3ffa8d4b2516 Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 2 Sep 2013 08:39:19 -0400 Subject: [PATCH 071/105] clarification about time zones --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 624887f..23d353d 100644 --- a/README.md +++ b/README.md @@ -110,6 +110,10 @@ which returns a slice of time.Time objects, containing the following time stamps 2028-02-29 00:00:00 2032-02-29 00:00:00 +The time zone of time values returned by `Next` and `NextN` is always the +time zone of the time value passed as argument, unless zero time value is +returned. + API --- From 5442b2bfefc9644e2d05ccac4db3c64bb240b369 Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 2 Sep 2013 09:25:49 -0400 Subject: [PATCH 072/105] changes as per #5 --- README.md | 12 ++++++------ cronexpr.go | 13 +++++++------ cronexpr_test.go | 35 +++++++++++++++++++++++++++++------ example_test.go | 2 +- 4 files changed, 43 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index 23d353d..f3d4a9b 100644 --- a/README.md +++ b/README.md @@ -77,30 +77,30 @@ Import the library: Simplest way: - nextTime := cronexpr.Parse("0 0 29 2 *").Next(time.Now()) + nextTime := cronexpr.MustParse("0 0 29 2 *").Next(time.Now()) Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". You can keep the returned Expression pointer around if you want to reuse it: - expr := cronexpr.Parse("0 0 29 2 *") + expr := cronexpr.MustParse("0 0 29 2 *") nextTime := expr.Next(time.Now()) ... nextTime = expr.Next(nextTime) Use `time.IsZero()` to find out whether a valid time was returned. For example, - cronexpr.Parse("* * * * * 1980").Next(time.Now()).IsZero() + cronexpr.MustParse("* * * * * 1980").Next(time.Now()).IsZero() will return `true`, whereas - cronexpr.Parse("* * * * * 2050").Next(time.Now()).IsZero() + cronexpr.MustParse("* * * * * 2050").Next(time.Now()).IsZero() will return `false` (as of 2013-08-29...) You may also query for `n` next time stamps: - cronexpr.Parse("0 0 29 2 *").NextN(time.Now(), 5) + cronexpr.MustParse("0 0 29 2 *").NextN(time.Now(), 5) which returns a slice of time.Time objects, containing the following time stamps (as of 2013-08-30): @@ -111,7 +111,7 @@ which returns a slice of time.Time objects, containing the following time stamps 2032-02-29 00:00:00 The time zone of time values returned by `Next` and `NextN` is always the -time zone of the time value passed as argument, unless zero time value is +time zone of the time value passed as argument, unless a zero time value is returned. API diff --git a/cronexpr.go b/cronexpr.go index 62f1bc8..2fc7477 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -45,11 +45,12 @@ type Expression struct { /******************************************************************************/ -// Parse returns a new Expression pointer. It expects a well-formed cron expression. -// If a malformed cron expression is supplied, the result is undefined. See -// for documentation -// about what is a well-formed cron expression from this library point of view. -func Parse(cronLine string) *Expression { +// MustParse returns a new Expression pointer. It expects a well-formed cron +// expression. If a malformed cron expression is supplied, it will `panic`. +// See for documentation +// about what is a well-formed cron expression from this library's point of +// view. +func MustParse(cronLine string) *Expression { cronLineNormalized := cronNormalize(cronLine) // Split into fields @@ -73,7 +74,7 @@ func Parse(cronLine string) *Expression { // At this point, we should have at least 7 fields. Fields beyond the // seventh one, if any, are ignored. if len(cronFields) < 7 { - panic("Malformed cron expression\n") + panic("MustParse(): Not enough fields in the cron time expression\n") } // Generic parser can be used for most fields diff --git a/cronexpr_test.go b/cronexpr_test.go index 25ec128..1207eb3 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -13,10 +13,10 @@ package cronexpr_test /******************************************************************************/ import ( - "github.com/gorhill/cronexpr" - "testing" "time" + + "github.com/gorhill/cronexpr" ) /******************************************************************************/ @@ -123,7 +123,7 @@ func TestExpressions(t *testing.T) { for _, test := range crontests { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) - next := cronexpr.Parse(test.expr).Next(from) + next := cronexpr.MustParse(test.expr).Next(from) nextstr := next.Format(test.layout) if nextstr != times.next { t.Errorf(`("%s").Next("%s") = "%s", got "%s"`, test.expr, times.from, times.next, nextstr) @@ -134,18 +134,41 @@ func TestExpressions(t *testing.T) { func TestZero(t *testing.T) { from, _ := time.Parse("2006-01-02", "2013-08-31") - next := cronexpr.Parse("* * * * * 1980").Next(from) + next := cronexpr.MustParse("* * * * * 1980").Next(from) if next.IsZero() == false { t.Error(`("* * * * * 1980").Next("2013-08-31").IsZero() returned 'false', expected 'true'`) } - next = cronexpr.Parse("* * * * * 2050").Next(from) + next = cronexpr.MustParse("* * * * * 2050").Next(from) if next.IsZero() == true { t.Error(`("* * * * * 2050").Next("2013-08-31").IsZero() returned 'true', expected 'false'`) } - next = cronexpr.Parse("* * * * * 2099").Next(time.Time{}) + next = cronexpr.MustParse("* * * * * 2099").Next(time.Time{}) if next.IsZero() == false { t.Error(`("* * * * * 2014").Next(time.Time{}).IsZero() returned 'true', expected 'false'`) } } + +func TestNextN(t *testing.T) { + expected := []string{ + "Sat, 30 Nov 2013 00:00:00", + "Sat, 29 Mar 2014 00:00:00", + "Sat, 31 May 2014 00:00:00", + "Sat, 30 Aug 2014 00:00:00", + "Sat, 29 Nov 2014 00:00:00", + } + from, _ := time.Parse("2006-01-02 15:04:05", "2013-09-02 08:44:30") + result := cronexpr.MustParse("0 0 * * 6#5").NextN(from, uint(len(expected))) + if len(result) != len(expected) { + t.Errorf(`MustParse("0 0 * * 6#5").NextN("2013-09-02 08:44:30", 5):\n"`) + t.Errorf(` Expected %d returned time values but got %d instead`, len(expected), len(result)) + } + for i, next := range result { + nextStr := next.Format("Mon, 2 Jan 2006 15:04:15") + if nextStr != expected[i] { + t.Errorf(`MustParse("0 0 * * 6#5").NextN("2013-09-02 08:44:30", 5):\n"`) + t.Errorf(` result[%d]: expected "%s" but got "%s"`, i, expected[i], nextStr) + } + } +} diff --git a/example_test.go b/example_test.go index ca4871a..38fa2ea 100644 --- a/example_test.go +++ b/example_test.go @@ -24,7 +24,7 @@ import ( // ExampleParse func ExampleParse() { t := time.Date(2013, time.August, 31, 0, 0, 0, 0, time.UTC) - nextTimes := cronexpr.Parse("0 0 29 2 *").NextN(t, 5) + nextTimes := cronexpr.MustParse("0 0 29 2 *").NextN(t, 5) for i := range nextTimes { fmt.Println(nextTimes[i].Format(time.RFC1123)) // Output: From 164843d2d0d093add27367db8a49bed85db56d33 Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 2 Sep 2013 10:34:47 -0400 Subject: [PATCH 073/105] added benchmarking, as per #5 --- cronexpr_test.go | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/cronexpr_test.go b/cronexpr_test.go index 1207eb3..9fbe49c 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -132,6 +132,8 @@ func TestExpressions(t *testing.T) { } } +/******************************************************************************/ + func TestZero(t *testing.T) { from, _ := time.Parse("2006-01-02", "2013-08-31") next := cronexpr.MustParse("* * * * * 1980").Next(from) @@ -150,6 +152,8 @@ func TestZero(t *testing.T) { } } +/******************************************************************************/ + func TestNextN(t *testing.T) { expected := []string{ "Sat, 30 Nov 2013 00:00:00", @@ -172,3 +176,39 @@ func TestNextN(t *testing.T) { } } } + +/******************************************************************************/ + +var benchmarkExpressions = []string{ + "* * * * *", + "@hourly", + "@weekly", + "@yearly", + "30 3 15W 3/3 *", + "30 0 0 1-31/5 Oct-Dec * 2000,2006,2008,2013-2015", + "0 0 0 * Feb-Nov/2 thu#3 2000-2050", +} +var benchmarkExpressionsLen = len(benchmarkExpressions) + +func BenchmarkParse(b *testing.B) { + for i := 0; i < b.N; i++ { + _ = cronexpr.MustParse(benchmarkExpressions[i%benchmarkExpressionsLen]) + } +} + +func BenchmarkNext(b *testing.B) { + exprs := make([]*cronexpr.Expression, benchmarkExpressionsLen) + for i := 0; i < benchmarkExpressionsLen; i++ { + exprs[i] = cronexpr.MustParse(benchmarkExpressions[i]) + } + from := time.Now() + b.ResetTimer() + for i := 0; i < b.N; i++ { + expr := exprs[i%benchmarkExpressionsLen] + next := expr.Next(from) + next = expr.Next(next) + next = expr.Next(next) + next = expr.Next(next) + next = expr.Next(next) + } +} From 662c567db40a958ce866631d08da0b860f427056 Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 2 Sep 2013 16:03:21 -0400 Subject: [PATCH 074/105] fixed borken example --- example_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/example_test.go b/example_test.go index 38fa2ea..3dc27d0 100644 --- a/example_test.go +++ b/example_test.go @@ -13,16 +13,16 @@ package cronexpr_test /******************************************************************************/ import ( - "github.com/gorhill/cronexpr" - "fmt" "time" + + "github.com/gorhill/cronexpr" ) /******************************************************************************/ -// ExampleParse -func ExampleParse() { +// ExampleMustParse +func ExampleMustParse() { t := time.Date(2013, time.August, 31, 0, 0, 0, 0, time.UTC) nextTimes := cronexpr.MustParse("0 0 29 2 *").NextN(t, 5) for i := range nextTimes { From e869d999cfed65828e8ccba2c804c0be6f9cf3f1 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 7 Sep 2013 14:02:17 -0400 Subject: [PATCH 075/105] issues #1, #3, #5, #6 --- cronexpr.go | 611 ++++++--------------------------------- cronexpr_impl.go | 739 +++++++++++++++++++++++++++++++++++++++++++++++ cronexpr_test.go | 51 +++- 3 files changed, 872 insertions(+), 529 deletions(-) create mode 100644 cronexpr_impl.go diff --git a/cronexpr.go b/cronexpr.go index 2fc7477..94cbf59 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -14,10 +14,8 @@ package cronexpr /******************************************************************************/ import ( - "regexp" + "fmt" "sort" - "strconv" - "strings" "time" ) @@ -33,12 +31,13 @@ type Expression struct { daysOfMonth map[int]bool workdaysOfMonth map[int]bool lastDayOfMonth bool + lastWorkdayOfMonth bool daysOfMonthRestricted bool actualDaysOfMonthList []int monthList []int daysOfWeek map[int]bool - specificWeekdaysOfWeek map[int]bool - lastWeekdaysOfWeek map[int]bool + specificWeekDaysOfWeek map[int]bool + lastWeekDaysOfWeek map[int]bool daysOfWeekRestricted bool yearList []int } @@ -51,50 +50,90 @@ type Expression struct { // about what is a well-formed cron expression from this library's point of // view. func MustParse(cronLine string) *Expression { - cronLineNormalized := cronNormalize(cronLine) - - // Split into fields - cronFields := regexp.MustCompile(`\s+`).Split(cronLineNormalized, -1) - - // Our cron expression parser expects 7 fields: - // second minute hour dayofmonth month dayofweek year - // Standard cron is 6 fields with year field being optional - // minute hour dayofmonth month dayofweek {year} - // Thus... - // If we have 5 fields, append wildcard year field - if len(cronFields) < 6 { - cronFields = append(cronFields, "*") + expr, err := Parse(cronLine) + if err != nil { + panic(err) } - // If we have 6 fields, prepend match-once second field - if len(cronFields) < 7 { - cronFields = append(cronFields, "") - copy(cronFields[1:], cronFields[0:]) - cronFields[0] = "0" - } - // At this point, we should have at least 7 fields. Fields beyond the - // seventh one, if any, are ignored. - if len(cronFields) < 7 { - panic("MustParse(): Not enough fields in the cron time expression\n") + return expr +} + +/******************************************************************************/ + +// Parse returns a new Expression pointer. An error is returned if a malformed +// cron expression is supplied. +// See for documentation +// about what is a well-formed cron expression from this library's point of +// view. +func Parse(cronLine string) (*Expression, error) { + + // Maybe one of the built-in aliases is being used + cron := cronNormalizer.Replace(cronLine) + + indices := fieldFinder.FindAllStringIndex(cron, -1) + if len(indices) < 5 { + return nil, fmt.Errorf("Missing field(s)") } - // Generic parser can be used for most fields - cronExpr := &Expression{ - expression: cronLine, - secondList: genericFieldParse(cronFields[0], 0, 59), - minuteList: genericFieldParse(cronFields[1], 0, 59), - hourList: genericFieldParse(cronFields[2], 0, 23), - monthList: genericFieldParse(cronFields[4], 1, 12), - yearList: genericFieldParse(cronFields[6], 1970, 2099), + expr := Expression{} + field := 0 + + // second field (optional) + if len(indices) >= 7 { + err := expr.secondFieldHandler(cron[indices[field][0]:indices[field][1]]) + if err != nil { + return nil, err + } + field += 1 + } else { + expr.secondList = []int{0} } - // Days of month/days of week is a bit more complicated, due - // to their extended syntax, and the fact that days per - // month is a variable quantity, and relation between - // days of week and days of month depends on the month/year. - cronExpr.dayofmonthFieldParse(cronFields[3]) - cronExpr.dayofweekFieldParse(cronFields[5]) + // minute field + err := expr.minuteFieldHandler(cron[indices[field][0]:indices[field][1]]) + if err != nil { + return nil, err + } + field += 1 - return cronExpr + // hour field + err = expr.hourFieldHandler(cron[indices[field][0]:indices[field][1]]) + if err != nil { + return nil, err + } + field += 1 + + // day of month field + err = expr.domFieldHandler(cron[indices[field][0]:indices[field][1]]) + if err != nil { + return nil, err + } + field += 1 + + // month field + err = expr.monthFieldHandler(cron[indices[field][0]:indices[field][1]]) + if err != nil { + return nil, err + } + field += 1 + + // day of week field + err = expr.dowFieldHandler(cron[indices[field][0]:indices[field][1]]) + if err != nil { + return nil, err + } + field += 1 + + // year field + if field < len(indices) { + err = expr.yearFieldHandler(cron[indices[field][0]:indices[field][1]]) + if err != nil { + return nil, err + } + } else { + expr.yearList = yearDescriptor.defaultList + } + + return &expr, nil } /******************************************************************************/ @@ -200,7 +239,7 @@ func (expr *Expression) Next(fromTime time.Time) time.Time { // matching time instants exist, the number of returned entries will be less // than `n`. func (expr *Expression) NextN(fromTime time.Time, n uint) []time.Time { - nextTimes := make([]time.Time, 0) + nextTimes := make([]time.Time, 0, n) if n > 0 { fromTime = expr.Next(fromTime) for { @@ -217,487 +256,3 @@ func (expr *Expression) NextN(fromTime time.Time, n uint) []time.Time { } return nextTimes } - -/******************************************************************************/ - -func (expr *Expression) nextYear(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate year - i := sort.SearchInts(expr.yearList, t.Year()+1) - if i == len(expr.yearList) { - return time.Time{} - } - // Year changed, need to recalculate actual days of month - expr.actualDaysOfMonthList = expr.calculateActualDaysOfMonth(expr.yearList[i], expr.monthList[0]) - if len(expr.actualDaysOfMonthList) == 0 { - return expr.nextMonth(time.Date( - expr.yearList[i], - time.Month(expr.monthList[0]), - 1, - expr.hourList[0], - expr.minuteList[0], - expr.secondList[0], - 0, - t.Location())) - } - return time.Date( - expr.yearList[i], - time.Month(expr.monthList[0]), - expr.actualDaysOfMonthList[0], - expr.hourList[0], - expr.minuteList[0], - expr.secondList[0], - 0, - t.Location()) -} - -/******************************************************************************/ - -func (expr *Expression) nextMonth(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate month - i := sort.SearchInts(expr.monthList, int(t.Month())+1) - if i == len(expr.monthList) { - return expr.nextYear(t) - } - // Month changed, need to recalculate actual days of month - expr.actualDaysOfMonthList = expr.calculateActualDaysOfMonth(t.Year(), expr.monthList[i]) - if len(expr.actualDaysOfMonthList) == 0 { - return expr.nextMonth(time.Date( - t.Year(), - time.Month(expr.monthList[i]), - 1, - expr.hourList[0], - expr.minuteList[0], - expr.secondList[0], - 0, - t.Location())) - } - - return time.Date( - t.Year(), - time.Month(expr.monthList[i]), - expr.actualDaysOfMonthList[0], - expr.hourList[0], - expr.minuteList[0], - expr.secondList[0], - 0, - t.Location()) -} - -/******************************************************************************/ - -func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { - actualDaysOfMonthMap := make(map[int]bool) - timeOrigin := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) - lastDayOfMonth := timeOrigin.AddDate(0, 1, -1).Day() - - // As per crontab man page (http://linux.die.net/man/5/crontab#): - // "The day of a command's execution can be specified by two - // "fields - day of month, and day of week. If both fields are - // "restricted (ie, aren't *), the command will be run when - // "either field matches the current time" - if expr.daysOfMonthRestricted || expr.daysOfWeekRestricted == false { - // Last day of month - if expr.lastDayOfMonth { - actualDaysOfMonthMap[lastDayOfMonth] = true - } - // Days of month - for v := range expr.daysOfMonth { - // Ignore days beyond end of month - if v <= lastDayOfMonth { - actualDaysOfMonthMap[v] = true - } - } - // Work days of month - // As per Wikipedia: month boundaries are not crossed. - for v := range expr.workdaysOfMonth { - // Ignore days beyond end of month - if v <= lastDayOfMonth { - // If saturday, then friday - if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Saturday { - if v > 1 { - v -= 1 - } else { - v += 2 - } - // If sunday, then monday - } else if timeOrigin.AddDate(0, 0, v-1).Weekday() == time.Sunday { - if v < lastDayOfMonth { - v += 1 - } else { - v -= 2 - } - } - actualDaysOfMonthMap[v] = true - } - } - } - - if expr.daysOfWeekRestricted { - // How far first sunday is from first day of month - offset := 7 - int(timeOrigin.Weekday()) - // days of week - // offset : (7 - day_of_week_of_1st_day_of_month) - // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for w := 0; w <= 4; w += 1 { - for v := range expr.daysOfWeek { - v := 1 + w*7 + (offset+v)%7 - if v <= lastDayOfMonth { - actualDaysOfMonthMap[v] = true - } - } - } - // days of week of specific week in the month - // offset : (7 - day_of_week_of_1st_day_of_month) - // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for v := range expr.specificWeekdaysOfWeek { - v := 1 + 7*(v/7) + (offset+v)%7 - if v <= lastDayOfMonth { - actualDaysOfMonthMap[v] = true - } - } - // Last days of week of the month - lastWeekOrigin := timeOrigin.AddDate(0, 1, -7) - offset = 7 - int(lastWeekOrigin.Weekday()) - for v := range expr.lastWeekdaysOfWeek { - v := lastWeekOrigin.Day() + (offset+v)%7 - if v <= lastDayOfMonth { - actualDaysOfMonthMap[v] = true - } - } - } - - return toList(actualDaysOfMonthMap) -} - -/******************************************************************************/ - -func (expr *Expression) nextDayOfMonth(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate day of month - i := sort.SearchInts(expr.actualDaysOfMonthList, t.Day()+1) - if i == len(expr.actualDaysOfMonthList) { - return expr.nextMonth(t) - } - - return time.Date( - t.Year(), - t.Month(), - expr.actualDaysOfMonthList[i], - expr.hourList[0], - expr.minuteList[0], - expr.secondList[0], - 0, - t.Location()) -} - -/******************************************************************************/ - -func (expr *Expression) nextHour(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate hour - i := sort.SearchInts(expr.hourList, t.Hour()+1) - if i == len(expr.hourList) { - return expr.nextDayOfMonth(t) - } - - return time.Date( - t.Year(), - t.Month(), - t.Day(), - expr.hourList[i], - expr.minuteList[0], - expr.secondList[0], - 0, - t.Location()) -} - -/******************************************************************************/ - -func (expr *Expression) nextMinute(t time.Time) time.Time { - // Find index at which item in list is greater or equal to - // candidate minute - i := sort.SearchInts(expr.minuteList, t.Minute()+1) - if i == len(expr.minuteList) { - return expr.nextHour(t) - } - - return time.Date( - t.Year(), - t.Month(), - t.Day(), - t.Hour(), - expr.minuteList[i], - expr.secondList[0], - 0, - t.Location()) -} - -/******************************************************************************/ - -func (expr *Expression) nextSecond(t time.Time) time.Time { - // nextSecond() assumes all other fields are exactly matched - // to the cron expression - - // Find index at which item in list is greater or equal to - // candidate second - i := sort.SearchInts(expr.secondList, t.Second()+1) - if i == len(expr.secondList) { - return expr.nextMinute(t) - } - - return time.Date( - t.Year(), - t.Month(), - t.Day(), - t.Hour(), - t.Minute(), - expr.secondList[i], - 0, - t.Location()) -} - -/******************************************************************************/ - -var cronNormalizer = strings.NewReplacer( - // Order is important! - "@yearly", "0 0 0 1 1 * *", - "@annually", "0 0 0 1 1 * *", - "@monthly", "0 0 0 1 * * *", - "@weekly", "0 0 0 * * 0 *", - "@daily", "0 0 0 * * * *", - "@hourly", "0 0 * * * * *", - "january", "1", - "february", "2", - "march", "3", - "april", "4", - "may", "5", - "june", "6", - "july", "7", - "august", "8", - "september", "9", - "october", "0", - "november", "1", - "december", "2", - "sunday", "0", - "monday", "1", - "tuesday", "2", - "wednesday", "3", - "thursday", "4", - "friday", "5", - "saturday", "6", - "jan", "1", - "feb", "2", - "mar", "3", - "apr", "4", - "jun", "6", - "jul", "7", - "aug", "8", - "sep", "9", - "oct", "10", - "nov", "11", - "dec", "12", - "sun", "0", - "mon", "1", - "tue", "2", - "wed", "3", - "thu", "4", - "fri", "5", - "sat", "6", - "?", "*") - -func cronNormalize(cronLine string) string { - cronLine = strings.TrimSpace(cronLine) - cronLine = strings.ToLower(cronLine) - cronLine = cronNormalizer.Replace(cronLine) - return cronLine -} - -/******************************************************************************/ - -func (expr *Expression) dayofweekFieldParse(cronField string) { - // Defaults - expr.daysOfWeekRestricted = true - expr.daysOfWeek = make(map[int]bool) - expr.lastWeekdaysOfWeek = make(map[int]bool) - expr.specificWeekdaysOfWeek = make(map[int]bool) - - // "You can also mix all of the above, as in: 1-5,10,12,20-30/5" - cronList := strings.Split(cronField, ",") - for _, s := range cronList { - // "/" - step, s := extractInterval(s) - // "*" - if s == "*" { - expr.daysOfWeekRestricted = (step > 1) - populateMany(expr.daysOfWeek, 0, 6, step) - continue - } - // "-" - // week day interval for all weeks - i := strings.Index(s, "-") - if i >= 0 { - min := atoi(s[:i]) % 7 - max := atoi(s[i+1:]) % 7 - populateMany(expr.daysOfWeek, min, max, step) - continue - } - // single value - // "l": week day for last week - i = strings.Index(s, "l") - if i >= 0 { - populateOne(expr.lastWeekdaysOfWeek, atoi(s[:i])%7) - continue - } - // "#": week day for specific week - i = strings.Index(s, "#") - if i >= 0 { - // v#w - v := atoi(s[:i]) % 7 - w := atoi(s[i+1:]) - // v domain = [0,7] - // w domain = [1,5] - populateOne(expr.specificWeekdaysOfWeek, (w-1)*7+(v%7)) - continue - } - // week day interval for all weeks - if step > 0 { - v := atoi(s) % 7 - populateMany(expr.daysOfWeek, v, 6, step) - continue - } - // single week day for all weeks - v := atoi(s) % 7 - populateOne(expr.daysOfWeek, v) - } -} - -/******************************************************************************/ - -func (expr *Expression) dayofmonthFieldParse(cronField string) { - // Defaults - expr.daysOfMonthRestricted = true - expr.lastDayOfMonth = false - - expr.daysOfMonth = make(map[int]bool) // days of month map - expr.workdaysOfMonth = make(map[int]bool) // work day of month map - - // Comma separator is used to mix different allowed syntax - cronList := strings.Split(cronField, ",") - for _, s := range cronList { - // "/" - step, s := extractInterval(s) - // "*" - if s == "*" { - expr.daysOfMonthRestricted = (step > 1) - populateMany(expr.daysOfMonth, 1, 31, step) - continue - } - // "-" - i := strings.Index(s, "-") - if i >= 0 { - populateMany(expr.daysOfMonth, atoi(s[:i]), atoi(s[i+1:]), step) - continue - } - // single value - // "l": last day of month - if s == "l" { - expr.lastDayOfMonth = true - continue - } - // "w": week day - i = strings.Index(s, "w") - if i >= 0 { - populateOne(expr.workdaysOfMonth, atoi(s[:i])) - continue - } - // single value with interval - if step > 0 { - populateMany(expr.daysOfMonth, atoi(s), 31, step) - continue - } - // single value - populateOne(expr.daysOfMonth, atoi(s)) - } -} - -/******************************************************************************/ - -func genericFieldParse(cronField string, min, max int) []int { - // Defaults - values := make(map[int]bool) - - // Comma separator is used to mix different allowed syntax - cronList := strings.Split(cronField, ",") - for _, s := range cronList { - // "/" - step, s := extractInterval(s) - // "*" - if s == "*" { - populateMany(values, min, max, step) - continue - } - // "-" - i := strings.Index(s, "-") - if i >= 0 { - populateMany(values, atoi(s[:i]), atoi(s[i+1:]), step) - continue - } - // single value with interval - if step > 0 { - populateMany(values, atoi(s), max, step) - continue - } - // single value - populateOne(values, atoi(s)) - } - - return toList(values) -} - -/******************************************************************************/ - -// Local helpers - -func extractInterval(s string) (int, string) { - step := 0 - i := strings.Index(s, "/") - if i >= 0 { - step = atoi(s[i+1:]) - s = s[:i] - } - return step, s -} - -func atoi(s string) int { - v, err := strconv.Atoi(s) - if err != nil { - panic(err) - } - return v -} - -func populateOne(values map[int]bool, v int) { - values[v] = true -} - -func populateMany(values map[int]bool, min, max, step int) { - if step == 0 { - step = 1 - } - for i := min; i <= max; i += step { - values[i] = true - } -} - -func toList(set map[int]bool) []int { - list := make([]int, len(set)) - i := 0 - for k := range set { - list[i] = k - i += 1 - } - sort.Ints(list) - return list -} diff --git a/cronexpr_impl.go b/cronexpr_impl.go new file mode 100644 index 0000000..3ca2e82 --- /dev/null +++ b/cronexpr_impl.go @@ -0,0 +1,739 @@ +/*! + * Copyright 2013 Raymond Hill + * + * Project: github.com/gorhill/cronexpr + * File: cronexpr_impl.go + * Version: 1.0 + * License: GPL v3 see + * + */ + +package cronexpr + +/******************************************************************************/ + +import ( + "fmt" + "regexp" + "sort" + "strings" + "time" +) + +/******************************************************************************/ + +var ( + genericDefaultList []int = []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + } + yearDefaultList []int = []int{ + 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, + 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, + 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, + 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, + 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, + 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, + 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, + 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, + 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, + 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, + 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, + 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, + } +) + +/******************************************************************************/ + +var ( + numberTokens map[string]int = map[string]int{ + "0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, + "10": 10, "11": 11, "12": 12, "13": 13, "14": 14, "15": 15, "16": 16, "17": 17, "18": 18, "19": 19, + "20": 20, "21": 21, "22": 22, "23": 23, "24": 24, "25": 25, "26": 26, "27": 27, "28": 28, "29": 29, + "30": 30, "31": 31, "32": 32, "33": 33, "34": 34, "35": 35, "36": 36, "37": 37, "38": 38, "39": 39, + "40": 40, "41": 41, "42": 42, "43": 43, "44": 44, "45": 45, "46": 46, "47": 47, "48": 48, "49": 49, + "50": 50, "51": 51, "52": 52, "53": 53, "54": 54, "55": 55, "56": 56, "57": 57, "58": 58, "59": 59, + "1970": 1970, "1971": 1971, "1972": 1972, "1973": 1973, "1974": 1974, "1975": 1975, "1976": 1976, "1977": 1977, "1978": 1978, "1979": 1979, + "1980": 1980, "1981": 1981, "1982": 1982, "1983": 1983, "1984": 1984, "1985": 1985, "1986": 1986, "1987": 1987, "1988": 1988, "1989": 1989, + "1990": 1990, "1991": 1991, "1992": 1992, "1993": 1993, "1994": 1994, "1995": 1995, "1996": 1996, "1997": 1997, "1998": 1998, "1999": 1999, + "2000": 2000, "2001": 2001, "2002": 2002, "2003": 2003, "2004": 2004, "2005": 2005, "2006": 2006, "2007": 2007, "2008": 2008, "2009": 2009, + "2010": 2010, "2011": 2011, "2012": 2012, "2013": 2013, "2014": 2014, "2015": 2015, "2016": 2016, "2017": 2017, "2018": 2018, "2019": 2019, + "2020": 2020, "2021": 2021, "2022": 2022, "2023": 2023, "2024": 2024, "2025": 2025, "2026": 2026, "2027": 2027, "2028": 2028, "2029": 2029, + "2030": 2030, "2031": 2031, "2032": 2032, "2033": 2033, "2034": 2034, "2035": 2035, "2036": 2036, "2037": 2037, "2038": 2038, "2039": 2039, + "2040": 2040, "2041": 2041, "2042": 2042, "2043": 2043, "2044": 2044, "2045": 2045, "2046": 2046, "2047": 2047, "2048": 2048, "2049": 2049, + "2050": 2050, "2051": 2051, "2052": 2052, "2053": 2053, "2054": 2054, "2055": 2055, "2056": 2056, "2057": 2057, "2058": 2058, "2059": 2059, + "2060": 2060, "2061": 2061, "2062": 2062, "2063": 2063, "2064": 2064, "2065": 2065, "2066": 2066, "2067": 2067, "2068": 2068, "2069": 2069, + "2070": 2070, "2071": 2071, "2072": 2072, "2073": 2073, "2074": 2074, "2075": 2075, "2076": 2076, "2077": 2077, "2078": 2078, "2079": 2079, + "2080": 2080, "2081": 2081, "2082": 2082, "2083": 2083, "2084": 2084, "2085": 2085, "2086": 2086, "2087": 2087, "2088": 2088, "2089": 2089, + "2090": 2090, "2091": 2091, "2092": 2092, "2093": 2093, "2094": 2094, "2095": 2095, "2096": 2096, "2097": 2097, "2098": 2098, "2099": 2099, + } + monthTokens map[string]int = map[string]int{ + `1`: 1, `jan`: 1, `january`: 1, + `2`: 2, `feb`: 2, `february`: 2, + `3`: 3, `mar`: 3, `march`: 3, + `4`: 4, `apr`: 4, `april`: 4, + `5`: 5, `may`: 5, + `6`: 6, `jun`: 6, `june`: 6, + `7`: 7, `jul`: 7, `july`: 7, + `8`: 8, `aug`: 8, `august`: 8, + `9`: 9, `sep`: 9, `september`: 9, + `10`: 10, `oct`: 10, `october`: 10, + `11`: 11, `nov`: 11, `november`: 11, + `12`: 12, `dec`: 12, `december`: 12, + } + dowTokens map[string]int = map[string]int{ + `0`: 0, `sun`: 0, `sunday`: 0, + `1`: 1, `mon`: 1, `monday`: 1, + `2`: 2, `tue`: 2, `tuesday`: 2, + `3`: 3, `wed`: 3, `wednesday`: 3, + `4`: 4, `thu`: 4, `thursday`: 4, + `5`: 5, `fri`: 5, `friday`: 5, + `6`: 6, `sat`: 6, `saturday`: 6, + `7`: 0, + } +) + +/******************************************************************************/ + +func atoi(s string) int { + return numberTokens[s] +} + +type fieldDescriptor struct { + name string + min, max int + defaultList []int + valuePattern string + atoi func(string) int +} + +var ( + secondDescriptor fieldDescriptor = fieldDescriptor{ + name: "second", + min: 0, + max: 59, + defaultList: genericDefaultList[0:60], + valuePattern: `[0-9]|[1-5][0-9]`, + atoi: atoi, + } + minuteDescriptor fieldDescriptor = fieldDescriptor{ + name: "minute", + min: 0, + max: 59, + defaultList: genericDefaultList[0:60], + valuePattern: `[0-9]|[1-5][0-9]`, + atoi: atoi, + } + hourDescriptor fieldDescriptor = fieldDescriptor{ + name: "hour", + min: 0, + max: 23, + defaultList: genericDefaultList[0:24], + valuePattern: `[0-9]|1[0-9]|2[0-3]`, + atoi: atoi, + } + domDescriptor fieldDescriptor = fieldDescriptor{ + name: "day-of-month", + min: 1, + max: 31, + defaultList: genericDefaultList[1:32], + valuePattern: `[1-9]|[12][0-9]|3[01]`, + atoi: atoi, + } + monthDescriptor fieldDescriptor = fieldDescriptor{ + name: "month", + min: 1, + max: 12, + defaultList: genericDefaultList[1:13], + valuePattern: `[1-9]|1[012]|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|january|february|march|april|march|april|june|july|august|september|october|november|december`, + atoi: func(s string) int { + return monthTokens[s] + }, + } + dowDescriptor fieldDescriptor = fieldDescriptor{ + name: "day-of-week", + min: 0, + max: 6, + defaultList: genericDefaultList[0:7], + valuePattern: `[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday`, + atoi: func(s string) int { + return dowTokens[s] + }, + } + yearDescriptor fieldDescriptor = fieldDescriptor{ + name: "year", + min: 1970, + max: 2099, + defaultList: yearDefaultList[:], + valuePattern: `19[789][0-9]|20[0-9]{2}`, + atoi: atoi, + } +) + +/******************************************************************************/ + +var ( + layoutDomValue string = `[1-9]|[12][0-9]|3[01]` + layoutDowValue string = `[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday` + layoutWildcard string = `^\*|\?$` + layoutValue string = `^(%value%)$` + layoutRange string = `^(%value%)-(%value%)$` + layoutWildcardAndInterval string = `^\*/(\d+)$` + layoutValueAndInterval string = `^(%value%)/(\d+)$` + layoutRangeAndInterval string = `^(%value%)-(%value%)/(\d+)$` + layoutLastDom string = `^l$` + layoutWorkdom string = `^(%value%)w$` + layoutLastWorkdom string = `^lw$` + layoutDowOfLastWeek string = `^(%value%)l$` + layoutDowOfSpecificWeek string = `^(%value%)#(\d+)$` + + layoutRegexp map[string]*regexp.Regexp = make(map[string]*regexp.Regexp) + fieldFinder *regexp.Regexp = regexp.MustCompile(`\S+`) + entryFinder *regexp.Regexp = regexp.MustCompile(`[^,]+`) +) + +/******************************************************************************/ + +var cronNormalizer = strings.NewReplacer( + "@yearly", "0 0 0 1 1 * *", + "@annually", "0 0 0 1 1 * *", + "@monthly", "0 0 0 1 * * *", + "@weekly", "0 0 0 * * 0 *", + "@daily", "0 0 0 * * * *", + "@hourly", "0 0 * * * * *") + +/******************************************************************************/ + +func (expr *Expression) nextYear(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate year + i := sort.SearchInts(expr.yearList, t.Year()+1) + if i == len(expr.yearList) { + return time.Time{} + } + // Year changed, need to recalculate actual days of month + expr.actualDaysOfMonthList = expr.calculateActualDaysOfMonth(expr.yearList[i], expr.monthList[0]) + if len(expr.actualDaysOfMonthList) == 0 { + return expr.nextMonth(time.Date( + expr.yearList[i], + time.Month(expr.monthList[0]), + 1, + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], + 0, + t.Location())) + } + return time.Date( + expr.yearList[i], + time.Month(expr.monthList[0]), + expr.actualDaysOfMonthList[0], + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (expr *Expression) nextMonth(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate month + i := sort.SearchInts(expr.monthList, int(t.Month())+1) + if i == len(expr.monthList) { + return expr.nextYear(t) + } + // Month changed, need to recalculate actual days of month + expr.actualDaysOfMonthList = expr.calculateActualDaysOfMonth(t.Year(), expr.monthList[i]) + if len(expr.actualDaysOfMonthList) == 0 { + return expr.nextMonth(time.Date( + t.Year(), + time.Month(expr.monthList[i]), + 1, + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], + 0, + t.Location())) + } + + return time.Date( + t.Year(), + time.Month(expr.monthList[i]), + expr.actualDaysOfMonthList[0], + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func workdayOfMonth(targetDom, lastDom time.Time) int { + dom := targetDom.Day() + dow := targetDom.Weekday() + // If saturday, then friday + if dow == time.Saturday { + if dom > 1 { + dom -= 1 + } else { + dom += 2 + } + // If sunday, then monday + } else if dow == time.Sunday { + if dom < lastDom.Day() { + dom += 1 + } else { + dom -= 2 + } + } + return dom +} + +func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { + actualDaysOfMonthMap := make(map[int]bool) + firstDayOfMonth := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) + lastDayOfMonth := firstDayOfMonth.AddDate(0, 1, -1) + + // As per crontab man page (http://linux.die.net/man/5/crontab#): + // "The day of a command's execution can be specified by two + // "fields - day of month, and day of week. If both fields are + // "restricted (ie, aren't *), the command will be run when + // "either field matches the current time" + if expr.daysOfMonthRestricted || expr.daysOfWeekRestricted == false { + // Last day of month + if expr.lastDayOfMonth { + actualDaysOfMonthMap[lastDayOfMonth.Day()] = true + } + // Last work day of month + if expr.lastWorkdayOfMonth { + actualDaysOfMonthMap[workdayOfMonth(lastDayOfMonth, lastDayOfMonth)] = true + } + // Days of month + for v := range expr.daysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[v] = true + } + } + // Work days of month + // As per Wikipedia: month boundaries are not crossed. + for v := range expr.workdaysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[workdayOfMonth(firstDayOfMonth.AddDate(0, 0, v-1), lastDayOfMonth)] = true + } + } + } + + if expr.daysOfWeekRestricted { + // How far first sunday is from first day of month + offset := 7 - int(firstDayOfMonth.Weekday()) + // days of week + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 + for w := 0; w <= 4; w += 1 { + for v := range expr.daysOfWeek { + v := 1 + w*7 + (offset+v)%7 + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[v] = true + } + } + } + // days of week of specific week in the month + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 + for v := range expr.specificWeekDaysOfWeek { + v := 1 + 7*(v/7) + (offset+v)%7 + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[v] = true + } + } + // Last days of week of the month + lastWeekOrigin := firstDayOfMonth.AddDate(0, 1, -7) + offset = 7 - int(lastWeekOrigin.Weekday()) + for v := range expr.lastWeekDaysOfWeek { + v := lastWeekOrigin.Day() + (offset+v)%7 + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[v] = true + } + } + } + + return toList(actualDaysOfMonthMap) +} + +/******************************************************************************/ + +func (expr *Expression) nextDayOfMonth(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate day of month + i := sort.SearchInts(expr.actualDaysOfMonthList, t.Day()+1) + if i == len(expr.actualDaysOfMonthList) { + return expr.nextMonth(t) + } + + return time.Date( + t.Year(), + t.Month(), + expr.actualDaysOfMonthList[i], + expr.hourList[0], + expr.minuteList[0], + expr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (expr *Expression) nextHour(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate hour + i := sort.SearchInts(expr.hourList, t.Hour()+1) + if i == len(expr.hourList) { + return expr.nextDayOfMonth(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + expr.hourList[i], + expr.minuteList[0], + expr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (expr *Expression) nextMinute(t time.Time) time.Time { + // Find index at which item in list is greater or equal to + // candidate minute + i := sort.SearchInts(expr.minuteList, t.Minute()+1) + if i == len(expr.minuteList) { + return expr.nextHour(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + t.Hour(), + expr.minuteList[i], + expr.secondList[0], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (expr *Expression) nextSecond(t time.Time) time.Time { + // nextSecond() assumes all other fields are exactly matched + // to the cron expression + + // Find index at which item in list is greater or equal to + // candidate second + i := sort.SearchInts(expr.secondList, t.Second()+1) + if i == len(expr.secondList) { + return expr.nextMinute(t) + } + + return time.Date( + t.Year(), + t.Month(), + t.Day(), + t.Hour(), + t.Minute(), + expr.secondList[i], + 0, + t.Location()) +} + +/******************************************************************************/ + +func (expr *Expression) secondFieldHandler(s string) error { + var err error + expr.secondList, err = genericFieldHandler(s, secondDescriptor) + return err +} + +/******************************************************************************/ + +func (expr *Expression) minuteFieldHandler(s string) error { + var err error + expr.minuteList, err = genericFieldHandler(s, minuteDescriptor) + return err +} + +/******************************************************************************/ + +func (expr *Expression) hourFieldHandler(s string) error { + var err error + expr.hourList, err = genericFieldHandler(s, hourDescriptor) + return err +} + +/******************************************************************************/ + +func (expr *Expression) monthFieldHandler(s string) error { + var err error + expr.monthList, err = genericFieldHandler(s, monthDescriptor) + return err +} + +/******************************************************************************/ + +func (expr *Expression) yearFieldHandler(s string) error { + var err error + expr.yearList, err = genericFieldHandler(s, yearDescriptor) + return err +} + +/******************************************************************************/ + +const ( + none = 0 + one = 1 + span = 2 + all = 3 +) + +type cronDirective struct { + kind int + first int + last int + step int + sbeg int + send int +} + +func genericFieldHandler(s string, desc fieldDescriptor) ([]int, error) { + directives, err := genericFieldParse(s, desc) + if err != nil { + return nil, err + } + values := make(map[int]bool) + for _, directive := range directives { + switch directive.kind { + case none: + return nil, fmt.Errorf("Syntax error in %s field: '%s'", desc.name, s[directive.sbeg:directive.send]) + case one: + populateOne(values, directive.first) + case span: + populateMany(values, directive.first, directive.last, directive.step) + case all: + return desc.defaultList, nil + } + } + return toList(values), nil +} + +func (expr *Expression) dowFieldHandler(s string) error { + expr.daysOfWeekRestricted = true + expr.daysOfWeek = make(map[int]bool) + expr.lastWeekDaysOfWeek = make(map[int]bool) + expr.specificWeekDaysOfWeek = make(map[int]bool) + + directives, err := genericFieldParse(s, dowDescriptor) + if err != nil { + return err + } + + for _, directive := range directives { + switch directive.kind { + case none: + sdirective := s[directive.sbeg:directive.send] + snormal := strings.ToLower(sdirective) + // `5L` + pairs := makeLayoutRegexp(layoutDowOfLastWeek, dowDescriptor.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + populateOne(expr.lastWeekDaysOfWeek, dowDescriptor.atoi(snormal[pairs[2]:pairs[3]])) + } else { + // `5#3` + pairs := makeLayoutRegexp(layoutDowOfSpecificWeek, dowDescriptor.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + populateOne(expr.specificWeekDaysOfWeek, (dowDescriptor.atoi(snormal[pairs[4]:pairs[5]])-1)*7+(dowDescriptor.atoi(snormal[pairs[2]:pairs[3]])%7)) + } else { + return fmt.Errorf("Syntax error in day-of-week field: '%s'", sdirective) + } + } + case one: + populateOne(expr.daysOfWeek, directive.first) + case span: + populateMany(expr.daysOfWeek, directive.first, directive.last, directive.step) + case all: + populateMany(expr.daysOfWeek, directive.first, directive.last, directive.step) + expr.daysOfWeekRestricted = false + } + } + return nil +} + +func (expr *Expression) domFieldHandler(s string) error { + expr.daysOfMonthRestricted = true + expr.lastDayOfMonth = false + expr.lastWorkdayOfMonth = false + expr.daysOfMonth = make(map[int]bool) // days of month map + expr.workdaysOfMonth = make(map[int]bool) // work days of month map + + directives, err := genericFieldParse(s, domDescriptor) + if err != nil { + return err + } + + for _, directive := range directives { + switch directive.kind { + case none: + sdirective := s[directive.sbeg:directive.send] + snormal := strings.ToLower(sdirective) + // `L` + if makeLayoutRegexp(layoutLastDom, domDescriptor.valuePattern).MatchString(snormal) { + expr.lastDayOfMonth = true + } else { + // `LW` + if makeLayoutRegexp(layoutLastWorkdom, domDescriptor.valuePattern).MatchString(snormal) { + expr.lastWorkdayOfMonth = true + } else { + // `15W` + pairs := makeLayoutRegexp(layoutWorkdom, domDescriptor.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + populateOne(expr.workdaysOfMonth, domDescriptor.atoi(snormal[pairs[2]:pairs[3]])) + } else { + return fmt.Errorf("Syntax error in day-of-month field: '%s'", sdirective) + } + } + } + case one: + populateOne(expr.daysOfMonth, directive.first) + case span: + populateMany(expr.daysOfMonth, directive.first, directive.last, directive.step) + case all: + populateMany(expr.daysOfMonth, directive.first, directive.last, directive.step) + expr.daysOfMonthRestricted = false + } + } + return nil +} + +/******************************************************************************/ + +func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) { + // At least one entry must be present + indices := entryFinder.FindAllStringIndex(s, -1) + if len(indices) == 0 { + return nil, fmt.Errorf("%s field: missing directive", desc.name) + } + + directives := make([]*cronDirective, 0, len(indices)) + + for i := range indices { + directive := cronDirective{ + sbeg: indices[i][0], + send: indices[i][1], + } + snormal := strings.ToLower(s[indices[i][0]:indices[i][1]]) + // `*` + if makeLayoutRegexp(layoutWildcard, desc.valuePattern).MatchString(snormal) { + directive.kind = all + directive.first = desc.min + directive.last = desc.max + directive.step = 1 + directives = append(directives, &directive) + continue + } + // `5` + if makeLayoutRegexp(layoutValue, desc.valuePattern).MatchString(snormal) { + directive.kind = one + directive.first = desc.atoi(snormal) + directives = append(directives, &directive) + continue + } + // `5-20` + pairs := makeLayoutRegexp(layoutRange, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) + directive.last = desc.atoi(snormal[pairs[4]:pairs[5]]) + directive.step = 1 + directives = append(directives, &directive) + continue + } + // `*/2` + pairs = makeLayoutRegexp(layoutWildcardAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.min + directive.last = desc.max + directive.step = atoi(snormal[pairs[2]:pairs[3]]) + directives = append(directives, &directive) + continue + } + // `5/2` + pairs = makeLayoutRegexp(layoutValueAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) + directive.last = desc.max + directive.step = atoi(snormal[pairs[4]:pairs[5]]) + directives = append(directives, &directive) + continue + } + // `5-20/2` + pairs = makeLayoutRegexp(layoutRangeAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) + directive.last = desc.atoi(snormal[pairs[4]:pairs[5]]) + directive.step = atoi(snormal[pairs[6]:pairs[7]]) + directives = append(directives, &directive) + continue + } + // No behavior for this one, let caller deal with it + directive.kind = none + directives = append(directives, &directive) + } + return directives, nil +} + +/******************************************************************************/ + +func populateOne(values map[int]bool, v int) { + values[v] = true +} + +func populateMany(values map[int]bool, min, max, step int) { + for i := min; i <= max; i += step { + values[i] = true + } +} + +func toList(set map[int]bool) []int { + list := make([]int, len(set)) + i := 0 + for k := range set { + list[i] = k + i += 1 + } + sort.Ints(list) + return list +} + +/******************************************************************************/ + +func makeLayoutRegexp(layout, value string) *regexp.Regexp { + layout = strings.Replace(layout, `%value%`, value, -1) + re := layoutRegexp[layout] + if re == nil { + re = regexp.MustCompile(layout) + layoutRegexp[layout] = re + } + return re +} diff --git a/cronexpr_test.go b/cronexpr_test.go index 9fbe49c..32467fb 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -116,6 +116,51 @@ var crontests = []crontest{ }, }, + // Work day of month + { + "0 0 14W * *", + "Mon 2006-01-02 15:04", + []crontimes{ + {"2013-03-31 00:00:00", "Mon 2013-04-15 00:00"}, + {"2013-08-31 00:00:00", "Fri 2013-09-13 00:00"}, + }, + }, + + // Work day of month -- end of month + { + "0 0 30W * *", + "Mon 2006-01-02 15:04", + []crontimes{ + {"2013-03-02 00:00:00", "Fri 2013-03-29 00:00"}, + {"2013-06-02 00:00:00", "Fri 2013-06-28 00:00"}, + {"2013-09-02 00:00:00", "Mon 2013-09-30 00:00"}, + {"2013-11-02 00:00:00", "Fri 2013-11-29 00:00"}, + }, + }, + + // Last day of month + { + "0 0 L * *", + "Mon 2006-01-02 15:04", + []crontimes{ + {"2013-09-02 00:00:00", "Mon 2013-09-30 00:00"}, + {"2014-01-01 00:00:00", "Fri 2014-01-31 00:00"}, + {"2014-02-01 00:00:00", "Fri 2014-02-28 00:00"}, + {"2016-02-15 00:00:00", "Mon 2016-02-29 00:00"}, + }, + }, + + // Last work day of month + { + "0 0 LW * *", + "Mon 2006-01-02 15:04", + []crontimes{ + {"2013-09-02 00:00:00", "Mon 2013-09-30 00:00"}, + {"2013-11-02 00:00:00", "Fri 2013-11-29 00:00"}, + {"2014-08-15 00:00:00", "Fri 2014-08-29 00:00"}, + }, + }, + // TODO: more tests } @@ -123,7 +168,11 @@ func TestExpressions(t *testing.T) { for _, test := range crontests { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) - next := cronexpr.MustParse(test.expr).Next(from) + expr, err := cronexpr.Parse(test.expr) + if err != nil { + t.Errorf(`cronexpr.Parse("%s") returned "%s"`, test.expr, err.Error()) + } + next := expr.Next(from) nextstr := next.Format(test.layout) if nextstr != times.next { t.Errorf(`("%s").Next("%s") = "%s", got "%s"`, test.expr, times.from, times.next, nextstr) From 7f9a918f89e2f0432412939d09a2aa1363b8b7fc Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 7 Sep 2013 15:45:21 -0400 Subject: [PATCH 076/105] golint/deadcode/etc. --- cronexpr.go | 2 +- cronexpr_impl.go | 71 +++++++++++++++++++++++------------------------- 2 files changed, 35 insertions(+), 38 deletions(-) diff --git a/cronexpr.go b/cronexpr.go index 94cbf59..5189e0f 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -71,7 +71,7 @@ func Parse(cronLine string) (*Expression, error) { indices := fieldFinder.FindAllStringIndex(cron, -1) if len(indices) < 5 { - return nil, fmt.Errorf("Missing field(s)") + return nil, fmt.Errorf("missing field(s)") } expr := Expression{} diff --git a/cronexpr_impl.go b/cronexpr_impl.go index 3ca2e82..51f2cc1 100644 --- a/cronexpr_impl.go +++ b/cronexpr_impl.go @@ -23,7 +23,7 @@ import ( /******************************************************************************/ var ( - genericDefaultList []int = []int{ + genericDefaultList = []int{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, @@ -31,7 +31,7 @@ var ( 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, } - yearDefaultList []int = []int{ + yearDefaultList = []int{ 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, @@ -51,7 +51,7 @@ var ( /******************************************************************************/ var ( - numberTokens map[string]int = map[string]int{ + numberTokens = map[string]int{ "0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, "10": 10, "11": 11, "12": 12, "13": 13, "14": 14, "15": 15, "16": 16, "17": 17, "18": 18, "19": 19, "20": 20, "21": 21, "22": 22, "23": 23, "24": 24, "25": 25, "26": 26, "27": 27, "28": 28, "29": 29, @@ -72,7 +72,7 @@ var ( "2080": 2080, "2081": 2081, "2082": 2082, "2083": 2083, "2084": 2084, "2085": 2085, "2086": 2086, "2087": 2087, "2088": 2088, "2089": 2089, "2090": 2090, "2091": 2091, "2092": 2092, "2093": 2093, "2094": 2094, "2095": 2095, "2096": 2096, "2097": 2097, "2098": 2098, "2099": 2099, } - monthTokens map[string]int = map[string]int{ + monthTokens = map[string]int{ `1`: 1, `jan`: 1, `january`: 1, `2`: 2, `feb`: 2, `february`: 2, `3`: 3, `mar`: 3, `march`: 3, @@ -86,7 +86,7 @@ var ( `11`: 11, `nov`: 11, `november`: 11, `12`: 12, `dec`: 12, `december`: 12, } - dowTokens map[string]int = map[string]int{ + dowTokens = map[string]int{ `0`: 0, `sun`: 0, `sunday`: 0, `1`: 1, `mon`: 1, `monday`: 1, `2`: 2, `tue`: 2, `tuesday`: 2, @@ -113,7 +113,7 @@ type fieldDescriptor struct { } var ( - secondDescriptor fieldDescriptor = fieldDescriptor{ + secondDescriptor = fieldDescriptor{ name: "second", min: 0, max: 59, @@ -121,7 +121,7 @@ var ( valuePattern: `[0-9]|[1-5][0-9]`, atoi: atoi, } - minuteDescriptor fieldDescriptor = fieldDescriptor{ + minuteDescriptor = fieldDescriptor{ name: "minute", min: 0, max: 59, @@ -129,7 +129,7 @@ var ( valuePattern: `[0-9]|[1-5][0-9]`, atoi: atoi, } - hourDescriptor fieldDescriptor = fieldDescriptor{ + hourDescriptor = fieldDescriptor{ name: "hour", min: 0, max: 23, @@ -137,7 +137,7 @@ var ( valuePattern: `[0-9]|1[0-9]|2[0-3]`, atoi: atoi, } - domDescriptor fieldDescriptor = fieldDescriptor{ + domDescriptor = fieldDescriptor{ name: "day-of-month", min: 1, max: 31, @@ -145,7 +145,7 @@ var ( valuePattern: `[1-9]|[12][0-9]|3[01]`, atoi: atoi, } - monthDescriptor fieldDescriptor = fieldDescriptor{ + monthDescriptor = fieldDescriptor{ name: "month", min: 1, max: 12, @@ -155,7 +155,7 @@ var ( return monthTokens[s] }, } - dowDescriptor fieldDescriptor = fieldDescriptor{ + dowDescriptor = fieldDescriptor{ name: "day-of-week", min: 0, max: 6, @@ -165,7 +165,7 @@ var ( return dowTokens[s] }, } - yearDescriptor fieldDescriptor = fieldDescriptor{ + yearDescriptor = fieldDescriptor{ name: "year", min: 1970, max: 2099, @@ -178,23 +178,20 @@ var ( /******************************************************************************/ var ( - layoutDomValue string = `[1-9]|[12][0-9]|3[01]` - layoutDowValue string = `[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday` - layoutWildcard string = `^\*|\?$` - layoutValue string = `^(%value%)$` - layoutRange string = `^(%value%)-(%value%)$` - layoutWildcardAndInterval string = `^\*/(\d+)$` - layoutValueAndInterval string = `^(%value%)/(\d+)$` - layoutRangeAndInterval string = `^(%value%)-(%value%)/(\d+)$` - layoutLastDom string = `^l$` - layoutWorkdom string = `^(%value%)w$` - layoutLastWorkdom string = `^lw$` - layoutDowOfLastWeek string = `^(%value%)l$` - layoutDowOfSpecificWeek string = `^(%value%)#(\d+)$` - - layoutRegexp map[string]*regexp.Regexp = make(map[string]*regexp.Regexp) - fieldFinder *regexp.Regexp = regexp.MustCompile(`\S+`) - entryFinder *regexp.Regexp = regexp.MustCompile(`[^,]+`) + layoutWildcard = `^\*|\?$` + layoutValue = `^(%value%)$` + layoutRange = `^(%value%)-(%value%)$` + layoutWildcardAndInterval = `^\*/(\d+)$` + layoutValueAndInterval = `^(%value%)/(\d+)$` + layoutRangeAndInterval = `^(%value%)-(%value%)/(\d+)$` + layoutLastDom = `^l$` + layoutWorkdom = `^(%value%)w$` + layoutLastWorkdom = `^lw$` + layoutDowOfLastWeek = `^(%value%)l$` + layoutDowOfSpecificWeek = `^(%value%)#(\d+)$` + fieldFinder = regexp.MustCompile(`\S+`) + entryFinder = regexp.MustCompile(`[^,]+`) + layoutRegexp = make(map[string]*regexp.Regexp) ) /******************************************************************************/ @@ -460,7 +457,7 @@ func (expr *Expression) nextSecond(t time.Time) time.Time { /******************************************************************************/ func (expr *Expression) secondFieldHandler(s string) error { - var err error + var err error expr.secondList, err = genericFieldHandler(s, secondDescriptor) return err } @@ -468,7 +465,7 @@ func (expr *Expression) secondFieldHandler(s string) error { /******************************************************************************/ func (expr *Expression) minuteFieldHandler(s string) error { - var err error + var err error expr.minuteList, err = genericFieldHandler(s, minuteDescriptor) return err } @@ -476,7 +473,7 @@ func (expr *Expression) minuteFieldHandler(s string) error { /******************************************************************************/ func (expr *Expression) hourFieldHandler(s string) error { - var err error + var err error expr.hourList, err = genericFieldHandler(s, hourDescriptor) return err } @@ -484,7 +481,7 @@ func (expr *Expression) hourFieldHandler(s string) error { /******************************************************************************/ func (expr *Expression) monthFieldHandler(s string) error { - var err error + var err error expr.monthList, err = genericFieldHandler(s, monthDescriptor) return err } @@ -492,7 +489,7 @@ func (expr *Expression) monthFieldHandler(s string) error { /******************************************************************************/ func (expr *Expression) yearFieldHandler(s string) error { - var err error + var err error expr.yearList, err = genericFieldHandler(s, yearDescriptor) return err } @@ -524,7 +521,7 @@ func genericFieldHandler(s string, desc fieldDescriptor) ([]int, error) { for _, directive := range directives { switch directive.kind { case none: - return nil, fmt.Errorf("Syntax error in %s field: '%s'", desc.name, s[directive.sbeg:directive.send]) + return nil, fmt.Errorf("syntax error in %s field: '%s'", desc.name, s[directive.sbeg:directive.send]) case one: populateOne(values, directive.first) case span: @@ -562,7 +559,7 @@ func (expr *Expression) dowFieldHandler(s string) error { if len(pairs) > 0 { populateOne(expr.specificWeekDaysOfWeek, (dowDescriptor.atoi(snormal[pairs[4]:pairs[5]])-1)*7+(dowDescriptor.atoi(snormal[pairs[2]:pairs[3]])%7)) } else { - return fmt.Errorf("Syntax error in day-of-week field: '%s'", sdirective) + return fmt.Errorf("syntax error in day-of-week field: '%s'", sdirective) } } case one: @@ -607,7 +604,7 @@ func (expr *Expression) domFieldHandler(s string) error { if len(pairs) > 0 { populateOne(expr.workdaysOfMonth, domDescriptor.atoi(snormal[pairs[2]:pairs[3]])) } else { - return fmt.Errorf("Syntax error in day-of-month field: '%s'", sdirective) + return fmt.Errorf("syntax error in day-of-month field: '%s'", sdirective) } } } From 8a4a15a5a2096bb94012538041471fb81ec873fb Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 7 Sep 2013 16:04:25 -0400 Subject: [PATCH 077/105] restrict week number to valid values --- cronexpr_impl.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cronexpr_impl.go b/cronexpr_impl.go index 51f2cc1..981aa0e 100644 --- a/cronexpr_impl.go +++ b/cronexpr_impl.go @@ -188,7 +188,7 @@ var ( layoutWorkdom = `^(%value%)w$` layoutLastWorkdom = `^lw$` layoutDowOfLastWeek = `^(%value%)l$` - layoutDowOfSpecificWeek = `^(%value%)#(\d+)$` + layoutDowOfSpecificWeek = `^(%value%)#([1-5])$` fieldFinder = regexp.MustCompile(`\S+`) entryFinder = regexp.MustCompile(`[^,]+`) layoutRegexp = make(map[string]*regexp.Regexp) From 8da0efdd84a9078f25833b8620262b447f606dfb Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 7 Sep 2013 17:08:27 -0400 Subject: [PATCH 078/105] split/rename cronexpr_impl.go --- cronexpr_impl.go => cronexpr_next.go | 0 cronexpr_parse.go | 485 +++++++++++++++++++++++++++ 2 files changed, 485 insertions(+) rename cronexpr_impl.go => cronexpr_next.go (100%) create mode 100644 cronexpr_parse.go diff --git a/cronexpr_impl.go b/cronexpr_next.go similarity index 100% rename from cronexpr_impl.go rename to cronexpr_next.go diff --git a/cronexpr_parse.go b/cronexpr_parse.go new file mode 100644 index 0000000..cdf4ba3 --- /dev/null +++ b/cronexpr_parse.go @@ -0,0 +1,485 @@ +/*! + * Copyright 2013 Raymond Hill + * + * Project: github.com/gorhill/cronexpr + * File: cronexpr_parser.go + * Version: 1.0 + * License: GPL v3 see + * + */ + +package cronexpr + +/******************************************************************************/ + +import ( + "fmt" + "regexp" + "sort" + "strings" +) + +/******************************************************************************/ + +var ( + genericDefaultList = []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + } + yearDefaultList = []int{ + 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, + 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, + 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, + 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, + 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, + 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, + 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, + 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, + 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, + 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, + 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, + 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, + } +) + +/******************************************************************************/ + +var ( + numberTokens = map[string]int{ + "0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, + "10": 10, "11": 11, "12": 12, "13": 13, "14": 14, "15": 15, "16": 16, "17": 17, "18": 18, "19": 19, + "20": 20, "21": 21, "22": 22, "23": 23, "24": 24, "25": 25, "26": 26, "27": 27, "28": 28, "29": 29, + "30": 30, "31": 31, "32": 32, "33": 33, "34": 34, "35": 35, "36": 36, "37": 37, "38": 38, "39": 39, + "40": 40, "41": 41, "42": 42, "43": 43, "44": 44, "45": 45, "46": 46, "47": 47, "48": 48, "49": 49, + "50": 50, "51": 51, "52": 52, "53": 53, "54": 54, "55": 55, "56": 56, "57": 57, "58": 58, "59": 59, + "1970": 1970, "1971": 1971, "1972": 1972, "1973": 1973, "1974": 1974, "1975": 1975, "1976": 1976, "1977": 1977, "1978": 1978, "1979": 1979, + "1980": 1980, "1981": 1981, "1982": 1982, "1983": 1983, "1984": 1984, "1985": 1985, "1986": 1986, "1987": 1987, "1988": 1988, "1989": 1989, + "1990": 1990, "1991": 1991, "1992": 1992, "1993": 1993, "1994": 1994, "1995": 1995, "1996": 1996, "1997": 1997, "1998": 1998, "1999": 1999, + "2000": 2000, "2001": 2001, "2002": 2002, "2003": 2003, "2004": 2004, "2005": 2005, "2006": 2006, "2007": 2007, "2008": 2008, "2009": 2009, + "2010": 2010, "2011": 2011, "2012": 2012, "2013": 2013, "2014": 2014, "2015": 2015, "2016": 2016, "2017": 2017, "2018": 2018, "2019": 2019, + "2020": 2020, "2021": 2021, "2022": 2022, "2023": 2023, "2024": 2024, "2025": 2025, "2026": 2026, "2027": 2027, "2028": 2028, "2029": 2029, + "2030": 2030, "2031": 2031, "2032": 2032, "2033": 2033, "2034": 2034, "2035": 2035, "2036": 2036, "2037": 2037, "2038": 2038, "2039": 2039, + "2040": 2040, "2041": 2041, "2042": 2042, "2043": 2043, "2044": 2044, "2045": 2045, "2046": 2046, "2047": 2047, "2048": 2048, "2049": 2049, + "2050": 2050, "2051": 2051, "2052": 2052, "2053": 2053, "2054": 2054, "2055": 2055, "2056": 2056, "2057": 2057, "2058": 2058, "2059": 2059, + "2060": 2060, "2061": 2061, "2062": 2062, "2063": 2063, "2064": 2064, "2065": 2065, "2066": 2066, "2067": 2067, "2068": 2068, "2069": 2069, + "2070": 2070, "2071": 2071, "2072": 2072, "2073": 2073, "2074": 2074, "2075": 2075, "2076": 2076, "2077": 2077, "2078": 2078, "2079": 2079, + "2080": 2080, "2081": 2081, "2082": 2082, "2083": 2083, "2084": 2084, "2085": 2085, "2086": 2086, "2087": 2087, "2088": 2088, "2089": 2089, + "2090": 2090, "2091": 2091, "2092": 2092, "2093": 2093, "2094": 2094, "2095": 2095, "2096": 2096, "2097": 2097, "2098": 2098, "2099": 2099, + } + monthTokens = map[string]int{ + `1`: 1, `jan`: 1, `january`: 1, + `2`: 2, `feb`: 2, `february`: 2, + `3`: 3, `mar`: 3, `march`: 3, + `4`: 4, `apr`: 4, `april`: 4, + `5`: 5, `may`: 5, + `6`: 6, `jun`: 6, `june`: 6, + `7`: 7, `jul`: 7, `july`: 7, + `8`: 8, `aug`: 8, `august`: 8, + `9`: 9, `sep`: 9, `september`: 9, + `10`: 10, `oct`: 10, `october`: 10, + `11`: 11, `nov`: 11, `november`: 11, + `12`: 12, `dec`: 12, `december`: 12, + } + dowTokens = map[string]int{ + `0`: 0, `sun`: 0, `sunday`: 0, + `1`: 1, `mon`: 1, `monday`: 1, + `2`: 2, `tue`: 2, `tuesday`: 2, + `3`: 3, `wed`: 3, `wednesday`: 3, + `4`: 4, `thu`: 4, `thursday`: 4, + `5`: 5, `fri`: 5, `friday`: 5, + `6`: 6, `sat`: 6, `saturday`: 6, + `7`: 0, + } +) + +/******************************************************************************/ + +func atoi(s string) int { + return numberTokens[s] +} + +type fieldDescriptor struct { + name string + min, max int + defaultList []int + valuePattern string + atoi func(string) int +} + +var ( + secondDescriptor = fieldDescriptor{ + name: "second", + min: 0, + max: 59, + defaultList: genericDefaultList[0:60], + valuePattern: `[0-9]|[1-5][0-9]`, + atoi: atoi, + } + minuteDescriptor = fieldDescriptor{ + name: "minute", + min: 0, + max: 59, + defaultList: genericDefaultList[0:60], + valuePattern: `[0-9]|[1-5][0-9]`, + atoi: atoi, + } + hourDescriptor = fieldDescriptor{ + name: "hour", + min: 0, + max: 23, + defaultList: genericDefaultList[0:24], + valuePattern: `[0-9]|1[0-9]|2[0-3]`, + atoi: atoi, + } + domDescriptor = fieldDescriptor{ + name: "day-of-month", + min: 1, + max: 31, + defaultList: genericDefaultList[1:32], + valuePattern: `[1-9]|[12][0-9]|3[01]`, + atoi: atoi, + } + monthDescriptor = fieldDescriptor{ + name: "month", + min: 1, + max: 12, + defaultList: genericDefaultList[1:13], + valuePattern: `[1-9]|1[012]|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|january|february|march|april|march|april|june|july|august|september|october|november|december`, + atoi: func(s string) int { + return monthTokens[s] + }, + } + dowDescriptor = fieldDescriptor{ + name: "day-of-week", + min: 0, + max: 6, + defaultList: genericDefaultList[0:7], + valuePattern: `[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday`, + atoi: func(s string) int { + return dowTokens[s] + }, + } + yearDescriptor = fieldDescriptor{ + name: "year", + min: 1970, + max: 2099, + defaultList: yearDefaultList[:], + valuePattern: `19[789][0-9]|20[0-9]{2}`, + atoi: atoi, + } +) + +/******************************************************************************/ + +var ( + layoutWildcard = `^\*|\?$` + layoutValue = `^(%value%)$` + layoutRange = `^(%value%)-(%value%)$` + layoutWildcardAndInterval = `^\*/(\d+)$` + layoutValueAndInterval = `^(%value%)/(\d+)$` + layoutRangeAndInterval = `^(%value%)-(%value%)/(\d+)$` + layoutLastDom = `^l$` + layoutWorkdom = `^(%value%)w$` + layoutLastWorkdom = `^lw$` + layoutDowOfLastWeek = `^(%value%)l$` + layoutDowOfSpecificWeek = `^(%value%)#([1-5])$` + fieldFinder = regexp.MustCompile(`\S+`) + entryFinder = regexp.MustCompile(`[^,]+`) + layoutRegexp = make(map[string]*regexp.Regexp) +) + +/******************************************************************************/ + +var cronNormalizer = strings.NewReplacer( + "@yearly", "0 0 0 1 1 * *", + "@annually", "0 0 0 1 1 * *", + "@monthly", "0 0 0 1 * * *", + "@weekly", "0 0 0 * * 0 *", + "@daily", "0 0 0 * * * *", + "@hourly", "0 0 * * * * *") + +/******************************************************************************/ + +func (expr *Expression) secondFieldHandler(s string) error { + var err error + expr.secondList, err = genericFieldHandler(s, secondDescriptor) + return err +} + +/******************************************************************************/ + +func (expr *Expression) minuteFieldHandler(s string) error { + var err error + expr.minuteList, err = genericFieldHandler(s, minuteDescriptor) + return err +} + +/******************************************************************************/ + +func (expr *Expression) hourFieldHandler(s string) error { + var err error + expr.hourList, err = genericFieldHandler(s, hourDescriptor) + return err +} + +/******************************************************************************/ + +func (expr *Expression) monthFieldHandler(s string) error { + var err error + expr.monthList, err = genericFieldHandler(s, monthDescriptor) + return err +} + +/******************************************************************************/ + +func (expr *Expression) yearFieldHandler(s string) error { + var err error + expr.yearList, err = genericFieldHandler(s, yearDescriptor) + return err +} + +/******************************************************************************/ + +const ( + none = 0 + one = 1 + span = 2 + all = 3 +) + +type cronDirective struct { + kind int + first int + last int + step int + sbeg int + send int +} + +func genericFieldHandler(s string, desc fieldDescriptor) ([]int, error) { + directives, err := genericFieldParse(s, desc) + if err != nil { + return nil, err + } + values := make(map[int]bool) + for _, directive := range directives { + switch directive.kind { + case none: + return nil, fmt.Errorf("syntax error in %s field: '%s'", desc.name, s[directive.sbeg:directive.send]) + case one: + populateOne(values, directive.first) + case span: + populateMany(values, directive.first, directive.last, directive.step) + case all: + return desc.defaultList, nil + } + } + return toList(values), nil +} + +func (expr *Expression) dowFieldHandler(s string) error { + expr.daysOfWeekRestricted = true + expr.daysOfWeek = make(map[int]bool) + expr.lastWeekDaysOfWeek = make(map[int]bool) + expr.specificWeekDaysOfWeek = make(map[int]bool) + + directives, err := genericFieldParse(s, dowDescriptor) + if err != nil { + return err + } + + for _, directive := range directives { + switch directive.kind { + case none: + sdirective := s[directive.sbeg:directive.send] + snormal := strings.ToLower(sdirective) + // `5L` + pairs := makeLayoutRegexp(layoutDowOfLastWeek, dowDescriptor.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + populateOne(expr.lastWeekDaysOfWeek, dowDescriptor.atoi(snormal[pairs[2]:pairs[3]])) + } else { + // `5#3` + pairs := makeLayoutRegexp(layoutDowOfSpecificWeek, dowDescriptor.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + populateOne(expr.specificWeekDaysOfWeek, (dowDescriptor.atoi(snormal[pairs[4]:pairs[5]])-1)*7+(dowDescriptor.atoi(snormal[pairs[2]:pairs[3]])%7)) + } else { + return fmt.Errorf("syntax error in day-of-week field: '%s'", sdirective) + } + } + case one: + populateOne(expr.daysOfWeek, directive.first) + case span: + populateMany(expr.daysOfWeek, directive.first, directive.last, directive.step) + case all: + populateMany(expr.daysOfWeek, directive.first, directive.last, directive.step) + expr.daysOfWeekRestricted = false + } + } + return nil +} + +func (expr *Expression) domFieldHandler(s string) error { + expr.daysOfMonthRestricted = true + expr.lastDayOfMonth = false + expr.lastWorkdayOfMonth = false + expr.daysOfMonth = make(map[int]bool) // days of month map + expr.workdaysOfMonth = make(map[int]bool) // work days of month map + + directives, err := genericFieldParse(s, domDescriptor) + if err != nil { + return err + } + + for _, directive := range directives { + switch directive.kind { + case none: + sdirective := s[directive.sbeg:directive.send] + snormal := strings.ToLower(sdirective) + // `L` + if makeLayoutRegexp(layoutLastDom, domDescriptor.valuePattern).MatchString(snormal) { + expr.lastDayOfMonth = true + } else { + // `LW` + if makeLayoutRegexp(layoutLastWorkdom, domDescriptor.valuePattern).MatchString(snormal) { + expr.lastWorkdayOfMonth = true + } else { + // `15W` + pairs := makeLayoutRegexp(layoutWorkdom, domDescriptor.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + populateOne(expr.workdaysOfMonth, domDescriptor.atoi(snormal[pairs[2]:pairs[3]])) + } else { + return fmt.Errorf("syntax error in day-of-month field: '%s'", sdirective) + } + } + } + case one: + populateOne(expr.daysOfMonth, directive.first) + case span: + populateMany(expr.daysOfMonth, directive.first, directive.last, directive.step) + case all: + populateMany(expr.daysOfMonth, directive.first, directive.last, directive.step) + expr.daysOfMonthRestricted = false + } + } + return nil +} + +/******************************************************************************/ + +func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) { + // At least one entry must be present + indices := entryFinder.FindAllStringIndex(s, -1) + if len(indices) == 0 { + return nil, fmt.Errorf("%s field: missing directive", desc.name) + } + + directives := make([]*cronDirective, 0, len(indices)) + + for i := range indices { + directive := cronDirective{ + sbeg: indices[i][0], + send: indices[i][1], + } + snormal := strings.ToLower(s[indices[i][0]:indices[i][1]]) + // `*` + if makeLayoutRegexp(layoutWildcard, desc.valuePattern).MatchString(snormal) { + directive.kind = all + directive.first = desc.min + directive.last = desc.max + directive.step = 1 + directives = append(directives, &directive) + continue + } + // `5` + if makeLayoutRegexp(layoutValue, desc.valuePattern).MatchString(snormal) { + directive.kind = one + directive.first = desc.atoi(snormal) + directives = append(directives, &directive) + continue + } + // `5-20` + pairs := makeLayoutRegexp(layoutRange, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) + directive.last = desc.atoi(snormal[pairs[4]:pairs[5]]) + directive.step = 1 + directives = append(directives, &directive) + continue + } + // `*/2` + pairs = makeLayoutRegexp(layoutWildcardAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.min + directive.last = desc.max + directive.step = atoi(snormal[pairs[2]:pairs[3]]) + directives = append(directives, &directive) + continue + } + // `5/2` + pairs = makeLayoutRegexp(layoutValueAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) + directive.last = desc.max + directive.step = atoi(snormal[pairs[4]:pairs[5]]) + directives = append(directives, &directive) + continue + } + // `5-20/2` + pairs = makeLayoutRegexp(layoutRangeAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) + directive.last = desc.atoi(snormal[pairs[4]:pairs[5]]) + directive.step = atoi(snormal[pairs[6]:pairs[7]]) + directives = append(directives, &directive) + continue + } + // No behavior for this one, let caller deal with it + directive.kind = none + directives = append(directives, &directive) + } + return directives, nil +} + +/******************************************************************************/ + +func populateOne(values map[int]bool, v int) { + values[v] = true +} + +func populateMany(values map[int]bool, min, max, step int) { + for i := min; i <= max; i += step { + values[i] = true + } +} + +func toList(set map[int]bool) []int { + list := make([]int, len(set)) + i := 0 + for k := range set { + list[i] = k + i += 1 + } + sort.Ints(list) + return list +} + +/******************************************************************************/ + +func makeLayoutRegexp(layout, value string) *regexp.Regexp { + layout = strings.Replace(layout, `%value%`, value, -1) + re := layoutRegexp[layout] + if re == nil { + re = regexp.MustCompile(layout) + layoutRegexp[layout] = re + } + return re +} From 13ba1270e189ce2bc861f2bed1d1228c524911b3 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sat, 7 Sep 2013 17:11:53 -0400 Subject: [PATCH 079/105] split/rename --- cronexpr_next.go | 470 +--------------------------------------------- cronexpr_parse.go | 2 +- 2 files changed, 2 insertions(+), 470 deletions(-) diff --git a/cronexpr_next.go b/cronexpr_next.go index 981aa0e..819df19 100644 --- a/cronexpr_next.go +++ b/cronexpr_next.go @@ -2,7 +2,7 @@ * Copyright 2013 Raymond Hill * * Project: github.com/gorhill/cronexpr - * File: cronexpr_impl.go + * File: cronexpr_next.go * Version: 1.0 * License: GPL v3 see * @@ -13,199 +13,12 @@ package cronexpr /******************************************************************************/ import ( - "fmt" - "regexp" "sort" - "strings" "time" ) /******************************************************************************/ -var ( - genericDefaultList = []int{ - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - } - yearDefaultList = []int{ - 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, - 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, - 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, - 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, - 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, - 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, - 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, - 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, - 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, - 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, - 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, - 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, - } -) - -/******************************************************************************/ - -var ( - numberTokens = map[string]int{ - "0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, - "10": 10, "11": 11, "12": 12, "13": 13, "14": 14, "15": 15, "16": 16, "17": 17, "18": 18, "19": 19, - "20": 20, "21": 21, "22": 22, "23": 23, "24": 24, "25": 25, "26": 26, "27": 27, "28": 28, "29": 29, - "30": 30, "31": 31, "32": 32, "33": 33, "34": 34, "35": 35, "36": 36, "37": 37, "38": 38, "39": 39, - "40": 40, "41": 41, "42": 42, "43": 43, "44": 44, "45": 45, "46": 46, "47": 47, "48": 48, "49": 49, - "50": 50, "51": 51, "52": 52, "53": 53, "54": 54, "55": 55, "56": 56, "57": 57, "58": 58, "59": 59, - "1970": 1970, "1971": 1971, "1972": 1972, "1973": 1973, "1974": 1974, "1975": 1975, "1976": 1976, "1977": 1977, "1978": 1978, "1979": 1979, - "1980": 1980, "1981": 1981, "1982": 1982, "1983": 1983, "1984": 1984, "1985": 1985, "1986": 1986, "1987": 1987, "1988": 1988, "1989": 1989, - "1990": 1990, "1991": 1991, "1992": 1992, "1993": 1993, "1994": 1994, "1995": 1995, "1996": 1996, "1997": 1997, "1998": 1998, "1999": 1999, - "2000": 2000, "2001": 2001, "2002": 2002, "2003": 2003, "2004": 2004, "2005": 2005, "2006": 2006, "2007": 2007, "2008": 2008, "2009": 2009, - "2010": 2010, "2011": 2011, "2012": 2012, "2013": 2013, "2014": 2014, "2015": 2015, "2016": 2016, "2017": 2017, "2018": 2018, "2019": 2019, - "2020": 2020, "2021": 2021, "2022": 2022, "2023": 2023, "2024": 2024, "2025": 2025, "2026": 2026, "2027": 2027, "2028": 2028, "2029": 2029, - "2030": 2030, "2031": 2031, "2032": 2032, "2033": 2033, "2034": 2034, "2035": 2035, "2036": 2036, "2037": 2037, "2038": 2038, "2039": 2039, - "2040": 2040, "2041": 2041, "2042": 2042, "2043": 2043, "2044": 2044, "2045": 2045, "2046": 2046, "2047": 2047, "2048": 2048, "2049": 2049, - "2050": 2050, "2051": 2051, "2052": 2052, "2053": 2053, "2054": 2054, "2055": 2055, "2056": 2056, "2057": 2057, "2058": 2058, "2059": 2059, - "2060": 2060, "2061": 2061, "2062": 2062, "2063": 2063, "2064": 2064, "2065": 2065, "2066": 2066, "2067": 2067, "2068": 2068, "2069": 2069, - "2070": 2070, "2071": 2071, "2072": 2072, "2073": 2073, "2074": 2074, "2075": 2075, "2076": 2076, "2077": 2077, "2078": 2078, "2079": 2079, - "2080": 2080, "2081": 2081, "2082": 2082, "2083": 2083, "2084": 2084, "2085": 2085, "2086": 2086, "2087": 2087, "2088": 2088, "2089": 2089, - "2090": 2090, "2091": 2091, "2092": 2092, "2093": 2093, "2094": 2094, "2095": 2095, "2096": 2096, "2097": 2097, "2098": 2098, "2099": 2099, - } - monthTokens = map[string]int{ - `1`: 1, `jan`: 1, `january`: 1, - `2`: 2, `feb`: 2, `february`: 2, - `3`: 3, `mar`: 3, `march`: 3, - `4`: 4, `apr`: 4, `april`: 4, - `5`: 5, `may`: 5, - `6`: 6, `jun`: 6, `june`: 6, - `7`: 7, `jul`: 7, `july`: 7, - `8`: 8, `aug`: 8, `august`: 8, - `9`: 9, `sep`: 9, `september`: 9, - `10`: 10, `oct`: 10, `october`: 10, - `11`: 11, `nov`: 11, `november`: 11, - `12`: 12, `dec`: 12, `december`: 12, - } - dowTokens = map[string]int{ - `0`: 0, `sun`: 0, `sunday`: 0, - `1`: 1, `mon`: 1, `monday`: 1, - `2`: 2, `tue`: 2, `tuesday`: 2, - `3`: 3, `wed`: 3, `wednesday`: 3, - `4`: 4, `thu`: 4, `thursday`: 4, - `5`: 5, `fri`: 5, `friday`: 5, - `6`: 6, `sat`: 6, `saturday`: 6, - `7`: 0, - } -) - -/******************************************************************************/ - -func atoi(s string) int { - return numberTokens[s] -} - -type fieldDescriptor struct { - name string - min, max int - defaultList []int - valuePattern string - atoi func(string) int -} - -var ( - secondDescriptor = fieldDescriptor{ - name: "second", - min: 0, - max: 59, - defaultList: genericDefaultList[0:60], - valuePattern: `[0-9]|[1-5][0-9]`, - atoi: atoi, - } - minuteDescriptor = fieldDescriptor{ - name: "minute", - min: 0, - max: 59, - defaultList: genericDefaultList[0:60], - valuePattern: `[0-9]|[1-5][0-9]`, - atoi: atoi, - } - hourDescriptor = fieldDescriptor{ - name: "hour", - min: 0, - max: 23, - defaultList: genericDefaultList[0:24], - valuePattern: `[0-9]|1[0-9]|2[0-3]`, - atoi: atoi, - } - domDescriptor = fieldDescriptor{ - name: "day-of-month", - min: 1, - max: 31, - defaultList: genericDefaultList[1:32], - valuePattern: `[1-9]|[12][0-9]|3[01]`, - atoi: atoi, - } - monthDescriptor = fieldDescriptor{ - name: "month", - min: 1, - max: 12, - defaultList: genericDefaultList[1:13], - valuePattern: `[1-9]|1[012]|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|january|february|march|april|march|april|june|july|august|september|october|november|december`, - atoi: func(s string) int { - return monthTokens[s] - }, - } - dowDescriptor = fieldDescriptor{ - name: "day-of-week", - min: 0, - max: 6, - defaultList: genericDefaultList[0:7], - valuePattern: `[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday`, - atoi: func(s string) int { - return dowTokens[s] - }, - } - yearDescriptor = fieldDescriptor{ - name: "year", - min: 1970, - max: 2099, - defaultList: yearDefaultList[:], - valuePattern: `19[789][0-9]|20[0-9]{2}`, - atoi: atoi, - } -) - -/******************************************************************************/ - -var ( - layoutWildcard = `^\*|\?$` - layoutValue = `^(%value%)$` - layoutRange = `^(%value%)-(%value%)$` - layoutWildcardAndInterval = `^\*/(\d+)$` - layoutValueAndInterval = `^(%value%)/(\d+)$` - layoutRangeAndInterval = `^(%value%)-(%value%)/(\d+)$` - layoutLastDom = `^l$` - layoutWorkdom = `^(%value%)w$` - layoutLastWorkdom = `^lw$` - layoutDowOfLastWeek = `^(%value%)l$` - layoutDowOfSpecificWeek = `^(%value%)#([1-5])$` - fieldFinder = regexp.MustCompile(`\S+`) - entryFinder = regexp.MustCompile(`[^,]+`) - layoutRegexp = make(map[string]*regexp.Regexp) -) - -/******************************************************************************/ - -var cronNormalizer = strings.NewReplacer( - "@yearly", "0 0 0 1 1 * *", - "@annually", "0 0 0 1 1 * *", - "@monthly", "0 0 0 1 * * *", - "@weekly", "0 0 0 * * 0 *", - "@daily", "0 0 0 * * * *", - "@hourly", "0 0 * * * * *") - -/******************************************************************************/ - func (expr *Expression) nextYear(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate year @@ -453,284 +266,3 @@ func (expr *Expression) nextSecond(t time.Time) time.Time { 0, t.Location()) } - -/******************************************************************************/ - -func (expr *Expression) secondFieldHandler(s string) error { - var err error - expr.secondList, err = genericFieldHandler(s, secondDescriptor) - return err -} - -/******************************************************************************/ - -func (expr *Expression) minuteFieldHandler(s string) error { - var err error - expr.minuteList, err = genericFieldHandler(s, minuteDescriptor) - return err -} - -/******************************************************************************/ - -func (expr *Expression) hourFieldHandler(s string) error { - var err error - expr.hourList, err = genericFieldHandler(s, hourDescriptor) - return err -} - -/******************************************************************************/ - -func (expr *Expression) monthFieldHandler(s string) error { - var err error - expr.monthList, err = genericFieldHandler(s, monthDescriptor) - return err -} - -/******************************************************************************/ - -func (expr *Expression) yearFieldHandler(s string) error { - var err error - expr.yearList, err = genericFieldHandler(s, yearDescriptor) - return err -} - -/******************************************************************************/ - -const ( - none = 0 - one = 1 - span = 2 - all = 3 -) - -type cronDirective struct { - kind int - first int - last int - step int - sbeg int - send int -} - -func genericFieldHandler(s string, desc fieldDescriptor) ([]int, error) { - directives, err := genericFieldParse(s, desc) - if err != nil { - return nil, err - } - values := make(map[int]bool) - for _, directive := range directives { - switch directive.kind { - case none: - return nil, fmt.Errorf("syntax error in %s field: '%s'", desc.name, s[directive.sbeg:directive.send]) - case one: - populateOne(values, directive.first) - case span: - populateMany(values, directive.first, directive.last, directive.step) - case all: - return desc.defaultList, nil - } - } - return toList(values), nil -} - -func (expr *Expression) dowFieldHandler(s string) error { - expr.daysOfWeekRestricted = true - expr.daysOfWeek = make(map[int]bool) - expr.lastWeekDaysOfWeek = make(map[int]bool) - expr.specificWeekDaysOfWeek = make(map[int]bool) - - directives, err := genericFieldParse(s, dowDescriptor) - if err != nil { - return err - } - - for _, directive := range directives { - switch directive.kind { - case none: - sdirective := s[directive.sbeg:directive.send] - snormal := strings.ToLower(sdirective) - // `5L` - pairs := makeLayoutRegexp(layoutDowOfLastWeek, dowDescriptor.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - populateOne(expr.lastWeekDaysOfWeek, dowDescriptor.atoi(snormal[pairs[2]:pairs[3]])) - } else { - // `5#3` - pairs := makeLayoutRegexp(layoutDowOfSpecificWeek, dowDescriptor.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - populateOne(expr.specificWeekDaysOfWeek, (dowDescriptor.atoi(snormal[pairs[4]:pairs[5]])-1)*7+(dowDescriptor.atoi(snormal[pairs[2]:pairs[3]])%7)) - } else { - return fmt.Errorf("syntax error in day-of-week field: '%s'", sdirective) - } - } - case one: - populateOne(expr.daysOfWeek, directive.first) - case span: - populateMany(expr.daysOfWeek, directive.first, directive.last, directive.step) - case all: - populateMany(expr.daysOfWeek, directive.first, directive.last, directive.step) - expr.daysOfWeekRestricted = false - } - } - return nil -} - -func (expr *Expression) domFieldHandler(s string) error { - expr.daysOfMonthRestricted = true - expr.lastDayOfMonth = false - expr.lastWorkdayOfMonth = false - expr.daysOfMonth = make(map[int]bool) // days of month map - expr.workdaysOfMonth = make(map[int]bool) // work days of month map - - directives, err := genericFieldParse(s, domDescriptor) - if err != nil { - return err - } - - for _, directive := range directives { - switch directive.kind { - case none: - sdirective := s[directive.sbeg:directive.send] - snormal := strings.ToLower(sdirective) - // `L` - if makeLayoutRegexp(layoutLastDom, domDescriptor.valuePattern).MatchString(snormal) { - expr.lastDayOfMonth = true - } else { - // `LW` - if makeLayoutRegexp(layoutLastWorkdom, domDescriptor.valuePattern).MatchString(snormal) { - expr.lastWorkdayOfMonth = true - } else { - // `15W` - pairs := makeLayoutRegexp(layoutWorkdom, domDescriptor.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - populateOne(expr.workdaysOfMonth, domDescriptor.atoi(snormal[pairs[2]:pairs[3]])) - } else { - return fmt.Errorf("syntax error in day-of-month field: '%s'", sdirective) - } - } - } - case one: - populateOne(expr.daysOfMonth, directive.first) - case span: - populateMany(expr.daysOfMonth, directive.first, directive.last, directive.step) - case all: - populateMany(expr.daysOfMonth, directive.first, directive.last, directive.step) - expr.daysOfMonthRestricted = false - } - } - return nil -} - -/******************************************************************************/ - -func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) { - // At least one entry must be present - indices := entryFinder.FindAllStringIndex(s, -1) - if len(indices) == 0 { - return nil, fmt.Errorf("%s field: missing directive", desc.name) - } - - directives := make([]*cronDirective, 0, len(indices)) - - for i := range indices { - directive := cronDirective{ - sbeg: indices[i][0], - send: indices[i][1], - } - snormal := strings.ToLower(s[indices[i][0]:indices[i][1]]) - // `*` - if makeLayoutRegexp(layoutWildcard, desc.valuePattern).MatchString(snormal) { - directive.kind = all - directive.first = desc.min - directive.last = desc.max - directive.step = 1 - directives = append(directives, &directive) - continue - } - // `5` - if makeLayoutRegexp(layoutValue, desc.valuePattern).MatchString(snormal) { - directive.kind = one - directive.first = desc.atoi(snormal) - directives = append(directives, &directive) - continue - } - // `5-20` - pairs := makeLayoutRegexp(layoutRange, desc.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - directive.kind = span - directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) - directive.last = desc.atoi(snormal[pairs[4]:pairs[5]]) - directive.step = 1 - directives = append(directives, &directive) - continue - } - // `*/2` - pairs = makeLayoutRegexp(layoutWildcardAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - directive.kind = span - directive.first = desc.min - directive.last = desc.max - directive.step = atoi(snormal[pairs[2]:pairs[3]]) - directives = append(directives, &directive) - continue - } - // `5/2` - pairs = makeLayoutRegexp(layoutValueAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - directive.kind = span - directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) - directive.last = desc.max - directive.step = atoi(snormal[pairs[4]:pairs[5]]) - directives = append(directives, &directive) - continue - } - // `5-20/2` - pairs = makeLayoutRegexp(layoutRangeAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - directive.kind = span - directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) - directive.last = desc.atoi(snormal[pairs[4]:pairs[5]]) - directive.step = atoi(snormal[pairs[6]:pairs[7]]) - directives = append(directives, &directive) - continue - } - // No behavior for this one, let caller deal with it - directive.kind = none - directives = append(directives, &directive) - } - return directives, nil -} - -/******************************************************************************/ - -func populateOne(values map[int]bool, v int) { - values[v] = true -} - -func populateMany(values map[int]bool, min, max, step int) { - for i := min; i <= max; i += step { - values[i] = true - } -} - -func toList(set map[int]bool) []int { - list := make([]int, len(set)) - i := 0 - for k := range set { - list[i] = k - i += 1 - } - sort.Ints(list) - return list -} - -/******************************************************************************/ - -func makeLayoutRegexp(layout, value string) *regexp.Regexp { - layout = strings.Replace(layout, `%value%`, value, -1) - re := layoutRegexp[layout] - if re == nil { - re = regexp.MustCompile(layout) - layoutRegexp[layout] = re - } - return re -} diff --git a/cronexpr_parse.go b/cronexpr_parse.go index cdf4ba3..fd02482 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -2,7 +2,7 @@ * Copyright 2013 Raymond Hill * * Project: github.com/gorhill/cronexpr - * File: cronexpr_parser.go + * File: cronexpr_parse.go * Version: 1.0 * License: GPL v3 see * From 17ea23bf089ae0ce23afe7ea3294524d7a3d36e4 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sun, 8 Sep 2013 10:37:12 -0400 Subject: [PATCH 080/105] further tidying --- README.md | 8 +- cronexpr.go | 20 +++-- cronexpr_next.go | 192 +++++++++++++++++++++++----------------------- cronexpr_parse.go | 46 +++++------ 4 files changed, 139 insertions(+), 127 deletions(-) diff --git a/README.md b/README.md index f3d4a9b..48c8662 100644 --- a/README.md +++ b/README.md @@ -39,7 +39,13 @@ Hyphens define ranges. For example, 2000-2010 indicates every year between 2000 `L` stands for "last". When used in the day-of-week field, it allows you to specify constructs such as "the last Friday" (`5L`) of a given month. In the day-of-month field, it specifies the last day of the month. #### W -The `W` character is allowed for the day-of-month field. This character is used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify `15W` as the value for the day-of-month field, the meaning is: "the nearest weekday to the 15th of the month." So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th is a Sunday, the trigger fires on Monday the 16th. If the 15th is a Tuesday, then it fires on Tuesday the 15th. However if you specify `1W` as the value for day-of-month, and the 1st is a Saturday, the trigger fires on Monday the 3rd, as it does not 'jump' over the boundary of a month's days. The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. +The `W` character is allowed for the day-of-month field. This character is used to specify the business day (Monday-Friday) nearest the given day. As an example, if you were to specify `15W` as the value for the day-of-month field, the meaning is: "the nearest business day to the 15th of the month." + +So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th is a Sunday, the trigger fires on Monday the 16th. If the 15th is a Tuesday, then it fires on Tuesday the 15th. However if you specify `1W` as the value for day-of-month, and the 1st is a Saturday, the trigger fires on Monday the 3rd, as it does not 'jump' over the boundary of a month's days. + +The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. + +The `W` character can also be combined with `L` to mean "the last business day of the month." #### Hash ( # ) `#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. diff --git a/cronexpr.go b/cronexpr.go index 5189e0f..bad9553 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -70,16 +70,22 @@ func Parse(cronLine string) (*Expression, error) { cron := cronNormalizer.Replace(cronLine) indices := fieldFinder.FindAllStringIndex(cron, -1) - if len(indices) < 5 { + fieldCount := len(indices) + if fieldCount < 5 { return nil, fmt.Errorf("missing field(s)") } + // ignore fields beyond 7th + if fieldCount > 7 { + fieldCount = 7 + } - expr := Expression{} - field := 0 + var expr = Expression{} + var field = 0 + var err error // second field (optional) - if len(indices) >= 7 { - err := expr.secondFieldHandler(cron[indices[field][0]:indices[field][1]]) + if fieldCount == 7 { + err = expr.secondFieldHandler(cron[indices[field][0]:indices[field][1]]) if err != nil { return nil, err } @@ -89,7 +95,7 @@ func Parse(cronLine string) (*Expression, error) { } // minute field - err := expr.minuteFieldHandler(cron[indices[field][0]:indices[field][1]]) + err = expr.minuteFieldHandler(cron[indices[field][0]:indices[field][1]]) if err != nil { return nil, err } @@ -124,7 +130,7 @@ func Parse(cronLine string) (*Expression, error) { field += 1 // year field - if field < len(indices) { + if field < fieldCount { err = expr.yearFieldHandler(cron[indices[field][0]:indices[field][1]]) if err != nil { return nil, err diff --git a/cronexpr_next.go b/cronexpr_next.go index 819df19..19f0ac2 100644 --- a/cronexpr_next.go +++ b/cronexpr_next.go @@ -86,102 +86,6 @@ func (expr *Expression) nextMonth(t time.Time) time.Time { /******************************************************************************/ -func workdayOfMonth(targetDom, lastDom time.Time) int { - dom := targetDom.Day() - dow := targetDom.Weekday() - // If saturday, then friday - if dow == time.Saturday { - if dom > 1 { - dom -= 1 - } else { - dom += 2 - } - // If sunday, then monday - } else if dow == time.Sunday { - if dom < lastDom.Day() { - dom += 1 - } else { - dom -= 2 - } - } - return dom -} - -func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { - actualDaysOfMonthMap := make(map[int]bool) - firstDayOfMonth := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) - lastDayOfMonth := firstDayOfMonth.AddDate(0, 1, -1) - - // As per crontab man page (http://linux.die.net/man/5/crontab#): - // "The day of a command's execution can be specified by two - // "fields - day of month, and day of week. If both fields are - // "restricted (ie, aren't *), the command will be run when - // "either field matches the current time" - if expr.daysOfMonthRestricted || expr.daysOfWeekRestricted == false { - // Last day of month - if expr.lastDayOfMonth { - actualDaysOfMonthMap[lastDayOfMonth.Day()] = true - } - // Last work day of month - if expr.lastWorkdayOfMonth { - actualDaysOfMonthMap[workdayOfMonth(lastDayOfMonth, lastDayOfMonth)] = true - } - // Days of month - for v := range expr.daysOfMonth { - // Ignore days beyond end of month - if v <= lastDayOfMonth.Day() { - actualDaysOfMonthMap[v] = true - } - } - // Work days of month - // As per Wikipedia: month boundaries are not crossed. - for v := range expr.workdaysOfMonth { - // Ignore days beyond end of month - if v <= lastDayOfMonth.Day() { - actualDaysOfMonthMap[workdayOfMonth(firstDayOfMonth.AddDate(0, 0, v-1), lastDayOfMonth)] = true - } - } - } - - if expr.daysOfWeekRestricted { - // How far first sunday is from first day of month - offset := 7 - int(firstDayOfMonth.Weekday()) - // days of week - // offset : (7 - day_of_week_of_1st_day_of_month) - // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for w := 0; w <= 4; w += 1 { - for v := range expr.daysOfWeek { - v := 1 + w*7 + (offset+v)%7 - if v <= lastDayOfMonth.Day() { - actualDaysOfMonthMap[v] = true - } - } - } - // days of week of specific week in the month - // offset : (7 - day_of_week_of_1st_day_of_month) - // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for v := range expr.specificWeekDaysOfWeek { - v := 1 + 7*(v/7) + (offset+v)%7 - if v <= lastDayOfMonth.Day() { - actualDaysOfMonthMap[v] = true - } - } - // Last days of week of the month - lastWeekOrigin := firstDayOfMonth.AddDate(0, 1, -7) - offset = 7 - int(lastWeekOrigin.Weekday()) - for v := range expr.lastWeekDaysOfWeek { - v := lastWeekOrigin.Day() + (offset+v)%7 - if v <= lastDayOfMonth.Day() { - actualDaysOfMonthMap[v] = true - } - } - } - - return toList(actualDaysOfMonthMap) -} - -/******************************************************************************/ - func (expr *Expression) nextDayOfMonth(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate day of month @@ -266,3 +170,99 @@ func (expr *Expression) nextSecond(t time.Time) time.Time { 0, t.Location()) } + +/******************************************************************************/ + +func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { + actualDaysOfMonthMap := make(map[int]bool) + firstDayOfMonth := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.UTC) + lastDayOfMonth := firstDayOfMonth.AddDate(0, 1, -1) + + // As per crontab man page (http://linux.die.net/man/5/crontab#): + // "The day of a command's execution can be specified by two + // "fields - day of month, and day of week. If both fields are + // "restricted (ie, aren't *), the command will be run when + // "either field matches the current time" + if expr.daysOfMonthRestricted || expr.daysOfWeekRestricted == false { + // Last day of month + if expr.lastDayOfMonth { + actualDaysOfMonthMap[lastDayOfMonth.Day()] = true + } + // Last work day of month + if expr.lastWorkdayOfMonth { + actualDaysOfMonthMap[workdayOfMonth(lastDayOfMonth, lastDayOfMonth)] = true + } + // Days of month + for v := range expr.daysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[v] = true + } + } + // Work days of month + // As per Wikipedia: month boundaries are not crossed. + for v := range expr.workdaysOfMonth { + // Ignore days beyond end of month + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[workdayOfMonth(firstDayOfMonth.AddDate(0, 0, v-1), lastDayOfMonth)] = true + } + } + } + + if expr.daysOfWeekRestricted { + // How far first sunday is from first day of month + offset := 7 - int(firstDayOfMonth.Weekday()) + // days of week + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 + for w := 0; w <= 4; w += 1 { + for v := range expr.daysOfWeek { + v := 1 + w*7 + (offset+v)%7 + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[v] = true + } + } + } + // days of week of specific week in the month + // offset : (7 - day_of_week_of_1st_day_of_month) + // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 + for v := range expr.specificWeekDaysOfWeek { + v := 1 + 7*(v/7) + (offset+v)%7 + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[v] = true + } + } + // Last days of week of the month + lastWeekOrigin := firstDayOfMonth.AddDate(0, 1, -7) + offset = 7 - int(lastWeekOrigin.Weekday()) + for v := range expr.lastWeekDaysOfWeek { + v := lastWeekOrigin.Day() + (offset+v)%7 + if v <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[v] = true + } + } + } + + return toList(actualDaysOfMonthMap) +} + +func workdayOfMonth(targetDom, lastDom time.Time) int { + dom := targetDom.Day() + dow := targetDom.Weekday() + // If saturday, then friday + if dow == time.Saturday { + if dom > 1 { + dom -= 1 + } else { + dom += 2 + } + // If sunday, then monday + } else if dow == time.Sunday { + if dom < lastDom.Day() { + dom += 1 + } else { + dom -= 2 + } + } + return dom +} diff --git a/cronexpr_parse.go b/cronexpr_parse.go index fd02482..f7df2b5 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -371,6 +371,29 @@ func (expr *Expression) domFieldHandler(s string) error { /******************************************************************************/ +func populateOne(values map[int]bool, v int) { + values[v] = true +} + +func populateMany(values map[int]bool, min, max, step int) { + for i := min; i <= max; i += step { + values[i] = true + } +} + +func toList(set map[int]bool) []int { + list := make([]int, len(set)) + i := 0 + for k := range set { + list[i] = k + i += 1 + } + sort.Ints(list) + return list +} + +/******************************************************************************/ + func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) { // At least one entry must be present indices := entryFinder.FindAllStringIndex(s, -1) @@ -451,29 +474,6 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) /******************************************************************************/ -func populateOne(values map[int]bool, v int) { - values[v] = true -} - -func populateMany(values map[int]bool, min, max, step int) { - for i := min; i <= max; i += step { - values[i] = true - } -} - -func toList(set map[int]bool) []int { - list := make([]int, len(set)) - i := 0 - for k := range set { - list[i] = k - i += 1 - } - sort.Ints(list) - return list -} - -/******************************************************************************/ - func makeLayoutRegexp(layout, value string) *regexp.Regexp { layout = strings.Replace(layout, `%value%`, value, -1) re := layoutRegexp[layout] From b4282cae901ecf025ed8d779cb06b2d2c2adfc85 Mon Sep 17 00:00:00 2001 From: gorhill Date: Sun, 8 Sep 2013 10:40:27 -0400 Subject: [PATCH 081/105] LW --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 48c8662..ae23c2e 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,7 @@ So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. -The `W` character can also be combined with `L` to mean "the last business day of the month." +The `W` character can also be combined with `L`, i.e. `LW` to mean "the last business day of the month." #### Hash ( # ) `#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. From 0766840399e458c23ed9d19fe0bbc9d27f37e2ec Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 9 Sep 2013 08:48:39 -0400 Subject: [PATCH 082/105] moving command line utility here --- cronexpr | 1 + 1 file changed, 1 insertion(+) create mode 160000 cronexpr diff --git a/cronexpr b/cronexpr new file mode 160000 index 0000000..94e0d0c --- /dev/null +++ b/cronexpr @@ -0,0 +1 @@ +Subproject commit 94e0d0c22be668b2f4ae6ab23633e8b78d7973e6 From 2323c4aca074c7c4f4e5f086f1d50478261d6e3c Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 9 Sep 2013 08:58:09 -0400 Subject: [PATCH 083/105] oops --- cronexpr | 1 - 1 file changed, 1 deletion(-) delete mode 160000 cronexpr diff --git a/cronexpr b/cronexpr deleted file mode 160000 index 94e0d0c..0000000 --- a/cronexpr +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 94e0d0c22be668b2f4ae6ab23633e8b78d7973e6 From ec79af33a849e4b5f0814b0ce531c7500c90ffe6 Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 9 Sep 2013 09:02:32 -0400 Subject: [PATCH 084/105] moving command line utility here --- README.md | 2 +- cronexpr/README.md | 122 +++++++++++++++++++++++++++++++++++++++++++++ cronexpr/main.go | 111 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 234 insertions(+), 1 deletion(-) create mode 100644 cronexpr/README.md create mode 100644 cronexpr/main.go diff --git a/README.md b/README.md index ae23c2e..c5219f1 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ In another project, I decided to use cron expression syntax to encode scheduling The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. -There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). +There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). Implementation -------------- diff --git a/cronexpr/README.md b/cronexpr/README.md new file mode 100644 index 0000000..685c278 --- /dev/null +++ b/cronexpr/README.md @@ -0,0 +1,122 @@ +cronexpr: command-line utility +============================== + +A command-line utility written in Go to evaluate cron time expressions. + +It is based on the standalone Go library . + +## Install + + go get github.com/gorhill/cronexpr + go install github.com/gorhill/cronexpr + +## Usage + + cronexpr [options] "{cron expression}" + +## Options + +`-l`: + +Go-compliant time layout to use for outputting time value(s), see . + +Default is `"Mon, 02 Jan 2006 15:04:05 MST"` + +`-n`: + +Number of resulting time values to output. + +Default is 1. + +`-t`: + +Whole or partial RFC3339 time value (i.e. `2006-01-02T15:04:05Z07:00`) against which the cron expression is evaluated. Examples of valid values include (assuming EST time zone): + +`13` = 2013-01-01T00:00:00-05:00 +`2013` = 2013-01-01T00:00:00-05:00 +`2013-08` = 2013-08-01T00:00:00-05:00 +`2013-08-31` = 2013-08-31T00:00:00-05:00 +`2013-08-31T12` = 2013-08-31T12:00:00-05:00 +`2013-08-31T12:40` = 2013-08-31T12:40:00-05:00 +`2013-08-31T12:40:35` = 2013-08-31T12:40:35-05:00 +`2013-08-31T12:40:35-10:00` = 2013-08-31T12:40:35-10:00 + +Default time is current time, and default time zone is local time zone. + +## Examples + +#### Example 1 + +Midnight on December 31st of any year. + +Command: + + cronexpr -t="2013-08-31" -n=5 "0 0 31 12 *" + +Output (assuming computer is in EST time zone): + + # "0 0 31 12 *" + "2013-08-31T00:00:00-04:00" = + Tue, 31 Dec 2013 00:00:00 EST + Wed, 31 Dec 2014 00:00:00 EST + Thu, 31 Dec 2015 00:00:00 EST + Sat, 31 Dec 2016 00:00:00 EST + Sun, 31 Dec 2017 00:00:00 EST + +#### Example 2 + +2pm on February 29th of any year. + +Command: + + cronexpr -t=2000 -n=10 "0 14 29 2 *" + +Output (assuming computer is in EST time zone): + + # "0 14 29 2 *" + "2000-01-01T00:00:00-05:00" = + Tue, 29 Feb 2000 14:00:00 EST + Sun, 29 Feb 2004 14:00:00 EST + Fri, 29 Feb 2008 14:00:00 EST + Wed, 29 Feb 2012 14:00:00 EST + Mon, 29 Feb 2016 14:00:00 EST + Sat, 29 Feb 2020 14:00:00 EST + Thu, 29 Feb 2024 14:00:00 EST + Tue, 29 Feb 2028 14:00:00 EST + Sun, 29 Feb 2032 14:00:00 EST + Fri, 29 Feb 2036 14:00:00 EST + +#### Example 3 + +12pm on the work day closest to the 15th of March and every three month +thereafter. + +Command: + + cronexpr -t=2013-09-01 -n=5 "0 12 15W 3/3 *" + +Output (assuming computer is in EST time zone): + + # "0 12 15W 3/3 *" + "2013-09-01T00:00:00-04:00" = + Mon, 16 Sep 2013 12:00:00 EDT + Mon, 16 Dec 2013 12:00:00 EST + Fri, 14 Mar 2014 12:00:00 EDT + Mon, 16 Jun 2014 12:00:00 EDT + Mon, 15 Sep 2014 12:00:00 EDT + +#### Example 4 + +Midnight on the fifth Saturday of any month (twist: not all months have a 5th +specific day of week). + +Command: + + cronexpr -t=2013-09-02 -n 5 "0 0 * * 6#5" + +Output (assuming computer is in EST time zone): + + # "0 0 * * 6#5" + "2013-09-02T00:00:00-04:00" = + Sat, 30 Nov 2013 00:00:00 EST + Sat, 29 Mar 2014 00:00:00 EDT + Sat, 31 May 2014 00:00:00 EDT + Sat, 30 Aug 2014 00:00:00 EDT + Sat, 29 Nov 2014 00:00:00 EST + diff --git a/cronexpr/main.go b/cronexpr/main.go new file mode 100644 index 0000000..c6c8b91 --- /dev/null +++ b/cronexpr/main.go @@ -0,0 +1,111 @@ +/*! + * Copyright 2013 Raymond Hill + * + * Project: github.com/gorhill/cronexprdo + * File: main.go + * Version: 1.0 + * License: GPL v3 see + * + */ + +package main + +/******************************************************************************/ + +import ( + "flag" + "fmt" + "os" + "time" + + "github.com/gorhill/cronexpr" +) + +/******************************************************************************/ + +var ( + usage = func() { + fmt.Fprintf(os.Stderr, "usage:\n %s [options] \"{cron expression}\"\noptions:\n", os.Args[0]) + flag.PrintDefaults() + } + inTimeStr string + outTimeCount uint + outTimeLayout string +) + +/******************************************************************************/ + +func main() { + var err error + + flag.Usage = usage + flag.StringVar(&inTimeStr, "t", "", `whole or partial RFC3339 time value (i.e. "2006-01-02T15:04:05Z07:00") against which the cron expression is evaluated, now if not present`) + flag.UintVar(&outTimeCount, "n", 1, `number of resulting time values to output`) + flag.StringVar(&outTimeLayout, "l", "Mon, 02 Jan 2006 15:04:05 MST", `Go-compliant time layout to use for outputting time value(s), see `) + flag.Parse() + + cronStr := flag.Arg(0) + if len(cronStr) == 0 { + flag.Usage() + return + } + + inTime := time.Now() + inTimeLayout := "" + timeStrLen := len(inTimeStr) + if timeStrLen == 2 { + inTimeLayout = "06" + } else if timeStrLen >= 4 { + inTimeLayout += "2006" + if timeStrLen >= 7 { + inTimeLayout += "-01" + if timeStrLen >= 10 { + inTimeLayout += "-02" + if timeStrLen >= 13 { + inTimeLayout += "T15" + if timeStrLen >= 16 { + inTimeLayout += ":04" + if timeStrLen >= 19 { + inTimeLayout += ":05" + if timeStrLen >= 20 { + inTimeLayout += "Z07:00" + } + } + } + } + } + } + } + + if len(inTimeLayout) > 0 { + // default to local time zone + if timeStrLen < 20 { + inTime, err = time.ParseInLocation(inTimeLayout, inTimeStr, time.Local) + } else { + inTime, err = time.Parse(inTimeLayout, inTimeStr) + } + if err != nil { + fmt.Fprintf(os.Stderr, "# error: unparseable time value: \"%s\"\n", inTimeStr) + os.Exit(1) + } + } + + expr, err := cronexpr.Parse(cronStr) + if err != nil { + fmt.Fprintf(os.Stderr, "# %s: %s\n", os.Args[0], err) + os.Exit(1) + } + + // Anything on the output which starts with '#' can be ignored if the caller + // is interested only in the time values. There is only one time + // value per line, and they are always in chronological ascending order. + fmt.Printf("# \"%s\" + \"%s\" =\n", cronStr, inTime.Format(time.RFC3339)) + + if outTimeCount < 1 { + outTimeCount = 1 + } + outTimes := expr.NextN(inTime, outTimeCount) + for _, outTime := range outTimes { + fmt.Println(outTime.Format(outTimeLayout)) + } +} From 4a303f4d72f119243ce58ef7652f085b03c1df2a Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 9 Sep 2013 09:30:28 -0400 Subject: [PATCH 085/105] name --- LICENSE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LICENSE b/LICENSE index 0a2023c..c13fcfa 100644 --- a/LICENSE +++ b/LICENSE @@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: - gocronexpression Copyright (C) 2013 Raymond Hill + cronexpr Copyright (C) 2013 Raymond Hill This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. From 2fc5c1e2856dd593132477468932b20449e6d23a Mon Sep 17 00:00:00 2001 From: gorhill Date: Mon, 9 Sep 2013 09:30:44 -0400 Subject: [PATCH 086/105] tab --- cronexpr_next.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cronexpr_next.go b/cronexpr_next.go index 19f0ac2..be7d7ca 100644 --- a/cronexpr_next.go +++ b/cronexpr_next.go @@ -256,7 +256,7 @@ func workdayOfMonth(targetDom, lastDom time.Time) int { } else { dom += 2 } - // If sunday, then monday + // If sunday, then monday } else if dow == time.Sunday { if dom < lastDom.Day() { dom += 1 From 0e96f1237756d74abdbda3ab882cd15f5a0f00e1 Mon Sep 17 00:00:00 2001 From: gorhill Date: Tue, 10 Sep 2013 16:09:51 -0400 Subject: [PATCH 087/105] #6: added simple test to avoid work --- cronexpr_next.go | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/cronexpr_next.go b/cronexpr_next.go index be7d7ca..84b136c 100644 --- a/cronexpr_next.go +++ b/cronexpr_next.go @@ -183,7 +183,14 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { // "fields - day of month, and day of week. If both fields are // "restricted (ie, aren't *), the command will be run when // "either field matches the current time" - if expr.daysOfMonthRestricted || expr.daysOfWeekRestricted == false { + + // If both fields are not restricted, all days of the month are a hit + if expr.daysOfMonthRestricted == false && expr.daysOfWeekRestricted == false { + return genericDefaultList[1 : lastDayOfMonth.Day()+1] + } + + // day-of-month != `*` + if expr.daysOfMonthRestricted { // Last day of month if expr.lastDayOfMonth { actualDaysOfMonthMap[lastDayOfMonth.Day()] = true @@ -209,6 +216,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { } } + // day-of-week != `*` if expr.daysOfWeekRestricted { // How far first sunday is from first day of month offset := 7 - int(firstDayOfMonth.Weekday()) @@ -256,7 +264,7 @@ func workdayOfMonth(targetDom, lastDom time.Time) int { } else { dom += 2 } - // If sunday, then monday + // If sunday, then monday } else if dow == time.Sunday { if dom < lastDom.Day() { dom += 1 From 09aefb5f32b5e0d6d22a8894611dd4f04a19019d Mon Sep 17 00:00:00 2001 From: gorhill Date: Wed, 11 Sep 2013 11:18:45 -0400 Subject: [PATCH 088/105] use precalculated dow offsets --- cronexpr_next.go | 34 ++++++++++++++++++++++++---------- 1 file changed, 24 insertions(+), 10 deletions(-) diff --git a/cronexpr_next.go b/cronexpr_next.go index 84b136c..169c900 100644 --- a/cronexpr_next.go +++ b/cronexpr_next.go @@ -19,6 +19,18 @@ import ( /******************************************************************************/ +var dowNormalizedOffsets = [][]int{ + {1, 8, 15, 22, 29}, + {2, 9, 16, 23, 30}, + {3, 10, 17, 24, 31}, + {4, 11, 18, 25}, + {5, 12, 19, 26}, + {6, 13, 20, 27}, + {7, 14, 21, 28}, +} + +/******************************************************************************/ + func (expr *Expression) nextYear(t time.Time) time.Time { // Find index at which item in list is greater or equal to // candidate year @@ -223,19 +235,21 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { // days of week // offset : (7 - day_of_week_of_1st_day_of_month) // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 - for w := 0; w <= 4; w += 1 { - for v := range expr.daysOfWeek { - v := 1 + w*7 + (offset+v)%7 - if v <= lastDayOfMonth.Day() { - actualDaysOfMonthMap[v] = true - } + for v := range expr.daysOfWeek { + w := dowNormalizedOffsets[offset%7+v] + actualDaysOfMonthMap[w[0]] = true + actualDaysOfMonthMap[w[1]] = true + actualDaysOfMonthMap[w[2]] = true + actualDaysOfMonthMap[w[3]] = true + if len(w) > 4 && w[4] <= lastDayOfMonth.Day() { + actualDaysOfMonthMap[w[4]] = true } } // days of week of specific week in the month // offset : (7 - day_of_week_of_1st_day_of_month) // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 for v := range expr.specificWeekDaysOfWeek { - v := 1 + 7*(v/7) + (offset+v)%7 + v = 1 + 7*(v/7) + (offset+v)%7 if v <= lastDayOfMonth.Day() { actualDaysOfMonthMap[v] = true } @@ -244,7 +258,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { lastWeekOrigin := firstDayOfMonth.AddDate(0, 1, -7) offset = 7 - int(lastWeekOrigin.Weekday()) for v := range expr.lastWeekDaysOfWeek { - v := lastWeekOrigin.Day() + (offset+v)%7 + v = lastWeekOrigin.Day() + (offset+v)%7 if v <= lastDayOfMonth.Day() { actualDaysOfMonthMap[v] = true } @@ -255,16 +269,16 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { } func workdayOfMonth(targetDom, lastDom time.Time) int { + // If saturday, then friday + // If sunday, then monday dom := targetDom.Day() dow := targetDom.Weekday() - // If saturday, then friday if dow == time.Saturday { if dom > 1 { dom -= 1 } else { dom += 2 } - // If sunday, then monday } else if dow == time.Sunday { if dom < lastDom.Day() { dom += 1 From 8c982ee625fecfa60dbc663372278220cdf87f51 Mon Sep 17 00:00:00 2001 From: gorhill Date: Wed, 11 Sep 2013 11:24:07 -0400 Subject: [PATCH 089/105] oops, fixed bug introduced by last change, added test case --- cronexpr_next.go | 2 +- cronexpr_test.go | 11 ++++++++++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/cronexpr_next.go b/cronexpr_next.go index 169c900..1d627b4 100644 --- a/cronexpr_next.go +++ b/cronexpr_next.go @@ -236,7 +236,7 @@ func (expr *Expression) calculateActualDaysOfMonth(year, month int) []int { // offset : (7 - day_of_week_of_1st_day_of_month) // target : 1 + (7 * week_of_month) + (offset + day_of_week) % 7 for v := range expr.daysOfWeek { - w := dowNormalizedOffsets[offset%7+v] + w := dowNormalizedOffsets[(offset+v)%7] actualDaysOfMonthMap[w[0]] = true actualDaysOfMonthMap[w[1]] = true actualDaysOfMonthMap[w[2]] = true diff --git a/cronexpr_test.go b/cronexpr_test.go index 32467fb..3692227 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -106,8 +106,17 @@ var crontests = []crontest{ {"2013-12-30 00:30:00", "Mon 2014-01-06 00:00"}, }, }, + { + "0 0 * * friday", + "Mon 2006-01-02 15:04", + []crontimes{ + {"2013-01-01 00:00:00", "Fri 2013-01-04 00:00"}, + {"2013-01-28 00:00:00", "Fri 2013-02-01 00:00"}, + {"2013-12-30 00:30:00", "Fri 2014-01-03 00:00"}, + }, + }, - // Specific weekdays of week + // Specific days of week { "0 0 * * 6#5", "Mon 2006-01-02 15:04", From e1010b5ee12a0d02b5fd7241980c2552d264c639 Mon Sep 17 00:00:00 2001 From: gorhill Date: Wed, 11 Sep 2013 19:37:42 -0400 Subject: [PATCH 090/105] added test --- cronexpr_test.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/cronexpr_test.go b/cronexpr_test.go index 3692227..9be7eff 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -115,6 +115,15 @@ var crontests = []crontest{ {"2013-12-30 00:30:00", "Fri 2014-01-03 00:00"}, }, }, + { + "0 0 * * 6,7", + "Mon 2006-01-02 15:04", + []crontimes{ + {"2013-01-01 00:00:00", "Sat 2013-01-05 00:00"}, + {"2013-01-28 00:00:00", "Sat 2013-02-02 00:00"}, + {"2013-12-30 00:30:00", "Sat 2014-01-04 00:00"}, + }, + }, // Specific days of week { From 28ed96782654cf68b950f4d12be68cc731befcef Mon Sep 17 00:00:00 2001 From: gorhill Date: Thu, 26 Sep 2013 11:42:53 -0400 Subject: [PATCH 091/105] trivial doc fix --- README.md | 2 +- cronexpr/main.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c5219f1..9561a96 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ In another project, I decided to use cron expression syntax to encode scheduling The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. -There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). +There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). Implementation -------------- diff --git a/cronexpr/main.go b/cronexpr/main.go index c6c8b91..1d9abe5 100644 --- a/cronexpr/main.go +++ b/cronexpr/main.go @@ -1,7 +1,7 @@ /*! * Copyright 2013 Raymond Hill * - * Project: github.com/gorhill/cronexprdo + * Project: github.com/gorhill/cronexpr * File: main.go * Version: 1.0 * License: GPL v3 see From 0ef34dac9b8833981714b667c15cccefd53647c0 Mon Sep 17 00:00:00 2001 From: gorhill Date: Wed, 20 Nov 2013 06:10:35 -0500 Subject: [PATCH 092/105] now also aplv2 --- README.md | 9 +++++++++ cronexpr.go | 4 +++- cronexpr_next.go | 4 +++- cronexpr_parse.go | 4 +++- cronexpr_test.go | 4 +++- 5 files changed, 21 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 9561a96..e8c56d2 100644 --- a/README.md +++ b/README.md @@ -123,3 +123,12 @@ returned. API --- + +License +------- + +License: pick the one which suits you best: + +- GPL v3 see +- APL v2 see + diff --git a/cronexpr.go b/cronexpr.go index bad9553..58b518f 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -4,7 +4,9 @@ * Project: github.com/gorhill/cronexpr * File: cronexpr.go * Version: 1.0 - * License: GPL v3 see + * License: pick the one which suits you : + * GPL v3 see + * APL v2 see * */ diff --git a/cronexpr_next.go b/cronexpr_next.go index 1d627b4..a0ebdb6 100644 --- a/cronexpr_next.go +++ b/cronexpr_next.go @@ -4,7 +4,9 @@ * Project: github.com/gorhill/cronexpr * File: cronexpr_next.go * Version: 1.0 - * License: GPL v3 see + * License: pick the one which suits you : + * GPL v3 see + * APL v2 see * */ diff --git a/cronexpr_parse.go b/cronexpr_parse.go index f7df2b5..2a0e5bc 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -4,7 +4,9 @@ * Project: github.com/gorhill/cronexpr * File: cronexpr_parse.go * Version: 1.0 - * License: GPL v3 see + * License: pick the one which suits you best: + * GPL v3 see + * APL v2 see * */ diff --git a/cronexpr_test.go b/cronexpr_test.go index 9be7eff..20c75c3 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -4,7 +4,9 @@ * Project: github.com/gorhill/cronexpr * File: cronexpr_test.go * Version: 1.0 - * License: GPL v3 see + * License: pick the one which suits you best: + * GPL v3 see + * APL v2 see * */ From f2ed51895e098fa8d1ec216d7c8ef4ee9f8a5b01 Mon Sep 17 00:00:00 2001 From: gorhill Date: Wed, 20 Nov 2013 06:15:47 -0500 Subject: [PATCH 093/105] copies of available licenses --- APLv2 | 202 +++++++++++++++++++++++++++++++++++++++++++++++ LICENSE => GPLv3 | 0 2 files changed, 202 insertions(+) create mode 100644 APLv2 rename LICENSE => GPLv3 (100%) diff --git a/APLv2 b/APLv2 new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/APLv2 @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/LICENSE b/GPLv3 similarity index 100% rename from LICENSE rename to GPLv3 From b0d44377d8f0c952ce8f0050452bd7564e50eac0 Mon Sep 17 00:00:00 2001 From: Safx Date: Wed, 23 Apr 2014 01:22:28 +0900 Subject: [PATCH 094/105] fixed parsering bug for like "*/5" --- cronexpr_parse.go | 23 ++++++++++++----------- cronexpr_test.go | 38 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+), 11 deletions(-) diff --git a/cronexpr_parse.go b/cronexpr_parse.go index 2a0e5bc..a1ab438 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -411,6 +411,17 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) send: indices[i][1], } snormal := strings.ToLower(s[indices[i][0]:indices[i][1]]) + + // `*/2` + pairs := makeLayoutRegexp(layoutWildcardAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.min + directive.last = desc.max + directive.step = atoi(snormal[pairs[2]:pairs[3]]) + directives = append(directives, &directive) + continue + } // `*` if makeLayoutRegexp(layoutWildcard, desc.valuePattern).MatchString(snormal) { directive.kind = all @@ -428,7 +439,7 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) continue } // `5-20` - pairs := makeLayoutRegexp(layoutRange, desc.valuePattern).FindStringSubmatchIndex(snormal) + pairs = makeLayoutRegexp(layoutRange, desc.valuePattern).FindStringSubmatchIndex(snormal) if len(pairs) > 0 { directive.kind = span directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) @@ -437,16 +448,6 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) directives = append(directives, &directive) continue } - // `*/2` - pairs = makeLayoutRegexp(layoutWildcardAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - directive.kind = span - directive.first = desc.min - directive.last = desc.max - directive.step = atoi(snormal[pairs[2]:pairs[3]]) - directives = append(directives, &directive) - continue - } // `5/2` pairs = makeLayoutRegexp(layoutValueAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) if len(pairs) > 0 { diff --git a/cronexpr_test.go b/cronexpr_test.go index 20c75c3..b729170 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -50,6 +50,21 @@ var crontests = []crontest{ }, }, + // every 5 Second + { + "*/5 * * * * * *", + "2006-01-02 15:04:05", + []crontimes{ + {"2013-01-01 00:00:00", "2013-01-01 00:00:05"}, + {"2013-01-01 00:00:59", "2013-01-01 00:01:00"}, + {"2013-01-01 00:59:59", "2013-01-01 01:00:00"}, + {"2013-01-01 23:59:59", "2013-01-02 00:00:00"}, + {"2013-02-28 23:59:59", "2013-03-01 00:00:00"}, + {"2016-02-28 23:59:59", "2016-02-29 00:00:00"}, + {"2012-12-31 23:59:59", "2013-01-01 00:00:00"}, + }, + }, + // Minutes { "* * * * *", @@ -246,6 +261,29 @@ func TestNextN(t *testing.T) { } } +func TestNextN_every5min(t *testing.T) { + expected := []string{ + "Mon, 2 Sep 2013 08:45:00", + "Mon, 2 Sep 2013 08:50:00", + "Mon, 2 Sep 2013 08:55:00", + "Mon, 2 Sep 2013 09:00:00", + "Mon, 2 Sep 2013 09:05:00", + } + from, _ := time.Parse("2006-01-02 15:04:05", "2013-09-02 08:44:32") + result := cronexpr.MustParse("*/5 * * * *").NextN(from, uint(len(expected))) + if len(result) != len(expected) { + t.Errorf(`MustParse("*/5 * * * *").NextN("2013-09-02 08:44:30", 5):\n"`) + t.Errorf(` Expected %d returned time values but got %d instead`, len(expected), len(result)) + } + for i, next := range result { + nextStr := next.Format("Mon, 2 Jan 2006 15:04:05") + if nextStr != expected[i] { + t.Errorf(`MustParse("*/5 * * * *").NextN("2013-09-02 08:44:30", 5):\n"`) + t.Errorf(` result[%d]: expected "%s" but got "%s"`, i, expected[i], nextStr) + } + } +} + /******************************************************************************/ var benchmarkExpressions = []string{ From a557574d6c024ed6e36acc8b610f5f211c91568a Mon Sep 17 00:00:00 2001 From: gorhill Date: Wed, 23 Apr 2014 19:13:48 -0400 Subject: [PATCH 095/105] fixed regex, put back code block where it was --- cronexpr_parse.go | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/cronexpr_parse.go b/cronexpr_parse.go index a1ab438..289ad53 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -179,7 +179,7 @@ var ( /******************************************************************************/ var ( - layoutWildcard = `^\*|\?$` + layoutWildcard = `^\*$|^\?$` layoutValue = `^(%value%)$` layoutRange = `^(%value%)-(%value%)$` layoutWildcardAndInterval = `^\*/(\d+)$` @@ -412,16 +412,6 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) } snormal := strings.ToLower(s[indices[i][0]:indices[i][1]]) - // `*/2` - pairs := makeLayoutRegexp(layoutWildcardAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) - if len(pairs) > 0 { - directive.kind = span - directive.first = desc.min - directive.last = desc.max - directive.step = atoi(snormal[pairs[2]:pairs[3]]) - directives = append(directives, &directive) - continue - } // `*` if makeLayoutRegexp(layoutWildcard, desc.valuePattern).MatchString(snormal) { directive.kind = all @@ -439,7 +429,7 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) continue } // `5-20` - pairs = makeLayoutRegexp(layoutRange, desc.valuePattern).FindStringSubmatchIndex(snormal) + pairs := makeLayoutRegexp(layoutRange, desc.valuePattern).FindStringSubmatchIndex(snormal) if len(pairs) > 0 { directive.kind = span directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) @@ -448,6 +438,16 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) directives = append(directives, &directive) continue } + // `*/2` + pairs = makeLayoutRegexp(layoutWildcardAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) + if len(pairs) > 0 { + directive.kind = span + directive.first = desc.min + directive.last = desc.max + directive.step = atoi(snormal[pairs[2]:pairs[3]]) + directives = append(directives, &directive) + continue + } // `5/2` pairs = makeLayoutRegexp(layoutValueAndInterval, desc.valuePattern).FindStringSubmatchIndex(snormal) if len(pairs) > 0 { From 334aab8a030c0447c99b564767340d6136d0fc0f Mon Sep 17 00:00:00 2001 From: takumakanari Date: Wed, 16 Mar 2016 20:18:20 +0900 Subject: [PATCH 096/105] support 0N format for numeric field --- cronexpr_parse.go | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/cronexpr_parse.go b/cronexpr_parse.go index 289ad53..92d6078 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -54,6 +54,7 @@ var ( var ( numberTokens = map[string]int{ "0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, + "00": 0, "01": 1, "02": 2, "03": 3, "04": 4, "05": 5, "06": 6, "07": 7, "08": 8, "09": 9, "10": 10, "11": 11, "12": 12, "13": 13, "14": 14, "15": 15, "16": 16, "17": 17, "18": 18, "19": 19, "20": 20, "21": 21, "22": 22, "23": 23, "24": 24, "25": 25, "26": 26, "27": 27, "28": 28, "29": 29, "30": 30, "31": 31, "32": 32, "33": 33, "34": 34, "35": 35, "36": 36, "37": 37, "38": 38, "39": 39, @@ -119,7 +120,7 @@ var ( min: 0, max: 59, defaultList: genericDefaultList[0:60], - valuePattern: `[0-9]|[1-5][0-9]`, + valuePattern: `[0-9]|[1-5][0-9]|0[0-9]`, atoi: atoi, } minuteDescriptor = fieldDescriptor{ @@ -127,7 +128,7 @@ var ( min: 0, max: 59, defaultList: genericDefaultList[0:60], - valuePattern: `[0-9]|[1-5][0-9]`, + valuePattern: `[0-9]|[1-5][0-9]|0[0-9]`, atoi: atoi, } hourDescriptor = fieldDescriptor{ @@ -135,7 +136,7 @@ var ( min: 0, max: 23, defaultList: genericDefaultList[0:24], - valuePattern: `[0-9]|1[0-9]|2[0-3]`, + valuePattern: `[0-9]|1[0-9]|2[0-3]|0[0-9]`, atoi: atoi, } domDescriptor = fieldDescriptor{ @@ -143,7 +144,7 @@ var ( min: 1, max: 31, defaultList: genericDefaultList[1:32], - valuePattern: `[1-9]|[12][0-9]|3[01]`, + valuePattern: `[1-9]|[12][0-9]|3[01]|0[0-9]`, atoi: atoi, } monthDescriptor = fieldDescriptor{ @@ -151,7 +152,7 @@ var ( min: 1, max: 12, defaultList: genericDefaultList[1:13], - valuePattern: `[1-9]|1[012]|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|january|february|march|april|march|april|june|july|august|september|october|november|december`, + valuePattern: `[1-9]|1[012]|0[0-9]|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|january|february|march|april|march|april|june|july|august|september|october|november|december`, atoi: func(s string) int { return monthTokens[s] }, @@ -161,7 +162,7 @@ var ( min: 0, max: 6, defaultList: genericDefaultList[0:7], - valuePattern: `[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday`, + valuePattern: `[0-7]|0[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday`, atoi: func(s string) int { return dowTokens[s] }, From cfcb63815621b795db7d5d7b296ab24fa0c00af4 Mon Sep 17 00:00:00 2001 From: takumakanari Date: Fri, 18 Mar 2016 16:23:09 +0900 Subject: [PATCH 097/105] modify regex --- cronexpr_parse.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/cronexpr_parse.go b/cronexpr_parse.go index 92d6078..aeb8296 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -120,7 +120,7 @@ var ( min: 0, max: 59, defaultList: genericDefaultList[0:60], - valuePattern: `[0-9]|[1-5][0-9]|0[0-9]`, + valuePattern: `0?[0-9]|[1-5][0-9]`, atoi: atoi, } minuteDescriptor = fieldDescriptor{ @@ -128,7 +128,7 @@ var ( min: 0, max: 59, defaultList: genericDefaultList[0:60], - valuePattern: `[0-9]|[1-5][0-9]|0[0-9]`, + valuePattern: `0?[0-9]|[1-5][0-9]`, atoi: atoi, } hourDescriptor = fieldDescriptor{ @@ -136,7 +136,7 @@ var ( min: 0, max: 23, defaultList: genericDefaultList[0:24], - valuePattern: `[0-9]|1[0-9]|2[0-3]|0[0-9]`, + valuePattern: `0?[0-9]|1[0-9]|2[0-3]`, atoi: atoi, } domDescriptor = fieldDescriptor{ @@ -144,7 +144,7 @@ var ( min: 1, max: 31, defaultList: genericDefaultList[1:32], - valuePattern: `[1-9]|[12][0-9]|3[01]|0[0-9]`, + valuePattern: `0?[1-9]|[12][0-9]|3[01]`, atoi: atoi, } monthDescriptor = fieldDescriptor{ @@ -152,7 +152,7 @@ var ( min: 1, max: 12, defaultList: genericDefaultList[1:13], - valuePattern: `[1-9]|1[012]|0[0-9]|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|january|february|march|april|march|april|june|july|august|september|october|november|december`, + valuePattern: `0?[1-9]|1[012]|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|january|february|march|april|march|april|june|july|august|september|october|november|december`, atoi: func(s string) int { return monthTokens[s] }, @@ -162,7 +162,7 @@ var ( min: 0, max: 6, defaultList: genericDefaultList[0:7], - valuePattern: `[0-7]|0[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday`, + valuePattern: `0?[0-7]|sun|mon|tue|wed|thu|fri|sat|sunday|monday|tuesday|wednesday|thursday|friday|saturday`, atoi: func(s string) int { return dowTokens[s] }, From 86090e60c22fdb98fb7e0c80afd94deb09ac6299 Mon Sep 17 00:00:00 2001 From: xiaofan Date: Mon, 5 Dec 2016 11:16:12 +0800 Subject: [PATCH 098/105] fix 60 interval issue --- cronexpr_parse.go | 9 +++++++++ cronexpr_test.go | 23 +++++++++++++++++++++++ 2 files changed, 32 insertions(+) diff --git a/cronexpr_parse.go b/cronexpr_parse.go index aeb8296..be6ef17 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -446,6 +446,9 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) directive.first = desc.min directive.last = desc.max directive.step = atoi(snormal[pairs[2]:pairs[3]]) + if directive.step < 1 || directive.step > desc.max { + return nil, fmt.Errorf("invalid interval %s", snormal) + } directives = append(directives, &directive) continue } @@ -456,6 +459,9 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) directive.last = desc.max directive.step = atoi(snormal[pairs[4]:pairs[5]]) + if directive.step < 1 || directive.step > desc.max { + return nil, fmt.Errorf("invalid interval %s", snormal) + } directives = append(directives, &directive) continue } @@ -466,6 +472,9 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) directive.last = desc.atoi(snormal[pairs[4]:pairs[5]]) directive.step = atoi(snormal[pairs[6]:pairs[7]]) + if directive.step < 1 || directive.step > desc.max { + return nil, fmt.Errorf("invalid interval %s", snormal) + } directives = append(directives, &directive) continue } diff --git a/cronexpr_test.go b/cronexpr_test.go index b729170..f170769 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -284,6 +284,29 @@ func TestNextN_every5min(t *testing.T) { } } +// Issue: https://github.com/gorhill/cronexpr/issues/16 +func TestInterval_Interval60Issue(t *testing.T){ + _, err := cronexpr.Parse("*/60 * * * * *") + if err == nil { + t.Errorf("parsing with interval 60 should return err") + } + + _, err = cronexpr.Parse("*/61 * * * * *") + if err == nil { + t.Errorf("parsing with interval 61 should return err") + } + + _, err = cronexpr.Parse("2/60 * * * * *") + if err == nil { + t.Errorf("parsing with interval 60 should return err") + } + + _, err = cronexpr.Parse("2-20/61 * * * * *") + if err == nil { + t.Errorf("parsing with interval 60 should return err") + } +} + /******************************************************************************/ var benchmarkExpressions = []string{ From 675cac9b2d182dccb5ba8d5f8a0d5988df8a4394 Mon Sep 17 00:00:00 2001 From: Alex Dadgar Date: Fri, 15 Sep 2017 11:30:32 -0700 Subject: [PATCH 099/105] Allow library to be used in parallel This PR allows concurrent calls to Parse. Further it makes the test be part of the same package. Fixes https://github.com/gorhill/cronexpr/issues/26 --- cronexpr_parse.go | 5 +++++ cronexpr_test.go | 36 +++++++++++++++++------------------- example_test.go | 6 ++---- 3 files changed, 24 insertions(+), 23 deletions(-) diff --git a/cronexpr_parse.go b/cronexpr_parse.go index be6ef17..a9fe746 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -19,6 +19,7 @@ import ( "regexp" "sort" "strings" + "sync" ) /******************************************************************************/ @@ -194,6 +195,7 @@ var ( fieldFinder = regexp.MustCompile(`\S+`) entryFinder = regexp.MustCompile(`[^,]+`) layoutRegexp = make(map[string]*regexp.Regexp) + layoutRegexpLock sync.Mutex ) /******************************************************************************/ @@ -488,6 +490,9 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) /******************************************************************************/ func makeLayoutRegexp(layout, value string) *regexp.Regexp { + layoutRegexpLock.Lock() + defer layoutRegexpLock.Unlock() + layout = strings.Replace(layout, `%value%`, value, -1) re := layoutRegexp[layout] if re == nil { diff --git a/cronexpr_test.go b/cronexpr_test.go index f170769..6ccf7ab 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -10,15 +10,13 @@ * */ -package cronexpr_test +package cronexpr /******************************************************************************/ import ( "testing" "time" - - "github.com/gorhill/cronexpr" ) /******************************************************************************/ @@ -203,9 +201,9 @@ func TestExpressions(t *testing.T) { for _, test := range crontests { for _, times := range test.times { from, _ := time.Parse("2006-01-02 15:04:05", times.from) - expr, err := cronexpr.Parse(test.expr) + expr, err := Parse(test.expr) if err != nil { - t.Errorf(`cronexpr.Parse("%s") returned "%s"`, test.expr, err.Error()) + t.Errorf(`Parse("%s") returned "%s"`, test.expr, err.Error()) } next := expr.Next(from) nextstr := next.Format(test.layout) @@ -220,17 +218,17 @@ func TestExpressions(t *testing.T) { func TestZero(t *testing.T) { from, _ := time.Parse("2006-01-02", "2013-08-31") - next := cronexpr.MustParse("* * * * * 1980").Next(from) + next := MustParse("* * * * * 1980").Next(from) if next.IsZero() == false { t.Error(`("* * * * * 1980").Next("2013-08-31").IsZero() returned 'false', expected 'true'`) } - next = cronexpr.MustParse("* * * * * 2050").Next(from) + next = MustParse("* * * * * 2050").Next(from) if next.IsZero() == true { t.Error(`("* * * * * 2050").Next("2013-08-31").IsZero() returned 'true', expected 'false'`) } - next = cronexpr.MustParse("* * * * * 2099").Next(time.Time{}) + next = MustParse("* * * * * 2099").Next(time.Time{}) if next.IsZero() == false { t.Error(`("* * * * * 2014").Next(time.Time{}).IsZero() returned 'true', expected 'false'`) } @@ -247,7 +245,7 @@ func TestNextN(t *testing.T) { "Sat, 29 Nov 2014 00:00:00", } from, _ := time.Parse("2006-01-02 15:04:05", "2013-09-02 08:44:30") - result := cronexpr.MustParse("0 0 * * 6#5").NextN(from, uint(len(expected))) + result := MustParse("0 0 * * 6#5").NextN(from, uint(len(expected))) if len(result) != len(expected) { t.Errorf(`MustParse("0 0 * * 6#5").NextN("2013-09-02 08:44:30", 5):\n"`) t.Errorf(` Expected %d returned time values but got %d instead`, len(expected), len(result)) @@ -270,7 +268,7 @@ func TestNextN_every5min(t *testing.T) { "Mon, 2 Sep 2013 09:05:00", } from, _ := time.Parse("2006-01-02 15:04:05", "2013-09-02 08:44:32") - result := cronexpr.MustParse("*/5 * * * *").NextN(from, uint(len(expected))) + result := MustParse("*/5 * * * *").NextN(from, uint(len(expected))) if len(result) != len(expected) { t.Errorf(`MustParse("*/5 * * * *").NextN("2013-09-02 08:44:30", 5):\n"`) t.Errorf(` Expected %d returned time values but got %d instead`, len(expected), len(result)) @@ -278,30 +276,30 @@ func TestNextN_every5min(t *testing.T) { for i, next := range result { nextStr := next.Format("Mon, 2 Jan 2006 15:04:05") if nextStr != expected[i] { - t.Errorf(`MustParse("*/5 * * * *").NextN("2013-09-02 08:44:30", 5):\n"`) + t.Errorf(`MustParse("*/5 * * * *").NextN("2013-09-02 08:44:30", 5):\n"`) t.Errorf(` result[%d]: expected "%s" but got "%s"`, i, expected[i], nextStr) } } } // Issue: https://github.com/gorhill/cronexpr/issues/16 -func TestInterval_Interval60Issue(t *testing.T){ - _, err := cronexpr.Parse("*/60 * * * * *") +func TestInterval_Interval60Issue(t *testing.T) { + _, err := Parse("*/60 * * * * *") if err == nil { t.Errorf("parsing with interval 60 should return err") } - _, err = cronexpr.Parse("*/61 * * * * *") + _, err = Parse("*/61 * * * * *") if err == nil { t.Errorf("parsing with interval 61 should return err") } - _, err = cronexpr.Parse("2/60 * * * * *") + _, err = Parse("2/60 * * * * *") if err == nil { t.Errorf("parsing with interval 60 should return err") } - _, err = cronexpr.Parse("2-20/61 * * * * *") + _, err = Parse("2-20/61 * * * * *") if err == nil { t.Errorf("parsing with interval 60 should return err") } @@ -322,14 +320,14 @@ var benchmarkExpressionsLen = len(benchmarkExpressions) func BenchmarkParse(b *testing.B) { for i := 0; i < b.N; i++ { - _ = cronexpr.MustParse(benchmarkExpressions[i%benchmarkExpressionsLen]) + _ = MustParse(benchmarkExpressions[i%benchmarkExpressionsLen]) } } func BenchmarkNext(b *testing.B) { - exprs := make([]*cronexpr.Expression, benchmarkExpressionsLen) + exprs := make([]*Expression, benchmarkExpressionsLen) for i := 0; i < benchmarkExpressionsLen; i++ { - exprs[i] = cronexpr.MustParse(benchmarkExpressions[i]) + exprs[i] = MustParse(benchmarkExpressions[i]) } from := time.Now() b.ResetTimer() diff --git a/example_test.go b/example_test.go index 3dc27d0..f91dc9e 100644 --- a/example_test.go +++ b/example_test.go @@ -8,15 +8,13 @@ * */ -package cronexpr_test +package cronexpr /******************************************************************************/ import ( "fmt" "time" - - "github.com/gorhill/cronexpr" ) /******************************************************************************/ @@ -24,7 +22,7 @@ import ( // ExampleMustParse func ExampleMustParse() { t := time.Date(2013, time.August, 31, 0, 0, 0, 0, time.UTC) - nextTimes := cronexpr.MustParse("0 0 29 2 *").NextN(t, 5) + nextTimes := MustParse("0 0 29 2 *").NextN(t, 5) for i := range nextTimes { fmt.Println(nextTimes[i].Format(time.RFC1123)) // Output: From b648cc9a908c22490de781dbe600459edd0ac533 Mon Sep 17 00:00:00 2001 From: Thomas Orozco Date: Wed, 1 Aug 2018 16:02:27 +0200 Subject: [PATCH 100/105] Expose ParseStrict to error on too many fields Parse currently ignores any tokens after the 7th, which means invalid cron expressions might be allowed as long as invalid tokens are found after the 7th character. In some use cases (e.g. validating cron expressions provided by a user), this might not be desirable. To allow for this use case, this adds a ParseStrict function that returns an error if too many fields are provided (it retains backwards compatibility by not touching Parse). --- cronexpr.go | 21 +++++++++++++++++++-- cronexpr_test.go | 16 ++++++++++++++++ 2 files changed, 35 insertions(+), 2 deletions(-) diff --git a/cronexpr.go b/cronexpr.go index 58b518f..3bb6571 100644 --- a/cronexpr.go +++ b/cronexpr.go @@ -62,11 +62,22 @@ func MustParse(cronLine string) *Expression { /******************************************************************************/ // Parse returns a new Expression pointer. An error is returned if a malformed -// cron expression is supplied. +// cron expression is supplied. ParseStrict does the same thing, but unlike +// Parse, it will return an error if the provided cron line has too many +// tokens. // See for documentation // about what is a well-formed cron expression from this library's point of // view. + func Parse(cronLine string) (*Expression, error) { + return parse(cronLine, false) +} + +func ParseStrict(cronLine string) (*Expression, error) { + return parse(cronLine, true) +} + +func parse(cronLine string, strict bool) (*Expression, error) { // Maybe one of the built-in aliases is being used cron := cronNormalizer.Replace(cronLine) @@ -76,8 +87,14 @@ func Parse(cronLine string) (*Expression, error) { if fieldCount < 5 { return nil, fmt.Errorf("missing field(s)") } - // ignore fields beyond 7th + if fieldCount > 7 { + // In strict mode, error out + if strict { + return nil, fmt.Errorf("too many fields") + } + + // In non-strict mode, ignore fields beyond 7th fieldCount = 7 } diff --git a/cronexpr_test.go b/cronexpr_test.go index 6ccf7ab..0af28c4 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -307,6 +307,22 @@ func TestInterval_Interval60Issue(t *testing.T) { /******************************************************************************/ +func TestTooManyFields(t *testing.T) { + cronLine := "* * * * * * * foobar" + + _, err := ParseStrict(cronLine) + if err == nil { + t.Errorf("ParseStrict with too many fields should return err ") + } + + _, err = Parse(cronLine) + if err != nil { + t.Errorf("Parse with too many fields should not return err ") + } +} + +/******************************************************************************/ + var benchmarkExpressions = []string{ "* * * * *", "@hourly", From ee361fc97ab3885ba09de55e3aaa5a20cacca510 Mon Sep 17 00:00:00 2001 From: Thomas Orozco Date: Sat, 14 Nov 2020 14:13:55 +0000 Subject: [PATCH 101/105] Set up go modules --- cronexpr/go.mod | 7 +++++++ cronexpr/go.sum | 2 ++ go.mod | 3 +++ 3 files changed, 12 insertions(+) create mode 100644 cronexpr/go.mod create mode 100644 cronexpr/go.sum create mode 100644 go.mod diff --git a/cronexpr/go.mod b/cronexpr/go.mod new file mode 100644 index 0000000..6f458ff --- /dev/null +++ b/cronexpr/go.mod @@ -0,0 +1,7 @@ +module github.com/gorhill/cronexpr/cronexpr + +go 1.14 + +replace github.com/gorhill/cronexpr => ../ + +require github.com/gorhill/cronexpr v0.0.0-00010101000000-000000000000 diff --git a/cronexpr/go.sum b/cronexpr/go.sum new file mode 100644 index 0000000..a4a51bf --- /dev/null +++ b/cronexpr/go.sum @@ -0,0 +1,2 @@ +github.com/gorhill/cronexpr v0.0.0-20180427100037-88b0669f7d75 h1:f0n1xnMSmBLzVfsMMvriDyA75NB/oBgILX2GcHXIQzY= +github.com/gorhill/cronexpr v0.0.0-20180427100037-88b0669f7d75/go.mod h1:g2644b03hfBX9Ov0ZBDgXXens4rxSxmqFBbhvKv2yVA= diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..a1c711f --- /dev/null +++ b/go.mod @@ -0,0 +1,3 @@ +module github.com/gorhill/cronexpr + +go 1.14 From cff9279a986857e46684ca2c9fb4ec2e49f0b355 Mon Sep 17 00:00:00 2001 From: Thomas Orozco Date: Sat, 14 Nov 2020 14:36:16 +0000 Subject: [PATCH 102/105] Reject intervals that are out of order If an interval if out of order, it ends up emitting 0000-00-00 00:00:00 as the "next" time, which is undesirable. This patch updates Parse to simply reject such intervals. Since the rejection reason might not be super obvious (the range 6-7 is actually translated to 6-0, which makes it invalid), let's also print the original vs. normalized form for clarity. See: https://github.com/aptible/supercronic/issues/63 --- cronexpr_parse.go | 3 +++ cronexpr_test.go | 13 +++++++++++++ 2 files changed, 16 insertions(+) diff --git a/cronexpr_parse.go b/cronexpr_parse.go index a9fe746..27683c6 100644 --- a/cronexpr_parse.go +++ b/cronexpr_parse.go @@ -438,6 +438,9 @@ func genericFieldParse(s string, desc fieldDescriptor) ([]*cronDirective, error) directive.first = desc.atoi(snormal[pairs[2]:pairs[3]]) directive.last = desc.atoi(snormal[pairs[4]:pairs[5]]) directive.step = 1 + if directive.last < directive.first { + return nil, fmt.Errorf("invalid interval %s (normalized to %d-%d)", snormal, directive.first, directive.last) + } directives = append(directives, &directive) continue } diff --git a/cronexpr_test.go b/cronexpr_test.go index 0af28c4..8bf8d4d 100644 --- a/cronexpr_test.go +++ b/cronexpr_test.go @@ -305,6 +305,19 @@ func TestInterval_Interval60Issue(t *testing.T) { } } +// Issue: https://github.com/aptible/supercronic/issues/63 +func TestRange_OutOfOrder(t *testing.T) { + _, err := Parse("45 4 * * 6-7") + if err == nil { + t.Errorf("parsing with range 6-7 should return err") + } + + _, err = Parse("45 4 * * 6-5") + if err == nil { + t.Errorf("parsing with range 6-5 should return err") + } +} + /******************************************************************************/ func TestTooManyFields(t *testing.T) { From 0373391ef0a2868e45b9b005f494e70284a7f522 Mon Sep 17 00:00:00 2001 From: Thomas Orozco Date: Sat, 14 Nov 2020 14:51:02 +0000 Subject: [PATCH 103/105] Update import paths to krallin/cronexpr This fork is to support Supercronic, and that's how it's imported there. --- cronexpr/go.mod | 6 +++--- cronexpr/go.sum | 2 -- cronexpr/main.go | 2 +- go.mod | 2 +- 4 files changed, 5 insertions(+), 7 deletions(-) diff --git a/cronexpr/go.mod b/cronexpr/go.mod index 6f458ff..128fd22 100644 --- a/cronexpr/go.mod +++ b/cronexpr/go.mod @@ -1,7 +1,7 @@ -module github.com/gorhill/cronexpr/cronexpr +module github.com/krallin/cronexpr/cronexpr go 1.14 -replace github.com/gorhill/cronexpr => ../ +replace github.com/krallin/cronexpr => ../ -require github.com/gorhill/cronexpr v0.0.0-00010101000000-000000000000 +require github.com/krallin/cronexpr v0.0.0-00010101000000-000000000000 diff --git a/cronexpr/go.sum b/cronexpr/go.sum index a4a51bf..e69de29 100644 --- a/cronexpr/go.sum +++ b/cronexpr/go.sum @@ -1,2 +0,0 @@ -github.com/gorhill/cronexpr v0.0.0-20180427100037-88b0669f7d75 h1:f0n1xnMSmBLzVfsMMvriDyA75NB/oBgILX2GcHXIQzY= -github.com/gorhill/cronexpr v0.0.0-20180427100037-88b0669f7d75/go.mod h1:g2644b03hfBX9Ov0ZBDgXXens4rxSxmqFBbhvKv2yVA= diff --git a/cronexpr/main.go b/cronexpr/main.go index 1d9abe5..e33213e 100644 --- a/cronexpr/main.go +++ b/cronexpr/main.go @@ -18,7 +18,7 @@ import ( "os" "time" - "github.com/gorhill/cronexpr" + "github.com/krallin/cronexpr" ) /******************************************************************************/ diff --git a/go.mod b/go.mod index a1c711f..1af9dc3 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,3 @@ -module github.com/gorhill/cronexpr +module github.com/krallin/cronexpr go 1.14 From 54eb9466ac0e163c4b0ae0021d87501112740680 Mon Sep 17 00:00:00 2001 From: Thomas Orozco Date: Sat, 14 Nov 2020 16:31:49 +0000 Subject: [PATCH 104/105] Prepare for merging into Supercronic --- README.md | 134 ------------ APLv2 => cronexpr/APLv2 | 0 GPLv3 => cronexpr/GPLv3 | 0 cronexpr/README.md | 202 ++++++++++-------- cronexpr.go => cronexpr/cronexpr.go | 0 cronexpr/cronexpr/README.md | 122 +++++++++++ cronexpr/cronexpr/go.mod | 7 + cronexpr/{ => cronexpr}/go.sum | 0 cronexpr/{ => cronexpr}/main.go | 0 cronexpr_next.go => cronexpr/cronexpr_next.go | 0 .../cronexpr_parse.go | 0 cronexpr_test.go => cronexpr/cronexpr_test.go | 0 example_test.go => cronexpr/example_test.go | 0 cronexpr/go.mod | 6 +- go.mod | 3 - 15 files changed, 237 insertions(+), 237 deletions(-) delete mode 100644 README.md rename APLv2 => cronexpr/APLv2 (100%) rename GPLv3 => cronexpr/GPLv3 (100%) rename cronexpr.go => cronexpr/cronexpr.go (100%) create mode 100644 cronexpr/cronexpr/README.md create mode 100644 cronexpr/cronexpr/go.mod rename cronexpr/{ => cronexpr}/go.sum (100%) rename cronexpr/{ => cronexpr}/main.go (100%) rename cronexpr_next.go => cronexpr/cronexpr_next.go (100%) rename cronexpr_parse.go => cronexpr/cronexpr_parse.go (100%) rename cronexpr_test.go => cronexpr/cronexpr_test.go (100%) rename example_test.go => cronexpr/example_test.go (100%) delete mode 100644 go.mod diff --git a/README.md b/README.md deleted file mode 100644 index e8c56d2..0000000 --- a/README.md +++ /dev/null @@ -1,134 +0,0 @@ -Golang Cron expression parser -============================= -Given a cron expression and a time stamp, you can get the next time stamp which satisfies the cron expression. - -In another project, I decided to use cron expression syntax to encode scheduling information. Thus this standalone library to parse and apply time stamps to cron expressions. - -The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. - -There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). - -Implementation --------------- -The reference documentation for this implementation is found at -, which I copy/pasted here (laziness!) with modifications where this implementation differs: - - Field name Mandatory? Allowed values Allowed special characters - ---------- ---------- -------------- -------------------------- - Seconds No 0-59 * / , - - Minutes Yes 0-59 * / , - - Hours Yes 0-23 * / , - - Day of month Yes 1-31 * / , - L W - Month Yes 1-12 or JAN-DEC * / , - - Day of week Yes 0-6 or SUN-SAT * / , - L # - Year No 1970–2099 * / , - - -#### Asterisk ( * ) -The asterisk indicates that the cron expression matches for all values of the field. E.g., using an asterisk in the 4th field (month) indicates every month. - -#### Slash ( / ) -Slashes describe increments of ranges. For example `3-59/15` in the minute field indicate the third minute of the hour and every 15 minutes thereafter. The form `*/...` is equivalent to the form "first-last/...", that is, an increment over the largest possible range of the field. - -#### Comma ( , ) -Commas are used to separate items of a list. For example, using `MON,WED,FRI` in the 5th field (day of week) means Mondays, Wednesdays and Fridays. - -#### Hyphen ( - ) -Hyphens define ranges. For example, 2000-2010 indicates every year between 2000 and 2010 AD, inclusive. - -#### L -`L` stands for "last". When used in the day-of-week field, it allows you to specify constructs such as "the last Friday" (`5L`) of a given month. In the day-of-month field, it specifies the last day of the month. - -#### W -The `W` character is allowed for the day-of-month field. This character is used to specify the business day (Monday-Friday) nearest the given day. As an example, if you were to specify `15W` as the value for the day-of-month field, the meaning is: "the nearest business day to the 15th of the month." - -So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th is a Sunday, the trigger fires on Monday the 16th. If the 15th is a Tuesday, then it fires on Tuesday the 15th. However if you specify `1W` as the value for day-of-month, and the 1st is a Saturday, the trigger fires on Monday the 3rd, as it does not 'jump' over the boundary of a month's days. - -The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. - -The `W` character can also be combined with `L`, i.e. `LW` to mean "the last business day of the month." - -#### Hash ( # ) -`#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. - -Predefined cron expressions ---------------------------- -(Copied from , with text modified according to this implementation) - - Entry Description Equivalent to - @annually Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * - @yearly Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * - @monthly Run once a month at midnight in the morning of the first of the month 0 0 0 1 * * * - @weekly Run once a week at midnight in the morning of Sunday 0 0 0 * * 0 * - @daily Run once a day at midnight 0 0 0 * * * * - @hourly Run once an hour at the beginning of the hour 0 0 * * * * * - @reboot Not supported - -Other details -------------- -* If only six fields are present, a `0` second field is prepended, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. -* If only five fields are present, a `0` second field is prepended and a wildcard year field is appended, that is, `* * * * Mon` internally become `0 * * * * Mon *`. -* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). This to comply with http://linux.die.net/man/5/crontab#. -* As of now, the behavior of the code is undetermined if a malformed cron expression is supplied - -Install -------- - go get github.com/gorhill/cronexpr - -Usage ------ -Import the library: - - import "github.com/gorhill/cronexpr" - import "time" - -Simplest way: - - nextTime := cronexpr.MustParse("0 0 29 2 *").Next(time.Now()) - -Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". - -You can keep the returned Expression pointer around if you want to reuse it: - - expr := cronexpr.MustParse("0 0 29 2 *") - nextTime := expr.Next(time.Now()) - ... - nextTime = expr.Next(nextTime) - -Use `time.IsZero()` to find out whether a valid time was returned. For example, - - cronexpr.MustParse("* * * * * 1980").Next(time.Now()).IsZero() - -will return `true`, whereas - - cronexpr.MustParse("* * * * * 2050").Next(time.Now()).IsZero() - -will return `false` (as of 2013-08-29...) - -You may also query for `n` next time stamps: - - cronexpr.MustParse("0 0 29 2 *").NextN(time.Now(), 5) - -which returns a slice of time.Time objects, containing the following time stamps (as of 2013-08-30): - - 2016-02-29 00:00:00 - 2020-02-29 00:00:00 - 2024-02-29 00:00:00 - 2028-02-29 00:00:00 - 2032-02-29 00:00:00 - -The time zone of time values returned by `Next` and `NextN` is always the -time zone of the time value passed as argument, unless a zero time value is -returned. - -API ---- - - -License -------- - -License: pick the one which suits you best: - -- GPL v3 see -- APL v2 see - diff --git a/APLv2 b/cronexpr/APLv2 similarity index 100% rename from APLv2 rename to cronexpr/APLv2 diff --git a/GPLv3 b/cronexpr/GPLv3 similarity index 100% rename from GPLv3 rename to cronexpr/GPLv3 diff --git a/cronexpr/README.md b/cronexpr/README.md index 685c278..e8c56d2 100644 --- a/cronexpr/README.md +++ b/cronexpr/README.md @@ -1,122 +1,134 @@ -cronexpr: command-line utility -============================== +Golang Cron expression parser +============================= +Given a cron expression and a time stamp, you can get the next time stamp which satisfies the cron expression. -A command-line utility written in Go to evaluate cron time expressions. +In another project, I decided to use cron expression syntax to encode scheduling information. Thus this standalone library to parse and apply time stamps to cron expressions. -It is based on the standalone Go library . +The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. -## Install +There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). +Implementation +-------------- +The reference documentation for this implementation is found at +, which I copy/pasted here (laziness!) with modifications where this implementation differs: + + Field name Mandatory? Allowed values Allowed special characters + ---------- ---------- -------------- -------------------------- + Seconds No 0-59 * / , - + Minutes Yes 0-59 * / , - + Hours Yes 0-23 * / , - + Day of month Yes 1-31 * / , - L W + Month Yes 1-12 or JAN-DEC * / , - + Day of week Yes 0-6 or SUN-SAT * / , - L # + Year No 1970–2099 * / , - + +#### Asterisk ( * ) +The asterisk indicates that the cron expression matches for all values of the field. E.g., using an asterisk in the 4th field (month) indicates every month. + +#### Slash ( / ) +Slashes describe increments of ranges. For example `3-59/15` in the minute field indicate the third minute of the hour and every 15 minutes thereafter. The form `*/...` is equivalent to the form "first-last/...", that is, an increment over the largest possible range of the field. + +#### Comma ( , ) +Commas are used to separate items of a list. For example, using `MON,WED,FRI` in the 5th field (day of week) means Mondays, Wednesdays and Fridays. + +#### Hyphen ( - ) +Hyphens define ranges. For example, 2000-2010 indicates every year between 2000 and 2010 AD, inclusive. + +#### L +`L` stands for "last". When used in the day-of-week field, it allows you to specify constructs such as "the last Friday" (`5L`) of a given month. In the day-of-month field, it specifies the last day of the month. + +#### W +The `W` character is allowed for the day-of-month field. This character is used to specify the business day (Monday-Friday) nearest the given day. As an example, if you were to specify `15W` as the value for the day-of-month field, the meaning is: "the nearest business day to the 15th of the month." + +So, if the 15th is a Saturday, the trigger fires on Friday the 14th. If the 15th is a Sunday, the trigger fires on Monday the 16th. If the 15th is a Tuesday, then it fires on Tuesday the 15th. However if you specify `1W` as the value for day-of-month, and the 1st is a Saturday, the trigger fires on Monday the 3rd, as it does not 'jump' over the boundary of a month's days. + +The `W` character can be specified only when the day-of-month is a single day, not a range or list of days. + +The `W` character can also be combined with `L`, i.e. `LW` to mean "the last business day of the month." + +#### Hash ( # ) +`#` is allowed for the day-of-week field, and must be followed by a number between one and five. It allows you to specify constructs such as "the second Friday" of a given month. + +Predefined cron expressions +--------------------------- +(Copied from , with text modified according to this implementation) + + Entry Description Equivalent to + @annually Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * + @yearly Run once a year at midnight in the morning of January 1 0 0 0 1 1 * * + @monthly Run once a month at midnight in the morning of the first of the month 0 0 0 1 * * * + @weekly Run once a week at midnight in the morning of Sunday 0 0 0 * * 0 * + @daily Run once a day at midnight 0 0 0 * * * * + @hourly Run once an hour at the beginning of the hour 0 0 * * * * * + @reboot Not supported + +Other details +------------- +* If only six fields are present, a `0` second field is prepended, that is, `* * * * * 2013` internally become `0 * * * * * 2013`. +* If only five fields are present, a `0` second field is prepended and a wildcard year field is appended, that is, `* * * * Mon` internally become `0 * * * * Mon *`. +* Domain for day-of-week field is [0-7] instead of [0-6], 7 being Sunday (like 0). This to comply with http://linux.die.net/man/5/crontab#. +* As of now, the behavior of the code is undetermined if a malformed cron expression is supplied + +Install +------- go get github.com/gorhill/cronexpr - go install github.com/gorhill/cronexpr -## Usage +Usage +----- +Import the library: - cronexpr [options] "{cron expression}" + import "github.com/gorhill/cronexpr" + import "time" -## Options +Simplest way: -`-l`: + nextTime := cronexpr.MustParse("0 0 29 2 *").Next(time.Now()) -Go-compliant time layout to use for outputting time value(s), see . +Assuming `time.Now()` is "2013-08-29 09:28:00", then `nextTime` will be "2016-02-29 00:00:00". -Default is `"Mon, 02 Jan 2006 15:04:05 MST"` +You can keep the returned Expression pointer around if you want to reuse it: -`-n`: + expr := cronexpr.MustParse("0 0 29 2 *") + nextTime := expr.Next(time.Now()) + ... + nextTime = expr.Next(nextTime) -Number of resulting time values to output. +Use `time.IsZero()` to find out whether a valid time was returned. For example, -Default is 1. + cronexpr.MustParse("* * * * * 1980").Next(time.Now()).IsZero() -`-t`: +will return `true`, whereas -Whole or partial RFC3339 time value (i.e. `2006-01-02T15:04:05Z07:00`) against which the cron expression is evaluated. Examples of valid values include (assuming EST time zone): + cronexpr.MustParse("* * * * * 2050").Next(time.Now()).IsZero() -`13` = 2013-01-01T00:00:00-05:00 -`2013` = 2013-01-01T00:00:00-05:00 -`2013-08` = 2013-08-01T00:00:00-05:00 -`2013-08-31` = 2013-08-31T00:00:00-05:00 -`2013-08-31T12` = 2013-08-31T12:00:00-05:00 -`2013-08-31T12:40` = 2013-08-31T12:40:00-05:00 -`2013-08-31T12:40:35` = 2013-08-31T12:40:35-05:00 -`2013-08-31T12:40:35-10:00` = 2013-08-31T12:40:35-10:00 +will return `false` (as of 2013-08-29...) -Default time is current time, and default time zone is local time zone. +You may also query for `n` next time stamps: -## Examples + cronexpr.MustParse("0 0 29 2 *").NextN(time.Now(), 5) -#### Example 1 +which returns a slice of time.Time objects, containing the following time stamps (as of 2013-08-30): -Midnight on December 31st of any year. + 2016-02-29 00:00:00 + 2020-02-29 00:00:00 + 2024-02-29 00:00:00 + 2028-02-29 00:00:00 + 2032-02-29 00:00:00 -Command: +The time zone of time values returned by `Next` and `NextN` is always the +time zone of the time value passed as argument, unless a zero time value is +returned. - cronexpr -t="2013-08-31" -n=5 "0 0 31 12 *" +API +--- + -Output (assuming computer is in EST time zone): +License +------- - # "0 0 31 12 *" + "2013-08-31T00:00:00-04:00" = - Tue, 31 Dec 2013 00:00:00 EST - Wed, 31 Dec 2014 00:00:00 EST - Thu, 31 Dec 2015 00:00:00 EST - Sat, 31 Dec 2016 00:00:00 EST - Sun, 31 Dec 2017 00:00:00 EST +License: pick the one which suits you best: -#### Example 2 - -2pm on February 29th of any year. - -Command: - - cronexpr -t=2000 -n=10 "0 14 29 2 *" - -Output (assuming computer is in EST time zone): - - # "0 14 29 2 *" + "2000-01-01T00:00:00-05:00" = - Tue, 29 Feb 2000 14:00:00 EST - Sun, 29 Feb 2004 14:00:00 EST - Fri, 29 Feb 2008 14:00:00 EST - Wed, 29 Feb 2012 14:00:00 EST - Mon, 29 Feb 2016 14:00:00 EST - Sat, 29 Feb 2020 14:00:00 EST - Thu, 29 Feb 2024 14:00:00 EST - Tue, 29 Feb 2028 14:00:00 EST - Sun, 29 Feb 2032 14:00:00 EST - Fri, 29 Feb 2036 14:00:00 EST - -#### Example 3 - -12pm on the work day closest to the 15th of March and every three month -thereafter. - -Command: - - cronexpr -t=2013-09-01 -n=5 "0 12 15W 3/3 *" - -Output (assuming computer is in EST time zone): - - # "0 12 15W 3/3 *" + "2013-09-01T00:00:00-04:00" = - Mon, 16 Sep 2013 12:00:00 EDT - Mon, 16 Dec 2013 12:00:00 EST - Fri, 14 Mar 2014 12:00:00 EDT - Mon, 16 Jun 2014 12:00:00 EDT - Mon, 15 Sep 2014 12:00:00 EDT - -#### Example 4 - -Midnight on the fifth Saturday of any month (twist: not all months have a 5th -specific day of week). - -Command: - - cronexpr -t=2013-09-02 -n 5 "0 0 * * 6#5" - -Output (assuming computer is in EST time zone): - - # "0 0 * * 6#5" + "2013-09-02T00:00:00-04:00" = - Sat, 30 Nov 2013 00:00:00 EST - Sat, 29 Mar 2014 00:00:00 EDT - Sat, 31 May 2014 00:00:00 EDT - Sat, 30 Aug 2014 00:00:00 EDT - Sat, 29 Nov 2014 00:00:00 EST +- GPL v3 see +- APL v2 see diff --git a/cronexpr.go b/cronexpr/cronexpr.go similarity index 100% rename from cronexpr.go rename to cronexpr/cronexpr.go diff --git a/cronexpr/cronexpr/README.md b/cronexpr/cronexpr/README.md new file mode 100644 index 0000000..685c278 --- /dev/null +++ b/cronexpr/cronexpr/README.md @@ -0,0 +1,122 @@ +cronexpr: command-line utility +============================== + +A command-line utility written in Go to evaluate cron time expressions. + +It is based on the standalone Go library . + +## Install + + go get github.com/gorhill/cronexpr + go install github.com/gorhill/cronexpr + +## Usage + + cronexpr [options] "{cron expression}" + +## Options + +`-l`: + +Go-compliant time layout to use for outputting time value(s), see . + +Default is `"Mon, 02 Jan 2006 15:04:05 MST"` + +`-n`: + +Number of resulting time values to output. + +Default is 1. + +`-t`: + +Whole or partial RFC3339 time value (i.e. `2006-01-02T15:04:05Z07:00`) against which the cron expression is evaluated. Examples of valid values include (assuming EST time zone): + +`13` = 2013-01-01T00:00:00-05:00 +`2013` = 2013-01-01T00:00:00-05:00 +`2013-08` = 2013-08-01T00:00:00-05:00 +`2013-08-31` = 2013-08-31T00:00:00-05:00 +`2013-08-31T12` = 2013-08-31T12:00:00-05:00 +`2013-08-31T12:40` = 2013-08-31T12:40:00-05:00 +`2013-08-31T12:40:35` = 2013-08-31T12:40:35-05:00 +`2013-08-31T12:40:35-10:00` = 2013-08-31T12:40:35-10:00 + +Default time is current time, and default time zone is local time zone. + +## Examples + +#### Example 1 + +Midnight on December 31st of any year. + +Command: + + cronexpr -t="2013-08-31" -n=5 "0 0 31 12 *" + +Output (assuming computer is in EST time zone): + + # "0 0 31 12 *" + "2013-08-31T00:00:00-04:00" = + Tue, 31 Dec 2013 00:00:00 EST + Wed, 31 Dec 2014 00:00:00 EST + Thu, 31 Dec 2015 00:00:00 EST + Sat, 31 Dec 2016 00:00:00 EST + Sun, 31 Dec 2017 00:00:00 EST + +#### Example 2 + +2pm on February 29th of any year. + +Command: + + cronexpr -t=2000 -n=10 "0 14 29 2 *" + +Output (assuming computer is in EST time zone): + + # "0 14 29 2 *" + "2000-01-01T00:00:00-05:00" = + Tue, 29 Feb 2000 14:00:00 EST + Sun, 29 Feb 2004 14:00:00 EST + Fri, 29 Feb 2008 14:00:00 EST + Wed, 29 Feb 2012 14:00:00 EST + Mon, 29 Feb 2016 14:00:00 EST + Sat, 29 Feb 2020 14:00:00 EST + Thu, 29 Feb 2024 14:00:00 EST + Tue, 29 Feb 2028 14:00:00 EST + Sun, 29 Feb 2032 14:00:00 EST + Fri, 29 Feb 2036 14:00:00 EST + +#### Example 3 + +12pm on the work day closest to the 15th of March and every three month +thereafter. + +Command: + + cronexpr -t=2013-09-01 -n=5 "0 12 15W 3/3 *" + +Output (assuming computer is in EST time zone): + + # "0 12 15W 3/3 *" + "2013-09-01T00:00:00-04:00" = + Mon, 16 Sep 2013 12:00:00 EDT + Mon, 16 Dec 2013 12:00:00 EST + Fri, 14 Mar 2014 12:00:00 EDT + Mon, 16 Jun 2014 12:00:00 EDT + Mon, 15 Sep 2014 12:00:00 EDT + +#### Example 4 + +Midnight on the fifth Saturday of any month (twist: not all months have a 5th +specific day of week). + +Command: + + cronexpr -t=2013-09-02 -n 5 "0 0 * * 6#5" + +Output (assuming computer is in EST time zone): + + # "0 0 * * 6#5" + "2013-09-02T00:00:00-04:00" = + Sat, 30 Nov 2013 00:00:00 EST + Sat, 29 Mar 2014 00:00:00 EDT + Sat, 31 May 2014 00:00:00 EDT + Sat, 30 Aug 2014 00:00:00 EDT + Sat, 29 Nov 2014 00:00:00 EST + diff --git a/cronexpr/cronexpr/go.mod b/cronexpr/cronexpr/go.mod new file mode 100644 index 0000000..128fd22 --- /dev/null +++ b/cronexpr/cronexpr/go.mod @@ -0,0 +1,7 @@ +module github.com/krallin/cronexpr/cronexpr + +go 1.14 + +replace github.com/krallin/cronexpr => ../ + +require github.com/krallin/cronexpr v0.0.0-00010101000000-000000000000 diff --git a/cronexpr/go.sum b/cronexpr/cronexpr/go.sum similarity index 100% rename from cronexpr/go.sum rename to cronexpr/cronexpr/go.sum diff --git a/cronexpr/main.go b/cronexpr/cronexpr/main.go similarity index 100% rename from cronexpr/main.go rename to cronexpr/cronexpr/main.go diff --git a/cronexpr_next.go b/cronexpr/cronexpr_next.go similarity index 100% rename from cronexpr_next.go rename to cronexpr/cronexpr_next.go diff --git a/cronexpr_parse.go b/cronexpr/cronexpr_parse.go similarity index 100% rename from cronexpr_parse.go rename to cronexpr/cronexpr_parse.go diff --git a/cronexpr_test.go b/cronexpr/cronexpr_test.go similarity index 100% rename from cronexpr_test.go rename to cronexpr/cronexpr_test.go diff --git a/example_test.go b/cronexpr/example_test.go similarity index 100% rename from example_test.go rename to cronexpr/example_test.go diff --git a/cronexpr/go.mod b/cronexpr/go.mod index 128fd22..1af9dc3 100644 --- a/cronexpr/go.mod +++ b/cronexpr/go.mod @@ -1,7 +1,3 @@ -module github.com/krallin/cronexpr/cronexpr +module github.com/krallin/cronexpr go 1.14 - -replace github.com/krallin/cronexpr => ../ - -require github.com/krallin/cronexpr v0.0.0-00010101000000-000000000000 diff --git a/go.mod b/go.mod deleted file mode 100644 index 1af9dc3..0000000 --- a/go.mod +++ /dev/null @@ -1,3 +0,0 @@ -module github.com/krallin/cronexpr - -go 1.14 From a3bd41c5d4fb5c27495c8e0bd3f99f663941ab4c Mon Sep 17 00:00:00 2001 From: Thomas Orozco Date: Sat, 14 Nov 2020 16:38:19 +0000 Subject: [PATCH 105/105] Vendor cronexpr in-tree Rather than depend on a fork, let's incorporate cronexpr directly here. Cronexpr won't ever receive updates at this point, so keeping it as a fork so we could switch back to master is a bit pointless. Incorporating it here into Supercronic gives us CI for free (which we don't get in a fork), and it makes commits incorporating changes to cronexpr clearer (since we can see the code changes instead of just a dependency change). --- README.md | 2 +- cronexpr/README.md | 11 ++-- cronexpr/cronexpr.go | 8 +-- cronexpr/cronexpr/README.md | 6 +-- cronexpr/cronexpr/cronexpr | Bin 0 -> 2851464 bytes cronexpr/cronexpr/go.mod | 6 +-- cronexpr/cronexpr/go.sum | 98 ++++++++++++++++++++++++++++++++++++ cronexpr/cronexpr/main.go | 4 +- cronexpr/cronexpr_next.go | 2 +- cronexpr/cronexpr_parse.go | 2 +- cronexpr/cronexpr_test.go | 2 +- cronexpr/example_test.go | 2 +- cronexpr/go.mod | 3 -- crontab/crontab.go | 2 +- go.mod | 1 - go.sum | 4 -- 16 files changed, 123 insertions(+), 30 deletions(-) create mode 100755 cronexpr/cronexpr/cronexpr delete mode 100644 cronexpr/go.mod diff --git a/README.md b/README.md index 3abc8f9..66ae17b 100644 --- a/README.md +++ b/README.md @@ -279,7 +279,7 @@ Copyright (c) 2019 [Aptible][aptible]. All rights reserved. [aptible-logo]: https://raw.github.com/aptible/straptible/master/lib/straptible/rails/templates/public.api/icon-60px.png [blog-post]: https://www.aptible.com/blog/cron-for-containers-introduction-supercronic/ - [cronexpr]: https://github.com/krallin/cronexpr + [cronexpr]: https://github.com/aptible/supercronic/tree/master/cronexpr [releases]: https://github.com/aptible/supercronic/releases [dep]: https://github.com/golang/dep [aptible]: https://www.aptible.com diff --git a/cronexpr/README.md b/cronexpr/README.md index e8c56d2..38cf9d2 100644 --- a/cronexpr/README.md +++ b/cronexpr/README.md @@ -1,3 +1,6 @@ +NOTE: Cronexpr is maintained in-tree by Supercronic, but it's forked from +github.com/gorhill/cronexpr. Its license applies to the underlying code. + Golang Cron expression parser ============================= Given a cron expression and a time stamp, you can get the next time stamp which satisfies the cron expression. @@ -6,7 +9,7 @@ In another project, I decided to use cron expression syntax to encode scheduling The time-matching algorithm in this implementation is efficient, it avoids as much as possible to guess the next matching time stamp, a common technique seen in a number of implementations out there. -There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). +There is also a companion command-line utility to evaluate cron time expressions: (which of course uses this library). Implementation -------------- @@ -72,13 +75,13 @@ Other details Install ------- - go get github.com/gorhill/cronexpr + go get github.com/aptible/supercronic/cronexpr Usage ----- Import the library: - import "github.com/gorhill/cronexpr" + import "github.com/aptible/supercronic/cronexpr" import "time" Simplest way: @@ -122,7 +125,7 @@ returned. API --- - + License ------- diff --git a/cronexpr/cronexpr.go b/cronexpr/cronexpr.go index 3bb6571..19553e4 100644 --- a/cronexpr/cronexpr.go +++ b/cronexpr/cronexpr.go @@ -1,7 +1,7 @@ /*! * Copyright 2013 Raymond Hill * - * Project: github.com/gorhill/cronexpr + * Project: github.com/aptible/supercronic/cronexpr * File: cronexpr.go * Version: 1.0 * License: pick the one which suits you : @@ -24,7 +24,7 @@ import ( /******************************************************************************/ // A Expression represents a specific cron time expression as defined at -// +// type Expression struct { expression string secondList []int @@ -48,7 +48,7 @@ type Expression struct { // MustParse returns a new Expression pointer. It expects a well-formed cron // expression. If a malformed cron expression is supplied, it will `panic`. -// See for documentation +// See for documentation // about what is a well-formed cron expression from this library's point of // view. func MustParse(cronLine string) *Expression { @@ -65,7 +65,7 @@ func MustParse(cronLine string) *Expression { // cron expression is supplied. ParseStrict does the same thing, but unlike // Parse, it will return an error if the provided cron line has too many // tokens. -// See for documentation +// See for documentation // about what is a well-formed cron expression from this library's point of // view. diff --git a/cronexpr/cronexpr/README.md b/cronexpr/cronexpr/README.md index 685c278..87121fb 100644 --- a/cronexpr/cronexpr/README.md +++ b/cronexpr/cronexpr/README.md @@ -3,12 +3,12 @@ cronexpr: command-line utility A command-line utility written in Go to evaluate cron time expressions. -It is based on the standalone Go library . +It is based on the standalone Go library . ## Install - go get github.com/gorhill/cronexpr - go install github.com/gorhill/cronexpr + go get github.com/aptible/supercronic/cronexpr + go install github.com/aptible/supercronic/cronexpr ## Usage diff --git a/cronexpr/cronexpr/cronexpr b/cronexpr/cronexpr/cronexpr new file mode 100755 index 0000000000000000000000000000000000000000..2e3a26def5c6450a718547a05583e887060dbd9b GIT binary patch literal 2851464 zcmeFa33O9s{y&^R14St}C`d(?pjC@&t2nl5C4~Yv7_=yAQAR2Pq9RmCp(tu=Qc8?h zt1^z;ILzkgs3R`JCTdHOvbeB}g5qd(Ty6|1E(0y7{eM2+=icO|6rJ;)-}%4qIq$FM zG`aU#zR!1mzR#Ms_J8?PcbCiE)#Y+^!T;g--_ipg*5A?i*6}}ia%u6HQCEz*_#!(e z`Rz_V{mcX5RH1>%lP8QSn~+ve)o&S?mgutHft$;Ne}40C^5oF8s*rkC?;YTIT>|g> z6D^S34OxPZUB2V@j36;^%8q@Mc=%;yn%C z!T4Plx_Zi?;njERBben{_~G3}-8j_WN_50;Wp@S7u8(*7vD0tDtGH(7 zEE`})cnuc3cV1UYiua$TmwJ~gdRJ0Bq1e%6%RoivSW7!BeXCxi2q(?_Ps!oh*^{SK zUN>{3+k2p z1H9RQlT_u7_%(c_=>79y3LxHpmT!|MCqYRY9pP2)9wdPFEKn%m{TJX(nL9U$?ZN!3 zo<3OMEqjz+Nd3|7?LUhR_AB@$^d^CJ#LwULSgB&3kgSr1Uq^V@TSkX`bGfkNbmP|=P15KgiP1>Zw~qI@T;htG7Atp!h8S7 z;|1QeWHA2TzvS5e8Xi4gM|dMoRq&e5SMWyO_)GAVIIf*KW%Ar>=3LhiUbmSFp53i= zd-_-fIQ7}NJd_(ah<}$_@Y>%~QoR)L{yX{3zJ^V9#Baiwp~Al%SqhB_btn9H@a9}S z>)L5^4}y2{r6&u#*Z!dhJoz`dKMRjyQ~iH1aNz}`N&S<_&>dJ?wr$SUN`0RsS9RK#XJ9)UVwkWg$dSQ zvMkD9vS4m#+Ks1;I1Tl#>#PyG(*J({F9-gY1OLl`|K-5{?>Nxz8#CJ{;~HO}JFkk!Y_TMx; z*7Nv0uvtI%YVW+W^ziO%JvuYTs~h+*uR_?M$4YX1dNd=454n1@Bq!56iWOok7G9U# zWH#UDaV7pCAXD&+lALAwxy4>>(Hj^X={38zuu}BtoDKXotnXMPr$vC>m9vxIwGCQi z4uTN2lcz_6ITd=eXO6VGz9h$ciWwuYSTHABuidB_9u&=Q$ls{PCZKqDf5yU>_1L7G zikfq;si-`yav3X@=}~4z@5-rW3()}pHz6mJ;EK%ioZ#*%MTn$86>in)x-c)?mZ9D8 z6~ZIknD~Pp{XpNhOK&_dTo3;{Lys-YsR$YwgLR|Wtru?5>Rw^FXeg&Nh<0b_L)WsU z+(2}zzVAJ~asP0A$QIq`)19g1fpA+Ft@ddIFeTcGKHaAm*X*A?ORLR5!b*ldXt}#q z`!_rxd+_v{{a4S_Y9Hb2@(F{xRPV=|!D6w#zKMff`5O~GiWi46kJgO~fXmifr|7YP z-I1Zk&T1{gSK+%_xR0Q>S#SKvv%aKPwmZ@g8u*H|6)W0>Lcy5lbt!vb&I|FaltS#R zmzWSMTBFjn@M}ocmWO)vPi&$>l<6_W*Ld+y?d^+8a!v$7_pmT%)PYrog^*^f6Kn_0 zQ2?(IfI#Xhwi6Ykg0Y~MsmIRK0)^jHHtW$zIew}@fgU|ChaAle;>~MjBXF%=n3L_Q zJVskCEutxk-LJ>Ud!RKVu~?5~b(g04wq8yWN|0T+K?}!4#*=ai)|d3pcB9lslHGS3 zzgVCN1wdiWiT=f*{zs=1IqAptb~Af_7ifd0@ZsJ-9CpzR%m#rtb9mRT($EY^MvJA& zTux-V;aL%MRDhUWW-nxz0fIx}6f5`sfL5MwlUAO%!BGi>yUcgHs8-7DRxG1zWV+$` zYN?}wj}@M+Po#Fck}kTtq-$QdHaxGCXDbcwi>-G_$NPhLuU?b06ko2;SybmLnntO% z{L!30AT6>hbfg}8QI$L2rA5}L#1rhq#e?+rwR+)N?XH`_R6S-n&YE@fr%eF;M|`_N zTXeWmHm*k_Io14zVb;rgFh@71?h_%re5Zq_{gG?NFf3%%YALGZpes34Fw5}VQ0u6Z z%{rGO!@Q3Wl^jSD9B^s;V!`m|@OXc(;Biu&1186`X4gaGVYW-1{2E7{eysBrGR(s| z!DADAk=giy$7Qa;haTOaN8dG{lShcW&3rud_(-Ziy*zF;O?Al92kflBtH)A2 z{#iX%;PGL3TrBEiWEtvh890KxYV}6#!`oc-wnx2PtKPhB$-6?m<*By|)my208=>AR z)Z1C=tzNwyuiloax4!Ca3*VYOc^40MX>6?7bE@?iE;?cN5K=phMWUV_NY|S)a!?BL z0tXhVZC&QXtj@Hj&~_QPYDdORABBh}+E+I@|Sv(D$s9bur5zY&cM(C%v( zvSG1j2$F%UFWlOF?qQ6t5YntGXj&Z18BCNphhx43#8IXvs&xg}JzojB9)Lw$kTZD5 zrp0}CskBUFZ&Q!NdxLr;vMceJ0uPSlm=S`_$N^OM+#~SW1t>)u(NIqOO6Y8UL*koM z4c#dEbLn80`Ss&4gL`3X49K953!q${D*@bm8##D~hIz*F{WbLtHS?Uu_kXB&=$hwL zzW+tuS1E<_9K)phRFcv7VCQCQVdHUQh(^|76l=m6WHF z)-vf#l~k&do@0_vB~_@TrA*3FN%bn}ZYJ&j3rSnGOeHN~(&s8^i%Ocxq<=Cgx*;B5 z5BS$Q@aYKjp0B@7T?DgwYJUXVy>JYD&?97{Ll~gk!YatvrMb5tHxsEn)0_qT1)|n$ zwZFaBjyTWDn5{sM zov9aIkQq8Je`920r8l2gJKzEXub^X$#J7zJmqksljY;BlJ=zCReTbfs5#nA1x|UNW zMQkSVN7DxkMVnLXNcX?A<sDs~?5&~Zl(k5kc8jy)Efc+-%AtbOKcuT{3bnUsrwIwC!pHz|fE@$c2UymOH zPA6->j{XkyS-q~S)NsI)6oLkP2!ZY>JAYUH-oz2w^7FET#%Q;{U`IeJ*&`j~=7n(z z%x>3iqPl3n7ef%v^n`k4G~kWm zaP2@`FZ@Z1aEe_o+#ZN-32MQnK)5wiyMtjCo`%mmqPpnG_z;&{i#&s3aV`WQ-8=89 z@3h(7@UKnRLK~)QI~w(~+S^^O%9Hf)daoXC_6EYHH}OxrK`WZ`5=Y<(rqJw5WZETk zZOu+Szv0fFgU;zWSo>{*Ze)xCd)ot1w_q{va6Q&dk7*coRBB^mCEZ%b#)92j@fx~C z*EZD1E_OJBq zpZTlXC3QGc7Xt3~ul4Pp>)M;T_LiQ%FVqj9-(u15X9QhoqXv{Qas$J(-#2JW8g-+j zSWxbqAzE!;R7BorFFr2vrn5_{{TkZJTpx3N9dnzl+&t#yb$86tgpN7`H_T!EQh^oE4^0?RD4t-z^dZA;Cni|+p%$`SI!k40ii+wO#!1~J9qi(~!7VIb3WZC1l{ zt=#&rXh1l3z`Jl(pqay8bP4S6wvYGa69s$zZxLAZSb))Uxj5 zTdOueD*ayjGW0H_usubbFIf2DZJ*#HbWSk(p|cFc0Gbi*H2Q!FC@x-2Q7VGdi9}J- z+NnQ)cZB7KG{80;K4uooV_RgnfMQ@d@ntAMJ9`9$B$IS(>hx;1?jPF9;(t5-KgIvP>DsQf z`2P(5>)>&=*!rr66aJe06nyB>^%M}Ao>K(2b;G}g|I4WTlYOuK82Shn@WpFy@1okj z)3JVgduScFMi9d11DW%V(PJRGA4k6H% z8$JI866tvyeg}+1;q6~JoDMuPs>10E-3Pxz0OU7^FYwav*H*-V`LX>_n4E(6a6nBL zXNU6ABm1oKxp58zI+o`&+)eQPm<;r4;gCGFcA09Mn?7k;HhR!LSf zCd+orNyN`r1-s5ae|qfKZoBYLs&J?mcq0YBj`u~u>9P6l>4hI?kxB=Qf5!L2#L$ap z%=cMs{TMr&EnVa&^=15@s#N#+MMTGq*@@UB&kv}i&!23!k4hz;Jp!bY z`YCiijz5jMC^D&lE@vki`7YVWPXbmExhl?K6dLi(9||K-xP62t+wFWu)S&s-+A{oi zV!VwFij{a;q*^C64o}r!7c;4#1;*6^!}{I=*~c!h7UmRa?#gy(S&8!MqN_g=mv}pS zjc{vEs3OqNjY{wIee3sVT4Xvhgblh8>i11RdHBFk_=9t<)_MjDH_pory5G_Z_s#i| zNf)*=ZT`c$aa+6Yek(Y1M<9Bx*pnUqphrUFgMc-j3x?Qc(OHj`>Bv7se>EZ5QOO*$ zbX0wTZnC4&)@-Xh9^|u|n)8_+ZANCYGh${YdK2LXt=|o73#3?fbPqWZ;bTTUI za1oe75CYu}=z`~dw1BKsr;;AOk4%r>8SG-t(jF@%MPt)(VfAM!C(3@u)#72;%ZC{1>r#f(`ydCf)?9J6Te~;e`XVD@U=xhh^-tn z=KD_by0ptTYNs_;cGF@{ppbT2LuHp+ZbJ18wLBE_=fxKLVBN8L&YeW-`5fKc_)+it zcca_$H#Nq)=WmU^*O>6;Z;n35B1T4kg>e1`ebtc1FT4H^vnpK-Xji^^%{?#O@b$$m zU3+!|$#HO}6K={(-1ql%&P{z~60$IdZ8^X96_sz`#R|Bf7f0i9V@IL7bA5w^h~uk(8@cgy*{0_r!Be!dJ7sc z0WuSohB<%&Le_QIAeI{=f2aAx0tk~9WTUftfrhete80VGeW45VC=8Ssh#N>#%TgU` zDHeMp`*A?bPSa8`f-<@YOt`G`Hzn=;=Rh6XDJW6+G*H$mlrs&On#c83>LT+1nBGzI zrMl5~<}6OLPk@iHr+g?n@nSyn)=M%3|6EJnwp`D;R?+3fl<>p?4FIe~TXXZPT`*z( zmk^Yy9>Pe|CvDM1KhJNje*Qn^wVSa2XL!9_>(9$(LI!}^Xza+cyaW z9(|9C-|&(%h;{`nubc};dN79dc-|;@N98w+ ziZp1oJi?$yRa4|N@If^)#vDD^!xi&PSLjA2A_r@Nw%9mEF6W#ahQc!l^{z`PoWjQW zK(lixq-5G8VitEX6!yT$*T7S*Esr6i>6k@i<2~#~L z^sZfS9yn%H7f}o9K8iQ9P@b(KAnZ zDh^7Aen-B0%_wH;t;xhtjvjxKT?p7&z(u#RAlbQZpv}&c)m9A=A4o1IFTq%r#z42M z7y<^rE8(6RxFRd;D5mdKjg-WX1dTF(*#V;PpY!Z9Pv!8*OWcfkJ)c@xfs#dpYKWDM^`+lMR zp__i~m#cD&n4v{#zzaNO{v0B8Sl;~w9^7Sl9R}qomCIDU{Fqu*A6neG|2Q-uYwrA| zronb|dX`-Zn&<4ipPl|Q9ZJImszZTy=5k%s?xL$EgC!zzBkR#TXNS^jB|8*zCOVWC zxY~Wl^(WK^A_Z-W(z^VktbV z(yPbD;z6e=b+Z1&@|hg&NJTtkBBsYAxAsWGkVY)DrXde{r98ubDUSyXa(}LZ4d0(Z z*mfhOe9P8O+ibU_owin6vX+gm9kSKgtlgeJlWp0JmhvqdEhhosxl;(K{+|2!F79+Z z$+b7oGl5R3zg{>tGj#B(8?=nx5DHC4`uG>^?Xu>V*lE6ZJtFl7t>IJp`0~GK57VoK zT@KZr3~cFwAApOp+q?e%LVMiLXt%fjx{4t>+!ne@Tkh}o zgfBFJ(krE5lyP4fETh~R;!9jke=a)|W!0=p`xbji(NPqW*5$IOXAKS@8gp6?fItKw#iXI>j z<(UZ`!(iA8>1QOTgY;PS766F=!eSl!vFK5J^e6~_(7Wu@qett}o1md8H{6JDT0Isn zE=Bo}Y;nO-Dz*^oQLf)33Nw$vlzrl}Bm(K}R~MbTfvoCBtI4JA`}8`o4GRpCeZoIv z0S8V;ke$n=`eyya1j2wfLk2jPU*ti%n~br4g!=meAY>O8m0)m~kIPe{qnuV#EeF)qbUXg2Cw zU!9EG~ij3W?kpO`zt1Pu*&$Q@K!&d5UsnD`)6> zjL)Enpb0vPO?urh-U&vrt#b3Nemyp9ryhHSV-M^Q&zKVK$AQo8&|54a05`ao-C#HK|W&@wYbYs>=> zyUM8j9WoqZ#eTj*ccmDWr8R}crJ+6HReMm*RXHOCV+RyM4F?^iwaXi{-ZTJs93N}I zbv$+ww4aJ;A;z9WVM5(Cm_cOcU#*P9R@Ri-9{iLd-IgcpbS9zk1Hkhzvd2I*WHkx! znKsFxORd(C_#KA#4jO#meXiIE%z^f4*&Bpz8yBBSNlmu7m*hcWcCCY-Y&0Ps@Ll#{ z@s|N#szjp<#dkff;r`hfN}(|;#>s~JE2fi%v$_C z0D$cnL7U?&SU$a7D*N?VZ;ml@bvNb>wo;v|aPnZ`Go%Kb!*0P}cnYtpCOuW;cNIsO zGUn#8x3vkGGXRTnxepZsV$57DB?^Tf>e`qC+VU&0x#rxonm9ah?4v_mk*?#S8|nkAfe$Q(t!EsjH=6zRBA3hW(!!@nr2$QW z#&}ks=A-t(F4u*zyEeOAK2$BfbK*7C2fApHOVK(`MQnWp0J{XEP4xidb%Obq6zI8D z=9rJh3tUs6(ewmrTG|0K;NGA&e$iDAf815CX=Dngd6ojDQ9NJ~2sdU1jXr0O!y2urbGj94f7&)@a(I8&xf$(i6WapVT+}_#-heIb>p7W0R}P!#N$vBR zr~aF$LNQ|{IXU!|oUww^LNG1lWD^dJ`U@tj(XGz1vm!; zJEfM5VS2KjZd)X78}a+Xd{%P zn~v_Ov87vmy^e`BnWA%V=8&wM@l~nr{+8dm?%qQ}^YZuRxATm`dW^3=n0tf1Z#_3t zRAMZ0PCd^L)NY*D4JQ~{6Yp!QKX=W2hty<)m_FnXJaCZCwXh7lJ6=VSf z#}Bj!zl7eJ3ofl<8J3fRelHSJ84AZ|DNf;LIHq?wL%p{Vj;S8yWvaTjR!f&dDOTef zyAXTm?d$cS2c*}pz%H^oB)bZoX21ET=rKIRhNF9D2%wF@dUczQHTI!ff^KyB2j;IO znKR&ED-f%Oz>}zj0614_@$fv$g@dDBN-En_lZ`@4s{B+GiMSCI(OHA1kT)z{HZVF;yI8f-FUoZ}n#f58e&@7;h*-}3a?qledz|gH@ zjXp;O3!CQk(vA7<;82`Pcyr+^iCC&p>P|V8x_~tJQdB{;Xf`t6NrE$(Z&6i1(}S3x ziGrMj{VA$+PJI^8ag@c?G`}CZrR3nSrX;vFnWar~H^t}Fli~UPREJ{mu)TRPe0{z7 z{#hBW_+MeOR)_7>FDzH|Q2Lc-VvL|;0f^g8H|~ZT-w3W(FX)@8)jcl!$59r2-^W_@ zLcXnD3J=81Epo!|x@3XcZQ5N|@(mKol^C=O-@*$J9Ms-LTjg-03Q69G^p$0Ob5 z8`oRNhKm|k6HP=PGV&=#6C2_|an4M@-hZ=&YpNzEBg#pBI@w_x63MRehKp_zcs=xJ zl{cP2IBR`U@6A?RdnDr7~j5^QWoe8oKGH|j~cI0F0ceNhX=njCPL#YiZOINoTNcBRjivn z|D`Qz^&mIAyNV#u(eMNF_0_Dyff#0OFuYS83pTr-5w05Gs)X|?g}2*=&^=sLz+rLi zwt4;ZLT}{}>(y$UG*|)WQ-!U6MH^N?5L(?|vFen+O}QRJFQd@#0r&mTcw(qpWdmAm z7h+}TpbXj9V`N2o&?FX(T!3O17Oz`~?TuB4{v2rfSRAmSHUlq#8XtsIY7hbz6_{mj zb5?b3Kz{?Ng`_BqJ7#yXtWe3bNsrhg8hJcG<&^2lj>3y zE*haK+$I&2JJh2UWs$ByBh2w;(1O`(3i2KlJt|pxbC_BDs}C2o3HxflLmjl{ zWhx~L@h(*7cH#Ko)`G@mI7xa{={Ux>RVW-TdR5gthpk1+vI9|`NElrT)jaKYmL@7j zfw|M6{a)=T8bLNNahdmTBU7y2v_LPcA<{TF308-TrYXo9iA%HO5Uuq!TziB*trGOL z$bEPV7ZtE@WhDyQR6%fg;P37JaM3Z6c^oJ!le!dI*^Vx@&}7(ZX%f72DU2?^!8{Qw z#;~~rx>ZiAa3K$_fc7h>=VAk+pq}_WT|4Z8mA;*$D&1kLkLX%NN0s;_G9N{C_#qT+ zmZDqY+#eh?%E7rGgVE0eQ3Rkn&A%}d9w8XrV?KuGV04H1fP8-){{x&rxM<9B65JOw zWhrnm_ z$!kIV_+B^$ZY_;An@36NTY)G}&zL>rWhbh{UuJNKrCZCo%&%@D5BAvob9@%_4ds$i zhVn5tv5avuP$sZ7Qey|%SztaZFRfeyMqpJC@5Smd9X&v)Pg_xzjpg&rdRKG{QO=IR zDYF|TP`-H0att(VRHRxv1c%yK{HUa<RK*8H#(60y^}!98M_~?MkAVn_aq&@DVb_*NB*Ny} z^_{4EuwQ{?EgR?X@i=nhGOzfH`1lu&N_GrYqwS92s^3Z8N8=rpc!0$`o|V9J#fHl- z1mg@(MGC}!M%f^a0SIA8MvmBUhD?Yk8-D9e0sn{N9N^g>nCt({?xkTox|f7nC$r}d zI>aNL?=M66T;+o^kf;G`Sr7omToV|l^l#rzyb&yfi-x~II|$O9!Z$7!MF=m*b5;8E zsOqvxIZXiBWSUdqS=mkbWM0Jl4QBAgC9Ar{=(#?lU!KFj& zFN0_5*d6<^jDYqTz6eCjf25Epp@*R=A~?-9TRxyYum@M`g$ixdLLnLtOPVj;PEOeU zx7m}}%m-eb#gFs;dwgKOXhjyxlK7N%zy}4uM&JX)lK7mQj?co2eg+?H(Uo+polHqF zxR4EDRwR(irp$W+iXna#2JC=wHv0$QQ-U+;`V!go)HHDL-la&d7uk}D{$#*V2o-0F z1Pp2moDv7Z(%Ov(T*Fn+!IQB^F5(UsJ-mzxk>%)}62HT7NopB1;bkl(Ck(S278-1I z1T&zH=zU&M&BFI3{hj&cCMwxzfe9re>za#wfaPM1T9u-dYzjfgL5=XgW+}>~QzPs* zZ#XPPO=wQI=!<8G?`5{`rW5mqWTp}GSc;fEH=xD4saDzMuxTlZvTcf1slI@{aD39rZZR zn)I`w-a?rho+Z7L?(v~w+qVsWQ2bX_D(}W*-f_sQH-8L5{T8Devi%p74cO9;q~>Rd zCa8c9f>NkKO$dW%-I|Li`s|4ccar*o=V*Ra0PLCCBN75Zz0tqen# zqCfNI_ry)zNZnTt3i;QQ8J={K;SgICi z5(u@!1uiY}3WH!nR|+yVlZ7mGuN`K^$AT0KFM5{fBH+?iV7XU&c9V3_2w^#C$tZp* zd+(G6pS*#^Evgu&Nhgh22dk6LLp7J)j;@_kS75EV3e!vI3!gx`8{bdzTaQ`%saZ$1 zVGcq@-eqWL073)qeGsQSuF2UN%EV{Ex22d^d0MKS@u_y$9@_z?>FuON_PTl7M(QNB z^w5$0Ln4IQe@X~wu_Z0CN52;7q8qCj0EdgNSHG=v%k<_un9n~%_JdWS-GtGcitM4M3pvR#iM>Cj&c+$Ke_X88KMv{>xk-@t z^r;~X#?Qn{5JT@kbOeG#zaMrq;a;n+SK@(MNL0|PUn;U+wO$!2x*c{kc4Yr+iR@zv z@>*cnNn{@@Mclsa_S^K>y`+PJggx&E!I!XJ*Dzo!R}Zi%0P zp#Mi1){AwM+b;-logr)q}Uobs)jPx&MX%*@FJCF3sl9B$+q$(BAJ|$}! z?4c!6SCPK2W2Eml&%B0ODUrS(k-mzd1|iX!vn}?qGoot%2J8*tKfUI^zQ@t)6U7x2 zqX!(%9&oMR6|;ddTtWADfgT$VlH@Y3xqtzeqN;~b{qJi?wnXTM>IvCJVh|f&3(Ho9 z5Ss`v$zF~z{IwPs43fZn#FL{-fcJRRNSD{Vvmq-l!&Eyn>GkX#S@h46mdfaDq$Fvl}y4jX)k}bQuQ5 zJa7JSi0k-0!`rp$qHFQ!3LRIpv|ATf<$#sI7-y$Xeu9aIh4;7@doDr&URd&y`i1hOS7PmRB~R{7}ixc=DBem7uR;VG~<5aTO`k6 z_7ZaCpK(@Zf38&bT(298kLDT=G;ZI!xQI~KF2Z$x?ZfH98e6*RLt43tiB&~J#d|7Y z6P{jd%E$nce)vdFdjT#uY^du(1I-5cKE%K9O|mT2_)%9C`hLu*3#0Fqf52`xVwqT> zw|m||&BVG@M9q8-@lJip9wC=KYCQ5c#-2611@q|BYJ$zMz9Fh|P$V)dS2BB4x@#;! zS2G=A()HL}7|^gBtJ8ks)B_d*`28y9Cw z3>f4TEc=yxA2N9Lo1?;NKNgx&&BJjtW$W$@k*<1Sm`Z!wFk1q04N)wFYy%6rHEkl7 zx@EvZH%f7eeUr9mG_~XbrZh`sp)mZCrBQE?uJB8uQS;%QELPO4BZtKOl}d$Jm_^6| zn4af(TocE&9nW*>A?8_%2Uy1+@MUqP%IdYMbY6Iqyr_=z=(u|di}zriEY8EJbjCW% zNb;Ch0I7*s{CqHvyMr9ELaF9zK_2PxB9O}BWfsb$ktmk|(|r*O6XWC2danDr_J57%;Cs%n?LkO2uU!u~Ur~a-*K@*g9iAZ@qT} zV?J~q@GpT_h(C}mpg+o^KgvrDHyH*L)-(XHR(mgrG8oPjX3p)#k@MWaK;fd1M1kf9 z@sM!S@nD78ZBQvOc zcxkEyz40VS$8#e-K+1`>j%bR@#dY!tHD2QXE^T%#-mUJt~fa4R=9+qv=Hlxg2Zc*W*;+y#c2#>Q9QRsKX|5W;n z@a|HIOsB};koq=sg$~6AKF2SvmVHGcYq#B2Okb8u$6k&;y}KT60{*Rf?1D@^cCKFd zjdu46lq}JfXPjMJ-C7j7T%BaAJO*Pd-nOyujie1iusR%nX%nswK-LCzrb$++HnCG_ zY{T8U8+3Ooxd5A+Kr>C&LFg(x%%dQ|g@v5EI!}VzGFE_q8J#w);;p8<+Ki&lV{GOl zFF}HYvvlehI~T++2YH=NQ3Ba%~r z`l<`sz-gwM-CnX6T~MYtYwH_MEt~J^407$QD7vZ#S#0zz^{`Pc*WjR@%pkLQ(yU5eRzgjyQut;ctWfScQQWn5Mj2~l zk_tl7joVwO5__l;d(6x!w4NJ@;iD%J!zEHsZ;r^}JaQ+s=xd)aSGfGTS86-D>p8#9d3graXrPOH4*VrcGg!JZEkv=2PL zsBn{Df>tM0X@`6;pFUFY5jtRL!whOegEHmQJ?yY~Zk5 z!m&;oJM|2VSt;m6EY_h)m(5TQ%$YC=AfO1=-R4l2$_pKlvxCh-)DNmWsw_V_nx=ISelE zNIanrL1%#;btW~7A3~uq9$JGdaoIBzBzog!z`T;h8RzQl7?EOQ;(k5+(_wRt*H^w_ z^+7l(t?&DcTVR7m#(jaUEy1Dd^}@I2tWRLJb<^B)(I@0B&cH3oblO9=aDjf`PQ9^J zu3LBSq%!+;>={(OI5$tCYw)5w;klD7=0jIPi?H+PUVJ;o2RuJF1?c;UegV-hNUF2p z`J$K7Tg7|1krvH^cQhP4mGa4FjyodVa>O6V@;bqVao2-+=b0FDFSbav<`Zlvuwg)P zo~KOp9}@3zg9dP{B90Zru_85trbSxdgpyi~6&2%oNwD@17~>Hs*xM-I)9Q*PQ*EtT zpV8}7GBIlJw6S+PTHOqkNPc+8>Yx!!2Xk;|5L^IqGW$@ysFU(QV$AOmuaYnDqjvLs zFap3@fTapAs&${jZ|8%=H96Iyq4u|x>28xIlFO{-SL}O}p3E{cB?r~jFtc7j*#~jS zr!Y5C0WFAj5~2me^Vu~BsG`a*tCqztQ@v#r2Rwb|z1tYETSvP=2kYC!K%Hl(-EfBI zp(HSyd9r;{fblju0ajuG6F7O~0aOg5GusDQfa7z;#ae)DX;~Yl;=Bmau90}x^ykCw zc3A_1gW@-%Bxk7#He_k0W_OG55?Xbc^GtWW!kt9%mD4;QrFs1k?i2Fo{Q{AE#=}L}`@5cI<=0 zhm8{{)f-)bRdXt5g|54CnvXlOW(HRIrp=i%d(JuXI+rs$NPU&ISG;N}KIOmxcJgqe zrZE@VtcBmfCqlYDU2!e_@meH;QbA*~n}-X!l`QU4n0SMFpqDJ3kTZsHAr#s3?$wqu zpiv->s{z@3b`ZMaGw<3$C7_>%{PSdsI<_D|ZZv+xitsIpNSjBp+G6tusGy-lZ4jak z6mHYPyqPoz-jpL}QntIe`ao6aI(#k&9gc+*EULtZGDf6f0g+510*0y>hnRCL;B%Xw z!PyEfYz^8Z_;rGejYklemSbH$4KDZlX5%*xK;;8~Cs3R~e+gcEEK#+)r*!6-Ihw-} z`q;%t7m3bJ0wx4b(&g5yYk`R9mgQoMrg#(7*~U6yf+vVO%+D{S$KGmwi0@VGy3M!o zRBsMH4F+&nngOKzCG>xb(*Ga3L-lHQFGEEJ+fVQt`Y+$$t%M6)e|`q#a05q8+l>?Y zzo69}gZQ(i?XE7zFVN~{L&s~{4&467(=ZZ&3~Sn6>(+jxR-1)qjH=%m2Nf!8)M^ui z4O?!&x3;{u7I~Qop!z}iP6ci19RXYH4aF#U9+?dk9aJvU{QYlb0pq4P0~mNK`dT!I z{YS7=s>Nb~N>>+^=ob5poF)^&6xdCVPqAT3R5bJ>{2+>j!Q#% zhW1+xzm!l7@aCEay10<8-jEFVZG@i#_;DF8+1$LmA%RW#sy(@+qo!^0i1VjcmZGVn zu2M~%WfvgtYa?h0=npb4MXz#1$Bnm*Md4jpw^LncM$5EERn`O z+zw>P$Rk8-KY#7A$_YUHTV*4>heH)0FSXhaF;grIJjGnL#A4tnNd}s`p$BF^Hg%1o zDROI_veU}zDgO%;`WM=;p;E=XL!pOOdm9>nFc6~QlhJPg%^(ZixyVQ!nMe5yd>G9= zfdcXG<&=WLlu^&+8xt?s(Bmf|v!<=c9E;0GZxeTL-;S{_+p_9X{LD+j)mJa>z*UOs zEBIPSD$i`ZzY9-C<>}WbrOcj0M; zfFKd7zKhoM4wB->9t1TdtBI&x({^G*x7RCiS!UKE3-Mps6pK9#Lm}AHV6!{G(VhnD z+A9k8O7g9Ot*jv)X&SL!aSAJiM%I@T74GP>6l=+m_puNR%!irJ-X|OxCWs$P#0L`O zbq9gmY*&vjMctaV7bms1XmvZpQjVCv@@?Uh+iEM_Qf8w9`BZKeqc!rWT$+0U`=QLg zBPqV0CDJH>rLcv{nV{f?GDQKlWhx4={)r$7*FyERAY)LVqG$8Nd)a~=kt#QhTq;@y zg*}|j#X2_k63B2Rp0(k}U&a!3P1~E*Z||IX<{!TZz|d+LreE_G^*4*CH(?bwWPhf_$v$wICm>tx$k(r*Ym) z!0S=S#z$!^q`v>AOZJH*&c3KKjr|nI&M1j8a|N$DfF#O95<`h@4xv^Y1U03xe?@Kc zHdZt|mw)2uATiU0--Qr3SgK=oq#~$BitF}nBO!aIi<<@xIFar2odtwog+k$ z$sL3U@(ls1bXb#ds@+>7=0dQj=0Gyd*RXGl6d>A{VS)tz9S#&Cbo1t#SN@HhVo8J? zcTMBGoS`E{U6G~L@qmDCly$*%>knS2vRpM`r*$}i9=M9=((|%g6Rtske>zy>HOZ9=1v|60v)R7lew1;{PsE0O@_NbZ}0-0On{Y4d;qD+fjW+;9&>Yd~-N^RBM?=qq_t>Sz5 zZDciMa*E(CH7A7H1kYOy*n$MTXh9}?acVR{WFl&s4@G?_n#rPeG!5lc5h8qrjI3n> z81Y{=AIxs;9F@rEnzNKiHGHfuU?3f{FIjhd4x>xv48u>~q@a7oUFMw5I8Crjj#U@C zl`>lcizJLKl`yK8#(G@lJbdUz3FklH)eO&GnQgLh6{2A^N^7X+b@R_F^0(Jwz%N8pZXF(e7_L@wj1z4Y-d>5p4BO~v@_!9 z#P+sBw6s1X`~Qc)t2~9y$)3!?ciQ-)L5)9FLb`A+4bs5VN(13sBoH?|4_`t#fsJ-_ zFY=~pnp&e0vv`$q`qvGF!5yWR<4Km~11F7f{^VJ3C%h0krQOw)Eo0sDF||3^JpX*W zW5@`d8Y3eKd{ZT{1!>zILtv-1YuP|dRv0v7`tS<5jLC)10HiT_;i4y1!8@1`9Rt+P z%Q27QlqLrEm|Ky#kEG#VZW}JtK^P1gL@n$Mw46vu&J)0Rb_!T)4i@VHCf~7wfvt{W zW*D6a-)h!1AP37s7XgF)*lJ*2d_G0KBYuNK^yt=2KT_gn%OF+RHfpG4UTeY^mPh#f z!{#%>2kq$%n7eS5Vw|zQ5^_quoG+Y-xwu^VDIe$J@ZlN%Z%0=oD++)6L^(h3L^amtL}0}6w&!-M%70;`Jq?paX3yWooeOEoqO4y=CY$oC$|`qObI zB4uqbc4cNT{{uXJt2eG69C&HRwt213-2GM-q<`iu;%`~MN@BC z`_?X`{1A-YkUcKn9H%|IE&#CjZmh>i^cE}!g3>mh7QUGx$={>rw+1n(!(-pilk@V+ zn-^1K!)=+`qQle^4)tR97t?(6j>GR$-d_#sh*hkpUOn!|&sZ9G3<7P=alEG+!|=11 z^Y-XQPkaYjc}G$HPW>gDVpMM;#rmr@#Ykz^&m57N%#nAV#kY$}g1bWk_Lw%B1LcZq zn?0xi2ZZ|@;y$KB#y-q$03{ohBlP?&`f3L%IQ0)yUUHz)q@Sr;QdvMDu_OiKhZsS` zdf-<*(FCr)cEA!r>Z=^E8snFd+r(f1m~ka`T%JMRZ;flqd*W`3k1_#6TYfm6y#Ecf z%yjj`{I#d;wjr*1DqJRz5_K~&?jS5d5Z8bIEP@udz(tVKDHl-!zRj8xM|)AUC(Y@p z_ST9J{wEu#L$ zLMkvbxr9AlrJ_YiEi=C@@Sqre@(pE5%}@A-&E$WA!`gEV9hTiAp^NsKm$EhrN|YOE zA-&+Y_{Q72#@VVUE!ZP8aenQmG z6aL*T2NOP#9>z(y2BP94RceaxwzHjtC-^3W1GgC|DZ=+x-3-Mf{@t+-0!7_9g?vHJ z4m3+iiio6)q-@9T8>g1f6>hLF3|*NcV8jen50#6sB4TO`|#&2k)dM(3EvA) z&tDc;B=xcI$%~(9<72k`ii{yBcED_*%zT|`(H)7UAg26dE3y&Ye*PLnXNKp3w8Y=3 z#FetLX~jU;u;ntR-oOa!s%!{k0p=}|Jsw*D8#BoW`WkMZ#TrfanOAxBA)8+XQ(cLy zpfSd+yAL1%+x+W;M#j!@hTn@jGq7F}>WvFDD*qKItjMgyh0HK4+2Q6xMQ-rzVDG0> zN@@0v0vX9G@xm)5XwYiEL~Tg?vvT&}V8|wP066o~Ga$Q{29l-3Txo&%xs#ra*e47SGNj=c z@&qsOcrR5QmGH|FsEtFz#hH~uAdfSNG8+^j-MWmyif0fKWmgai^m~Esq^(w1o+l`e@G4HmyyfSL(KP6 zNZbZPw7@VJCD`=pa^-M^MaUcP$Eoa$SVgApUa!|2;DAx9%M|GQ)yp^Z_87=5mA0%= zDF-QBX)Mj>t|8pn6u$y$#0ygLaIVEIH>L2}tOrqvD>J2J(hQ0PXI|C@qtM!S@Ix?~ zaR4T%h388fT<2;0JcDMd$9kSid_`iLS16oy4i5-1Ho=`iPJ01>XHuwPVTD$)NYTOjBMLwcESj&;x@+0=H#n0&d25B7P z@DK;?mqX+o_X?;IE|FPCmAJuFi_g%_O!Jy#S10O-D6qCafg20JATTfp5-NhRsk~$A z-Cz_aA;D12W{}2l(H84~&r%XtxI;5e0XU95Z|)~^?W;!v-A{K%|QkvmyF z3bz7FMf((gXE+yTCpVTmq$ymcclvF zJr&21oEbNy15==bh=Ig^+CV$N;aRe8%xe)4VaG@iOOTWBhzVLZet$(0-%~HI;icYu zwl_TA^=T6V9r}~kiER2F6T{=5V|B7`9Zn)WRd2&3)7pL`q%o31^P*AEU|i&O9`)L* z$1-qc4U*7hnv{N)`zS$U9;p@K`KY_O(nG?dENqsa7T;;*VigI=( z_K2FNLKWOD_9mSFUv9Gdf6TEl*ioBUcr9D}IvBaR28Z3^{ZfO14)iWn^ky?&272=0 z$y{qqM?8BffnquW=O4iXSLI-ZeH38|`^4xN5W&DGItJFZKXJNbn=`QNtKtqw2YZOH zEQr$PcuBq)d_fg+B;T4x_<#Vvl>*^@p?B?=1lyR*L07WFYSlmk@0~-G(E)!hzCm6< zg}b7GKbS;>5J$|HzLYkE;OneLk_26Q|CA(2)!>~)Qh}~W0u_oRD5fF_E0zqoe{*Ul zBzeu-Bw3M^XI9`Xk%6tX(M|~aZl{y5QCE<#!6fXYlyExIC%;b%RAz!A&;~t`a2uY% z3g%Vtu@X#V7Nkh2K(|1T9qz+J_^C}^vvH9shD`DNB0-5;2|A2xZOyxT0igv>gwpsu z?{e@O(w>P{fR7Jt=HW==QBcGs5{L?V%nftK1e2xci-DTw?rjWWVBAF5Wp=j_2C8|{ z%*1-LFB(qVe-Qmwrng5TaX?qKcx>k_GTcUsIq5C_hNldKMQl<>o9oO!WTDM_l98)= zNT+woL9yHHEA1oXS0aR#g^OIXsehP=CsEM9Xe$?$ z@M4~LGBEqvbOAw`E_2|RhM%^mhOMQ^gj0*S{(&-aSs3b$SuDterUnc*ZArs$F7|rL zpoA#+l@dXBfEfo6V{k!O=`7-lmwrU`ac=b8MDk^;UxiCYN{23MAd^m8KmsH_&eDGVQ&f^UhsociPkehAt z&=`EPGOWo5A(rbftRSb?(QBGB!U})bnV6GhSY>3pwT=HQV#VzeY4~W1IN{epenKAn zS2<;XLl>EqgOUcTS^#p~;gr-mju~uwSBQW16+=aG6vonM4M23(1N-cHhe$S~hXL0K z76&`v`^2H~#j2#3mcuo<%wH!Fv3-usBpVCp>4Ps>{mpO;Ux;>I1YeLsxaj>GsB^dm zv)G&HA(z@6o(mOdF7^Qte%t-VlI^y8MLqMg33RUwxZW*(Zc-J*iaO8(mv|`tUw$w> zZqxWO#n{j<$mJ0HJw&p31hM^fI<_79yLq9`>?x{(G-0gt$52bSS+iK;C|orVvAS!p z6j5pPda@L%uBpz>cK+5Cg->BA7QfR7joM=V9?yw?nN>KU5}&IuOXJ_XiNMF_?0Y?t z@ye@saT9J=u7nh3&Kn9d-XN!Fzp}z4oF0a6fyLoW3Zg330JuJ4&Dh5A?VizxvVt;+pQH-6JsxM4ov6EG?=oUvYS!0}HK?DC$tPkGI z-_OOzoeIkx?>Q>;B;4mF(kPzl24Ox9)li*^FrJ8uz9aaG z2={OYw+E1p>&THLe-5t#&5zH)$Gxh8$GNla2v%5GM#7)>fbelYYhT);Ghu-&@0p6N|OgEv~uGGL8e=+D$*Or@km087z2lkMBLmCgo=DTrp=`d8GQ7GgzJz@&9C9H6yiO}SeY=%-z6NjUBkzeWBXzmgW)MwEy~ca@Z!qe)vL&6 z7jM)o_I@C{cx+EbIw-){3lyM}`IQ-vvmr4AXD`eOi@)B)15o^<ZU?XX6Nj0C!*t+~h!BAk`-H#!sPbts9|~kx^RYZaiuIOv0Y~Xu6a%tz zPf*s3$e7as)Gpow!^p3I%sL$R3`812xRPf?-umjkfRE6})As^&GvNYPSy%> z54y~y0?N}i7I_?zTf9SaE^`=Ws%ctihFkk%T@e|DUP}Q*X4383`d%vVP$#iN51*U< zQx1lwR}Tko5GcCLQbZkKT87gBaj%7WwuB@3ZV2x64hjlp!QagU)f`ZzxCv)Nmy6pW zh;SY`aiqFjE3(CMD}Fjb4o7aSqGG0)(;BdtGbnKpcopYsM}Fk=13zrWU3)y-5{CJ% zh0+@Xu-^j5i#T`+f(Y7UI;dW|ISf@2+sq$_(B>I{utRlkpj>ry{OCx)Yyi3s%LpRlKH+61&Z_ieEbQ;NLkG4w|tAJOkeO7T%a?seN3MWMHD_t*;?Oms#y- zTxS5^=Br+ zwpC%2jorfQ$#oERNDif`-OGI;b9H6@&)1@U6?bH|;d$z8hmxH^q7zv7gOYXsl_P`u zZ_I5f<49+JDK2*vGLk>qlF~5lkC^xKwpxjaEQsbo++?V9jkF2*5VN|Cgn?!OrV2Sl z>BEoY$XL?~pA654FC0M#4Q zNN%_l(<8R2n#WBSJ6QdlLv;NB!yJpVAYjYpNmiRT&y<3{`?_PnAt-20QeYb7cr&z{ zovj2F;R})b$~39lU-l+ixe`)-%I$hF&n&xRO$oww@_Rjb*( z6!>!e@j-qY);E?kIL8rj)$7LMR_xECx8bVOGM3`6y|m*;Up~Ui4-8h|a4>MC)`0ac z9?WZ+LA^uIZ59J(8i$W2UE8G_-|n*ZzT%u^0#nPprslalXr*3{J(qVPT08kU7r&zF zE%sctykV635TE!1#j%H2L2eEBg9k9J)iZ=N+VZ)X4Dp9<(QEhW+Nf6D$T$Zjb_@B3x!JV%aoQx#Cq1`grh*mm>b*268POawbM8O&%~32(eu6~0Vv>- zmFi|L^pmox>Vjrai%Zr6@t)nrdB=#p5zP z_P`bq1gQQCd>-!5Bs4EMdk(GoFEFKUtD zgp@)|we}KQQ%mZNX4haeEcivkDmlzTfxr5Dh+9T{$HANmn)pTpJydYel z@#oMeR7(Qj2vE*$K7$N1lLR~l_bGUKaH|nq0 zP1D=p_EZ!@3yC}V6y1WGHF=DRagQD^CQ0~tg=aAtVt&CH5yMj}7Z_MR;aJdy`!A)p z3+FicSeb4#Mnl{#nEBZC&_ zr++Kw>}M%iRbj5c??(Vsi|os{P?Q=UOhX39L=8x~T6O3T|J{KKw9RF%u!;dDicM6- z_Ov^S4VLz;Vihb#uxK9c$E-rS*@ScL=HC?}?&BRS;o%7L?Ggq6Z+(LR;4mCKl2E;~ zc)i3833s?J$vW4>2FocQY?4=3A%H6OixQqH)xfTumy~MYFos!SouT$|%`KNdB?jQy zC`{&I916$Cid1$0yaMs-PW&7eQ$SNey@VA;PejLob{-I8uP^)71=UU@L_%*8)Y!&S;F!wim^EgF9?W)HLzveR)5DUnfNHm2zUsy z0K97iT!vvNWllI~UY-nBSeTQRY`y=i)MV!5{BJ3Y1l?f*0% zzx`CAV!l!wv_vOh&lzFU$I9v8^HDUIY;zH&+F>x4IhO#i#m{9vGesT#J4##8Ao#pL zSxP?hio+PN%fw}dQ4+YLk0sjwKryocyCKY{6zGD_92I2Tv#nSlEpU!icn6KSiWyL@ z?CC)MDDw-cVdWkXX^XbBItKjp0`pueX$C-7VzN~4uHWJ zuX(Sv2@@Q*_BEk*k;ZG*5tk+aL8#-Z?7kA=oGY;k@6bTCw{8_3ovxKMCjPk6%iKpW z&kt0A%o%7BWDc-qLFXbIUEaXb2!$hA$kbzxRR9p}II5nw!mtYnqgo%U+7)^A?O`?b zd_`WQOZcTd0D%qL=PT$|vBFDAwa5`jY7R4>=s93qjHcJ*EJY&58~1Ub&R+Hjyz`=v z$W>@Dz#mgB)|SADG0IUrCHm_UnAYj+5@s-9sYc6nb1h*8~E}Ls<#gAeZ1j75h^QQ%|Ef_!K6q*!t<6dxFve`bur!Yn>$E829 z`$@4er#<=tA237R*;MIT8;&YkZ6Q*}6@ITp^6-GppPc#(($43d09tQ= zxi~vms5DUvQx9;FxsDs_senrX0?)X+OFdIHc)tie)oH@K41$6$utJhNvp=SZ!$sXM z7{bQafNFYyvgT@$H>#(uM2gi5cdlrUK6q&Egp0B-6j0Lj#XQHIG!UBCaNAJKI$?9@ zG9qXr3V&J7wLm!6@Nb#H-Ux>gI7)yO^<&_(R4TxS^9HA(i>bJDwx?l^KD)YT5*L?4 zJ;FuTjO9aNegih04kQHsp{z={n30q0pZ>NH*7HWV$U_K~uOPInu7HUaX4T+JyT2jv z3^Y2!vI-qmQA6To0t#k~kb$uS*M!lRp!cv`1bFT>--2O~eRge}zlhyy^Y9^yhg$97 z=;EtaVh{|{B0r&z)0_RWsH1)aPZ7gb?3>o4AuA?Ct6uYj&)u&0J*=53Y%2rZ4pQ@! z(|P>_l;2nJ^wxRaKE$_QllM)0b_&G5O*p2h>ytidvd=W=1{Ao{=j&4e{=;52aAele8 z3LTD*kpWGg9861Rddy>a92|(_wjp-X=*FQdG7_RwV9aYf6WpBxXA%Dw$1lbOZcZpBNgHcuZA}zyqQp)x=oy^B zpuQS!7^_8EZHpv9yay+NoQ_jdYpb>GQ?<2fZL3xbcu#-=f)@f-1*{@?IpbJGtX#a1 z_xs!D%w%#w?fX9O|Nrp$kU5uq_FjA4_F8MNy*G;Jcq_KtJRP_F>~T3KT8qY>s$AsT zDBn7yqo#W^XZEh2T)3geTDT-_s>JyKEG#LD#OtM5w$wZxqCA@Ajd1J}G|M+&#z=f7 znx*LwF6N?Ic3Uyci=CXfoyz$b#TYBc-nE#;^tu?&~4C_y6T?J6*a}PlSoXc z^*7%##^8h}v#d$8RHW5=u_8OxZ04UX=0%75U9gl4!7OOg5uPqK^S_tS)xPsL!dXax zgdlI&g6TT5WCsta%VkvwbBjB=bWAtuiLu65>BQPLjT9}6`{f>UDu_=6P8}Nr3p}L0 zph^~K*a@%=J%@m&P@rHa*Y*I8bTqOoyALYIYh$48qaW;E&;)s>~*iD^3VXP>}*EXt4_Ba@hJv?hstkcgA(dRpeiK(&i?36rGVmQ%=? z3i3Su*HZpEf7P|~YS)%g6(2i0DqiVI4XgOT+1>SCQN^pyBPx;@{Vk>K_2l&|!7|)t zTVGq!F~hd5K~&ZudWYMw&1^P4n~`RB3FEhV<*?s$YJwybr^BANG}nwH$pe|E!Bjx3 zj+*oRaoSQU{{{X;USQ^Wttwu(&8lCs%{phL-%!^!>rDO^jeK&&-V{G`CGWer4;;Eu z_vfsk+zjiRYvvp-oAr#RR0m~>#++f^pSjBW{;HzBr%+XasVZ$j3pmyr7VA$LI;HT>-lzyW zpeK!H(p8Q17HkKm`Q|^p!O%Q!P=^o=ZIb%kS75;g$ds)QI6wXq znMZ@f*W@(G){3qhD4OH8O>?*Z&erkZ8PmON`a zJk|n2RDV7P${Fb}^8|E05jYDk-Y84Ah4ntd7r4=wMpw#g2S%*QX$~YkCj@6HaQ^M& z+c*p`C=TVoB*vZ0limy-9p0fKN?tK08X&A8zZpR!vZt-8WK$<5>|;BZ7RXtd;JZ4c z_1DH1sF}%ZNL1_GU|P&wQ-iL;D}KWGD@s5+!An2`#!BWRKe!WUs=7&=0A3=IV}2Z= zKULjqYfXt+qG>u*s6l~Hp;U-G&v|#1X|~I1YZE;ZfeX`RFQ#m&k$fr~jbF%~bJizwjr|u0rORCOf>&R?U@jJt z;K_00dF`!k_JNw|0hQ#q69MIurEjmyc9h9K%ach2l4e^UdL)^_=*V$@^G!3lezGfT z*!_xLw0bXI%np)&O)oC?UQEoMgFZknPT>XPF*~^@-$DWTqbB???YGLmLfeuTMH-fI zq^r7Se_$s%#Bk7}@hvlYEY)9gijn_ufBkOFe}k5gFW6p@M|3<)ZN_Z)hB;*%zTugO zGVY$(FL#w)RaazPXB>J5B`|LBu@F|PW)q_i;E0pm_KuBq$p)LPe&GpiP5@7&GoU3R za500*RvTkA6Q8ElI-$SFo#LY(;>(jHjxCQwbn~`&E|6Z5hH~q6rMJuBb*0Di)SvpX z=uuAzph~yw=50X3$ocNYg|5_HEWf(KmXC^N&qO@ZVYRc%nG;1g;*Xkv=22bOI9t2k z992`X)!AKJv7!doqNZY}v!m`* zMFY26(gnI^LYR<$BHAx0+2Mf{yS$7hPSmG@E_MueTMZ4uFx9A5v=Q0aXTdPD3)m8z z{c&Hqj1BgbT+E>biHYyWs*h9i&67Mnb4I@pnof}l!2g=aW+rrG7~mJ1QY?dI-4Od9 zipF(}BAl7T5`&4`u`S;6H?au0-{96;h>-fLO2g5Cs;;c19derxbf#Yv1!4c+xmi1H zl?xL1kR{l*a|TP6ep4j?3Ca&Mdmy0dy9`E>6VNzr=ZCcYCM_)5IMP#OPxzK91e;r? zWfMqktojU73#}p^{`W5$&4o>}(!GLO=t*h|75(KL%nb*P*z8xt*ZZ5V_wkVK)EI%C znQS-25o;taFLRIfAd$Q#7wJvniXu+}kt zt4SKkojmz3q%2SjHO|fobi}ZV-L;OCMiC06)`;<#w=n_c$J+BjrC*zLZFG?~P25Qgp>9CjYLcnSFnGeW&kq$SUX4dc3!MUppKD{?$ zxW8|cZ8I0)#@=%mahKxEd%*_hxp(QlL+ZUu^7oeC)NSuep=e5!uga2t65D0FMAiaF zkDQmxp-FDd^N?{OPqI~JKYEsU`m(%tJTvon-n`tp%`Lm~t?RUDh$suG8$+?KPs}DF z_PV$1+!yWm(K=4lx^H)SRwDL2l}-l&39i!3zJb8s@hp-Ux%7l_Ig>c*ra;-3RxD;p zj{Mh&%Fi58V^{66TK_46Xp$zXmuwp4bXTmkcWf68g2E1z67z|{yrtlcaN%))v(t`U z!;yfEwj=Zjw%e@p^o`3D61@LI%X|8`xI@MV%@je&h6?|o;=vl!I;jft#uPh zUHnea30`L#AU>Z@`zY^)}hv!?QTY`yeg8zwds!RU~9UPBzKra=OXYN*-p+ zuYTdT#_xlqgHFprQsY#fJPq1vgrVemqjhe`3DU8uUCKP$mHa!;0Qd$I(IHE26KOXO z7@oiw5e1!<$tSpX4;jv!pb1yqOVXYfu6jUM=Go1?&vd6MTi3Gg?dqZL94P27;#2khSQVQ=rmwcHWet2oqmQt*anxI;Egy zdsl(gdYl?7SxS*tHMkQ=9$VZ(lKK2`ylDA2V8uqOM3-ARG0>P7>kJUaIyh-|DQ7ub z>?1b)e~yOvY4keHqe=LTuIs`Xf2#xC&qzq_QDn{h)+LF z3xgWbj)ivo1Q4W%nBgHTVGRrn^gZ1zOf2Ly@2^F@K6&jS+cFuuT> zjtjBwBR_b=DiuUej2LBF3(?x9+(zb#Fcf?cF(rCIT$y^yS~Q)Va?O5cJMH*h#vjy* z7C}=+ri_UP!%nY@b-Gi@NAwHGp}0-$ujS9?M5@4-WyPjj$VNiE&hG7>EPW8jdzKoe zR`T8a?1}FZUYY#%4)@0AV6xvBCd*P-{q$9i$8Shf@AxBBir-d>l7`>JEQWouSPYFk z!Sk>BvKaXMOct|0kHx}jY%mrphhH&*~G#JunG~28c6YY?@zKkYrUaf)%d0$2wYy4(4NxKbV zh?(NHG_WgEn+M~z1AJ~{w~pjaqo8(q3Jq?%PxqgJ0e2=x0wlM1oYId!?h1gkKIgw^ za;9CV6pLKU>x?3rtg=k?wdieH7x^cv48kk)3{-h(ckoO>?1TJv4u6eZt|>b+1y72k z>Pp_vpK#9-X1GuvLz#hZ9mDE02zURBS*{;wV(V|rW4&$7Z{>yU zu(}sTRN$^**=eTxnT{HpWKFs!N}p@tD{JAUM$x{X8Ql|?_1GoLeUN^TN0CKWO4shN z^JZhwtmwMLU?^}ePYV>G3|pD>&|3*Sh`;jBz0)u2u5 zl>=k;%U+gBysEU`TilI>@W5duSO{ZeA^12|`mLQjj;^}@aIpp6O4kP;F(NHQ^&E1H_p|Zs_ zt@))LY0#{N$Ja#(GZsV>BbG%OrF?Vcdy|A+*n#ezb?Z~Jwaul@;NvtzZs!EI;z+Z zPE0tGpkP65{Or?M^y&?kM+^Rtp}iR~(`1(}Yw9y-R`vlt-9-(Zs3O94+ApijFo>UV z4isjcg1E)7f*IEGW*-i_Fdo!1zBcg%JGl~~c|n8iOw`^!8eh{4mb`;b;n>5NUbrQs zF7eviA4@mnJA^y|R2!+^Arz+)W%yu9VgkE^%wgm`8taz5+vv_rrk#_knOTlFuOvS- zGt5mg*L+d-NEtNS9~m{&mmvghW%3+_-TfY!ki!7q)7qdC*v+x(yswE{S)J$af#z_A zD{tt|`s9&nKm8(cWs$qzn=sZU#_qGSSCWjOSMJN?B5ci?P>drcr7hOHZS$ z*ju5x+u6P|Igwe}tl_@Dzj+f{ub&TWh)FD;7|k&`eHPF{r}EakSoNXf>6_Jdq`n0+ zK?2MutW!0eKB=&_{rD-QND-XK@rvz61KG~;K|4MtWZZ`4lRD6P3eMc2SMk{dXO83U zr1V{UDE@z$X=A+iF#=7g_z5_HfAn4q@m^FiKJ~ij9r62(d%oDX=ZkecFhr(E8F4e5 z^xdA5K8aN7mMaR!&Y4DK>1gzv^7s?_zBWEzmDM`)z1ntly+y!n7oPLvij_58$zl3& zb}_+2z0MP!6FtFV(ZRtSGL4~Jn6a#To|V3L8bf;8q9tkD?RBmh1Ku1KYHzfWMY#NU zBxF)SY*XIEyrvPX3@dmTg`cyv0DZ$6>QA`t4JB~CdZoL53v~WB>Vvy-ceU;JS`}!4y7wq?MVWgXbtnRLWzaoRaP5>(!|{S8=mymSC&Vl2M5t_(Y4F+P z-zen1zKr50bCu1!T=%m_LW9^NkCnC4FN`53`hm*T7E0jQ2)0)fMi|om{&rf#VsENHk>_ltfgp!(;-MMpK z;BS5tlM`NF*m<_r>54k9nsk*EHd21DCbo&w$d)#JDe7!x3&SWUerZc( zA_XIYExSlOwW+aXR~{oe7Z0m?QXt#b38PNhz-O!}a+hSLf*CG@n19WOi3RGV5@2PI z3K|f|n_^}L*wlH$B$^i?{!>~4`%&IsH^h{ZGo?V|2#R@1op@xXT{Wq!X=JSWAyc+Q ze5S$Z@Se{0Nz7jxg*u5UGG>LiZsjJp?xi#c?!(;LiSv-3oi>NHdEEVbmHAn$`fOA2 z2?THBQ)L_FHXap@lizo|c~0ogY%iOfA$vM;26dRlQ=IsSgfysP%^SR$+8A-3QmVOO zWZOJnnfkL=<&ega29L4#bCdTQ@sN`mg6(BUm~a#IF6rr3Xvm1hOi2(37>G@nBaKLg zq=-h})Lke>q9DMk`ph8d)tAPAweVzbzXyBWCc9^){S_=bp_%OpRyKXPx0(LL3OlQl zDKqF9r=t%@qG<*cm@=XvGVDB;{Hqza_s~ONH*K5xMCUKiPqd2ct59+bHN(>Ib27>$ z!~Kj?NM|ikIxABO(fEi`M){~VxR)VVsRQ)bZxh~2meGqy)rq0z;VsvO8M>Ci&XM>@ zgfmF*y`38XJGHR3@{B3W)tYx_6q6ixRv~{*LH?E$G+i#wz{Kss>o$jbRz*wj9`N&# z;B_5G z#Bi=G`?X~DP0#Aob?LUUYfSwqR{g6I36Zx4FNSei z4hX0((cE@yMS=S;7pd174$gZ$YZmaUbkn`Y7z%UQDKq&y&rs;6U(Mj%Xa8Xd9RgQ` zbB(80Xks`&`4f6#&_MA9Ykmjs4F3}iKAhkT>K7LYE0Ac7ADPNs-7b3?pR@?5SWok| z29b26SWJSWaaMuzN^Hv~==0pByx3}1Sj;Xo{B(G2?($Ik?85f57?t8d@IeraYRrJd zWDbHxaM|CAamI>CoE}d+o%yPbO~)yyPDtx$J9Z^&(c3=cvsm?sULAL-4(E6@(iO~= z#H!1^$HoWrr>WpI_EW)@Y5KYyKgCR04Oc1UGqSxfY*FG{sRB%gY~(YO{q6AZYCV15mUd_58-Qq+wMkcc@q-9%0==rqnfTPaJzM< zBf@EoKC^xX_2@pzQ?L1#-1}5w8!AX{TWnPU-Wu777fL530*~C6#T{m0MMIIy$g>{j zqc_qcaX22zzo>i$|x(_@Cpy$y4Y?GlEUc51Xf97{( zH0&s~UeriXw4wbqKB|pMSAZM7b8s-1tLgs!L z&HY4kIaXq|XHiTTDih|iq094!=BL(j4UC=CQX9Wg)(WY|v0qX$8owI;$7mEpc7!lL zK?GyFY{=?7i)wNzdTJBr4XJG(JCr70#d^U!`3@C^yS4-bR^`3 ztZ5y>?&wqFwR*E@*oo~EhSbK7_sk_Pp;+(c*0ds#e;aG0`b~Nsbt==vavLw78gCsd zd{8PHA6<(4t7Nksb&96Oo2a>G`BaBr-3XOe)&e`y@rTTpK9YFo-80`(ym#%F2c@kfDAh;NZWR2akhCx+wks4-Jz((l=$_g3fqy-%)l!|6}eU9kxB}%R3M9( zHY9IvF<^?@8#FA7uhJ|fn~0%YI7VUAne9}<&PS$QcEQ@|?tD@0ZjErbjL9S+Tr(ve z89O(t-AibgiM2<+$|%?S)RI|`Xq_g?^f1WH!|D3I z80j$0Ovo@UifuC>P|oW}8g}oHTOY5)FpfpP;cFx>ph=@P2zq|iSU}LQ6B7Es_#qdQn}pvVVvG&Kcx4{6@ZxSLuI)%^8nRZXx7B>u@;eeWN=nqdLS zF#H8dQyZ;C$De|oi&E_D2(ylmG%r*!0+6WLY4oyt=7e6pgGPGhOJX`fdY+q@_;utV%jqED@FoqkwYUS`zjc#12hl4Pqw0_*aD* z#D2bzv0*FwRQHYtCf{%g-!gvDgTv?n{~2V#!?YkvTAANDGic9S!iiz9k|ud(rKNM2ZDM4>ST(Y3n*v)7Vc(tH%>pX?{~ zG%2&OrY@D%$ozTQwo47M?{Kk+R?7OIlzi7E07UUz@Y#3I!6CZ7y|5_<^EGQ z54#KhM)yiI^!4eV*}swz^AccZK;ch-qfJrjWNFskEhB0`&Z8SD!9bZVeC?SfUc_5+GH~?t4FbAMN8eG`gobfX%(TI z8EABXlz$&GVDZ4a$3(+g^b2L|M2dgz`#$)v=3kd<=p7V{#e%U|4Uk~T>?-AUM)6cg|+v5al19Mud|! zO8L3yL8##44~b#_Pp{0PY0MLjE+R>7r}B}8$QCW^kUnL>?d_0j9OmF)U#90%IPMH; zA^1j9_nF(p#Qw~Qx3cuao91;jzpJ_3ugKroj=OWHH|6$mIFVn8#u#1M@=@-bku4tu zG!ecsc`Cey7D#=-^kwRK0Bt&GAfSoBN7)O6OF*AHVyMJ%C<|GV=QG~)DFwR9xf+}bam;)SVs!$5quK+EYIF034&ibgcGU9BEvUW_T zw#9w}H?-zy1>9Z)@^Y;OXY+trz_7ECB{-CRI%-W`Ik|N$D=%Z$Xg1Ked1STptgseN z#h>jdxaKl1t`=UmDctRz%+6*fC-OTYRV(I9_q-3LN8ELOrU@MaSXp@}l{LoN^91i% zXMOKn-+9dSu>+-PP%&a_(G{BOd)3aH&Q8M2>?L>7CnU1pte%PQ)vVhzqqb^A<8^Xb z&&!$@Y-IzPr^2zp(PVBvFp{Iu*XbdIr+u56uVb0rObE+}UBr4^)>5R9Q8}q7LWDnvWW|lTJfz zjs_gfM;ROB86)DokeIA@z)9Y#4*(HzkPJFtW~P}Cj9xP{^Sz=HhTwhG728AxOvjw= z9d`C9oW=NRG_M|K zniy&{ae;BoW`<)+%k*Rxjn(_k`(LT7-MG)EF~=8>jxp}@#nULAAI*KobDdvCUV!5; z%(+j~t}}B0p90QeeS;8{)wW-P&*C}Dn7K4Ei$<2?qkoI9S@)Wljgve9p3m!`4@Lf#^EKH_%{?tQ(pe4M3fUcP)MJ zVd|BePVMQCa=;RV$1= zNc_*()0O6(?6q%lm9YdQ3!c5!DpbjyKFhP$a1OAi+3Zc3lvvap5$ajgn_$@i7B$NI zKeecTOLtfAGtf{~?OAro{|t-z%Yy)#2;BX67PU%1p!>*2qSixqK`ouJl^$69-+uJ^ znW4$x_Vpz5PV^GxGW0ru8;@Q;Nz?1RY%Qk9UfEAKnT1>L6b~dMVj!Pxke{89g#odR9XT*a&6u@qcJvA8e}l9Q*pW za6=#a`do3%{{#EF@r{f@_aEBVUlsQbu&=d-_lwxq=YO_+z1rBO)K0}^H@-8D!Z~foPQ{|xY6mg!*_E+WL^^vDJ{pBfQO@1!h zUzKqfi4Qf?$x}&QWs%O@jHw*%ew)}T)8eD=h*qtcb6&=Ma=+qd?m)gh%2Th~o2bun zSdRlFjEzaB5cGY?^H?i-l6!kkPw3~dnkn*{b(_gUUDMbi_inB)Q5PrdKx-cUy63Tu zz++uMB{7k>=CuVZq!Vw|#i~~gDS>$yf`=LRb<#9Nntk^b7dGSxmp0iL)O~eVKcUc~ zVpBi!!V4K!wqnJe1?|kw6|^w<`Z}C4;&jsmb8H7I8u5Me2Dq|c&Ip=5n!E==Qwpy7 z9F&a=RWh#ZPd{7G{`f#f(Eck|xEjQjZR;awiBZ8xR`ZRXn&v`N23(0-Ew3yM!>!pOe`CuH{ zWd%$Jdk*dSyuknIGZ(C+HXPazHTVv#CgEtvG$M!gava(fc&OU9O%Cl9IJ6Uc9ok)L zt=FNwN)Bxg#fMRx*|X90HLb%U&Z~@Ldb357z6VF*XP1Xf`bDdj0<~1H+#LiTtxLF3 zK_-gxqRefv{?EKn~U`>NQ!p1+6t8)3d16*Lao?qMrPLo*ESE8<&4)kYh zae+aM*&{UUpcYvjxAWnwSGJqy`c|^9meDe}tq(8@9mdhh| zxz|lkJBj$IpAReKhMvhrqhHcfsigp7reLzX>eI{|=9*rwy1UmM9i%0hC1wKKLy6za ztLPx(q7Im$?DeZ>;8*|9#;=|!2lX>2Cj0u;KKi^EW!dXle)VTeOm?yjXu2c)v1R%& z=)~lOrTEoG;Qr+8h;3x<_hykq@@MEj%|(vmm+-IWSTDw~!Fu`CtSqy}IM$Z2PzrBF z54AFhDV5pJKKYtdPwbtUnxAUW{8WReJ=gftQX}5{lmc!UOXZ*3c>Wm?M*62Ms*NAu zXP(DC4q6FKhcmBKqj@C;R@Oyz78!4wxUOHWs=lDOI2jT@Q{*VVGE?p&$q4G-F&3U0b^6Q-w5hi#7Pu8P8Z^TOor<`19D z{*3=rP@i1tYzkK^TY_tTZF)D<3pt_RAU=S&BUKa0u&3pigTJC=Fs)RPdM#Z1{lXMLc^&t-|^S!e?cIq4R)L_VO^`V1tT950$&HOgxH3h!AyvOj6T zpF|V+#jO7LWO6)bvd)+qCQYJVq0e4S?lKY`DMdB-lPhW9C-`cn&&=T5&zTvVHQ3A` zYd6fypw(I;HZu$IKAw^oJq)oOTWQvO=J3KS$lD>r^;wX2X!0RF>tPOL38ea%nVOsQ z0Om1lQFTQ@^J^%M{Jm-`JDXpO#D`>|rTK6(krHa{X?omRc!GF}sg8UIx(77NuPGN} zF>YyD6X8+OxX7KluXqaj`72tKQD^1>&|q+KQ|YYKFRewVYf=`DJ!L2P8ThtM>@h$| z*lt=u#l~c{aGwZVhw(KSJ9m3YIxMs^n<(@X1hy~P6VQpk;e%J12>kWlELBnh;@oAf zY_KPOjw*TBS0%;*>!(k?{~7vZAM;M}oe_?ul&4M=mys-ezj%}*Hc#+{SxY@UnY&t(k~(D z7y2mua`WfvmpkeG0R2(|PyDbanBj?mJ^T;!%$@tB^~^oJUC!1sb%W@cft~N8Z?uVJ ze|_`MEPX?hd(<~Oq+v4pCi(xVzNy%gz9~xU8=05=_03~aFWLHrUDLm)zWLS{(l-Oq zy+^(C!l=*HJ3swgy<<)fNd$&}`q@0z?d{@={#jwj)OR56uYU&VL?Uq4C!g5_Yt!%Q zua73YE`9XPpQ4X0{|tR(a;akPG|0XonOT3NAdP*qGTW-TL&gpa&uo=Hq%~m%4U*}C z<$$hW>>H3TpdE1~(KC~>2bkX%16#4nc-%_%*}~DsPOj{>T9u8gQ~@m(?zCEe&#l5O z&-t_U*K;3<@9QlVp6)LezC;Y?Jf|fA@`P9{{Cc?i9TxIjNc81T(W=dJF0-A{jJ+5R z?mcUe9eSyWHx1G01;Rj<$rRW_#<>}`*miOQ%`!7 zBs3$DDRO_24jvkMnSmGrsb4+jq;3z_$%6$uYfL7Z-3%gTCFibrDX!3xku z;$E6`r0Rl#roD)_DR=fG6BId6Zrj{QRjPSx#YRlk^xKzt8+Bfakoc=aIj#f~suz=gm&^h^HO5&OWTZQ3GjSugNfNmK6iKofTOMFehBKZTU1utIesQ6m<+ zo{f27@*h~a!)v;FHZTBeavr}d&PtX@fO!Xbd}i{{wZf+hj1Loe^Di=9l50#C4XX_n zqy5ouJx(M>d%=66r3oF)N@qb}GIb|c$&;blStbkO>U;grQRkIe5lNp z;Kg|F#dXs%p`#To>Cn+PUXq#^mOxExHfo}uz4AXPUUdHTKzRCN7dQBfvj#0G$S3K{Jq zb&a5q1F@%&k%LwkBxGa~!v+Z%DLk498TE}95fh5S?gi2KM8YbKXr`aP12%hoR(SLVjXfe`j!a_UUqwj{5zALRYNc88I_xn;Qu|oz2PnHN6Kk2_C z{-eXudsFHEpT&RnrkTOxKl^9$Dir_ui#kRK=oWO>|8WTD5VDywsTH3Q0(zXKI{ytJ zptKnIQJ_wArlLS6N_VECK!3f@M1g)jJxg(pq^oWrBX@_J*A7eQ?5}L?LO%0=%`Zb5 zTWpqUTCJYTtawT63extcv(t|4hAjwLb~`-sc7+*tIe_*KqYEjDBjU zZ#-+xF#~f$7*9PI#OWRk3~x#`_tv(glV{z{^BH>X?=wF9XZ1Z`_&ihJjRWhm=8r-t z^+kD0b;JdGR_j|r2N(j`tdYQ~G55p)IPalgHY;vV!(rrPEAQkT%R6N*ws}}bhc*Uf zf;bf6cuK94wIjK!yi_0=Jh9hy3d=?ArDppWLkwX=L^gz^;(B?lMeenv$+uKL{ub~I zq^6I?0i*=vIw7=Jz*7-3Ozu!(NvS7fmB3AeMUp=-RHHM=D?F`4H-Vr&c`>){MQ!lr zTF__sG1!|d-%@?JfN5%0-K?POY`V~3r|EP(2x(@akrhu`TI>*_n@f#)ga3Z+N z3AH!-%h#a=9_c0dVDPGf3;jQV@UKsQtoi2;&>yM*S*j~%?>(~E)>*A)2Rt@qT5y003qfp79I~y)wm%sX zMXcH#sY#+Fn4u?K$vh)7?xnqwi7{_I_Efs~bK(XnQEZ$|RDOkGX4bh!6121h=kpc%^+&>)D-|qiNSRA6D@c zPSY4dq2D$8vuw22y{(<2o$k~l zy$?z2ox$`6`?vIX@7Wgk9JB>HL$7k)H;+EjCkxn$I{H|UV1pgcUn*sJkhjPGNShM? z*q)osgx2Kb1mTGdW@->4Xc9E{7|s9NkKYcG3EO9XSofo3ZjSpQe{jYwIzJ16qv)MG z_5)tPl60J9SWmo9*)Y@hdSw6DzCcz#TNbc}8C5%d$eu}q7O>cw>sLRqq2s$YcO}cI)>*#ZwT})yif)MjF`f}Atq2kvD5>f zUtRpnVzwN%u4|S;tg4x1&DS7dEt)oc2K!W1v9;cJ)ABg}CA);J`}5IPt9xb9u)j7_ zLCPDlbRnhV)7WEX&1_;dnM$~>nZXntTj;QC$cQw%H0@+p*x3?u_Db%u*S#CzUG z7t|IpBiq@Qx|zZi+gXN_diM+TY1|QuJ=HLp(@obljnjq=Ix^@GPcvM<#M2BfC4UGD z5Zt@Ss6Y7!h+OXgIwrL!NdD#8rn49h4oe)L>uJKq8FqZc63ty5Dk@b%q>zXN@@wtH zJag0!*9>s!kyapAs)(P768b`~9yW*jyhzTSf22o$_;3*btW2j9@e5aQ{`iZWb27xv zT}SXS&qT^tCd6Utb7qEhUeb7wsUwNTU;!PL$Ui6%BE&W>-*i(uc2uj$M#wk6C#na%;w@%3D3Tw!byr$yBJy56pEGSS-9D-eww1W=+^7dkYts;!8x5Qt#p2?X zdexvm#jfYSU?K6kjM@$p1`%e$d%T}TFPk*D&sB?j(puUgU?3M>(4+Jzsby_>e@utUcgbe zR_sGzivYciyzevF`rVSo2~!iJzZ8kzYLh1tjqe?G_6e^z-k7zK_>FoPX7W1Xn9E4j zjdeU}I=?2iGp{jF)6>a9|EkrTPtvoL<$S4IY-em~Ewn1&zejL4r0{?tW^HL{EmRAN zqQ&BrS+e($Mi23t`)&t3Z#Nf+T}LIAstxkvofr{i^gFLDH^(S+Dus1THO6_#s!Q## zfs$XL$yJ9%=EAfs0J=7nPp1mPRUb9FCgcq=4g?uX8>>!Ej2#|LlpYa@|ItIpfzfy= z@wRhGzWOc^c7rBXnSc><8L7I}VB~wf82NoRMs6MiBi|(cv1g3v zQO0>EXCA|OCo(c#5C`c{kT`)&4nHBSrfSvIQzG&FHPLu`3va_!>o0S|Rkw(kb6yR{ zTW*01g$LiWyNbgu$Ft_qSn}|L`>7-&LmwJ@r^+HcXVDRrxQpDYuK<70mO0OJ%oYBa;i+NOg%p~HmT;ty18t{fzy zyfnEN?9D)xZ@4^NpQlC_{u-An5xD0!Std&vpt_%~z+}lbc;QQQ*(DGS{gh2PUo%|= z>t?B?JLzUi^{p=irIw)io|Vbc`;9W`2m=xSS|E;6NP2yT*vWjJ(Jx=qO@I9|h;pf8 z?W$y`3mMvF#gbI5fuyomsYDZ_D|(em*c|tX2%U-u?MbPe-77+$t5kHBVzw^PSb=&G z&!ZBU6jCT^uEJ22$^YdGO-M46Q73j81pqhLx!d#$4jAK28eb<Mn zFUr&xQj(~=AIKtGFtwb6rK=)-#c|Z| z-eKoJanK$cYyMffjfr2ZjpTX26?VGuM2Gs6C04Vnl6`i$S zD8xbDZ+lnBYWq~;RXucFP%`-@H@!AfJX~(a9gm8{JGJLUT~LD{TuQvFqDMm~L-Y!U z=(z=)lrDPjSfMzC)h6E_u^Q5WqV+b_d?At;@hy-;4)HIA^=Q1%jN5y8;^pWWqR9wl zE+bWrDAD{|1u}x-f6lwdKuzPS=$f>@2ijqK1==&PiI0L3fU#yyu%_Gfc3wjUym*?p z-oJ7fn~yAl=_w8yXxOI40`XDEowC8Wn}J*VOT(pGyyinT-|JIj>lL_X>UkpY=Wx~s z+V$HF@xr~*tL{r3S#L}A_KqcdCP?nFJVKn4^H67~iGBs6XtC8`lX)!O-gGev0nf-mxXtK{~;}Uobl>(!sBerZP*Y(;+6K~tm zg>4CoRZ<+2Si?1ko*0{vL3gGQhoakw!2P>nP_q1MZl7~Y8^z)n)EPR4eff1hfA0=CU*%q`}|KVJ1JnTkyweTv-<)(aax zfMnFnS*SBzu;3jwjX^C@aR(~`q-imVy6(kx^$@mc?8V?=|ah2z0`UNZ44J%3-e-| zwzd;-1anOo*{7wwD%{v&+>;!4_WK_82#0p&>-!+zmr)rQG~6#!qH5>t`y{wFeXC;_ zQ}@$t(dbpBGgC7}s!GO(*skE@{X5Y>d(}KrL<=l(nq0D^X2;seC97)Ni8y4Rk&9)A zZ2^3M@$` zoOB5^1Ah<>QX2eS{hLw{j%?RHXXrJRdqV^^|9VZg+gdcNjm5gTp`-$hH= zlsENZe|(Xzald_RO_4RfT+=c0-tmT^KbgJw?1cY|^lvgaWfSPuXrV-XT>BpssevvJ zmA<5RPx8lDki-$bm2E*jZOV@&F2VVnpB7Nmh$)9Fzv+c2UeRezUGL>7^1;cSUbLc1 zqPvwEquO^Y_E8Z#VDK%Q5e%tumW3Y&ojpC*@;Wya?n)gHt$NvNJ%|F>+!fokA*76c z9qiu0Z#v_OwL0J1kBy@lkK2dIuC0*dyDCw&+=`vfvuON#1>vrL;Vyq#Wi8lEw34F- zCTk2{D_4*$t+%D>SieJ{dt*4EeUJ%FQ11Z|XBWF%hD$a|km@3Z>rs2`zhFGiUmFxf z(365jJLWa$JM@m{fkvy|n|*KC*@pIl@P{4kHU2{yH=7@F&_U`OW|v7CwVn5M3P;I5 zRd-#u@Shw&Mq<7{yGIj-8cci4d1i7e8)n-eg$#lnk5C(%7*?!6T**%9V2j&R9`oLRk{J&f^ltk%_J3Phasi2DIDIK)`9 z7SjM2)?na??C%XmqgBsaZ5L4<0)o-E^P;MtN@!=Bj~cTmBx+6SZtJny-bOc(6vE;s zD?D$tSdcRL)`B?WQdr&c`nbmk>PDX~B7R)hpJ50;-wZ&N1ML)APfLS-GjbmJdZ;EXk)w%bC`hv$cY( z-lan{P1Uv?TO~=Pv`@1Yx5P!?qfIb-r>}AJd zfI}k`oc<=9&iW?ea?HWN|FPXethRhAG@3N_+L8S3H@Q$Mv^Fs{w2a7D9WUCAK~=WHRa(Anwlq!lg&7*eF~Nk#0W8Vvw& zw>B#(GovC}F=#sv`TKJ|=Iwy!Oe|F}<~Gx=mZWsKRP8T?q0SJcoHkv_V_OJ zL#y{eI;fVI$N=5yaVgK#x(tZL{PImL4To&UZzRS^aIyUnbg~P;kFu8;XkxED4R)-W z!l!E6_v(o4&TBju6oH{e;`t}$vQ2cvVH_V1Kci;dCvOx?z9yTuOx(2;+BQQB#wIM# z47%KhlERSJcpAvmy%cU@c@P6(>ec}$c3aFh8o6*V!D&!(S=_&td+K%QJ)sEkLDi-*0{uBmn7q+E z%&rIXtmay#%a zaq>HduzudiAcozGN-luB?JDW8!|q#_J@2`#x=S3NAE{bn#opnjroFNw-1SbrUG+lK zx!R+wk)6%pC02ny#eVGJ!exl(BuKeA9D5y|@U&`(CQd4dR&~#gg%$mFcHy#;n#*qB z=?0VkAaVwLJE@3_BkD>$uJBBh7Ep1W)Q!EkM8A18G2HY>BE~!7_yoWN57QQnzF``N>hn-J3rHBI$G`UNO z_fko6R%yr z4v1}Gzx5&%(NJes&BI6XQO&y7YD&6lc63iJ>C&OXwS}wO59(h7Tm=vqe4Q0NbbntU z7*He;IOeh}pP_`h-QQKT3t@VC2y>Pxe|*ep6@e_$8v@iL;!>-XS#09USdO>A+6?nL zi}M3b%av0yJuO$M4bNLb0(abHtkGomDy+q#cwJb&QHU1|KeSZAKG1z^URHqQ)) z`4sMYJD{!9#-mJORktE8_DzRKJ@vH&^@VzSRAV7cWdMW9vMnh;5U#L+%VbJ*FKqdpSjOe_OI)*UL2~*9^yrZ`k9i;mhobIHnMMK>CRywPa^L9}rWG!e_Nz6=+S6S6K zTTE8DJb%dTDpZ%LjxyAf=08>Lo^QT0vw{R1Obskj8s75J?alj8vO)076hnoKvkgvn zpOb}#169YL{{nv4s{W{0e$FF22)So-#s1f4gP5)2x~$Evz4$_JN}5D>A> zoiY_>PiDnbZu7`c`;izx?`mo@wM7yddlOUVSs5z4lHhl_SVx<%URLTMM}Wy<;sbn( z)B_A0xgDCCjcvL%l9-lD?Dn-`)^%sn>F|y&99xv)ooW{QWlRMr7f2Q7_F`PIEZaNR zSzv_Z*#K%#83KvX_;yR}9WU7&9bo6al(ItY6@uFbR4JdAy<>(?JAPOx2xI^3KHuMx z`94qI2W{trKK)W{pHLg&XpX{WB&EWQsXuE92$XG+U+EZ#x~Dmtu1^!7?iD2z4E@ub8 z{M;x}DHB`-U8|ByA+NC#yHjsx5IYq^)}Qzo79|8@GX9Z*;};a`j?;-$bxLlgL}C%5UTRFJh`edwZE zU1bk^LakAFFSa|saYO3PXxsKVHrsZZ8mTzCen_}Y!)2e(J79$TIB_!5r%~m_D*}pdXF(*C;Px&mx`2ZF+|^DBS_)I*qrG21)PURyH~@^bZNKbk+m|H-+kC7ELn_GW zUBTJ&bhKnyzxr5FSio><$iynbRmpSZcJITH3^2?e&g$nbe$olQt@a8QU2iF1};k|E6cORLkRr08E1#u0h2(W zoHs@{)|>`bE(=mj!IjfDQ;o(}-IftPW_(gQ6`?EJ8J(5w&5-C>aAIutVEJEs#;C27 zKZeS3G=Jq%_ZO!z{7Int=WqYQgSTApdMT0`?2CAsHn@ucY`?F_Boa6nkj5Jc>I&$v zZ{9v7pOj;SlkvTX8O_9)nL%l;TxApSrHvOe%--v#|yX?k$ZTm__yl#-%9` z%%)mKeZdi9C5^lJRA7z@=Inoc@I40}c_%2?fs8+9BGbd=>tFUjHgy|(6bWQ_8IZpP z$ZDyWmV!&&xwMq}gV#!*`mOo?{0u$41PE!vSPQ{cPTvxmP3OF<2fDw6BL&VRk?qV% ztLpJsl0etz`M_rT-V_q2O>Xner6tJ`_f3X zE@MO{i>C{dQI%aCl?i#;N*Hk5VFw9e8=78|wO2$$69kRB;U_}S2sX^a7{&N3aQ_$4 zX2Wp2-8GI+R4eg=m1U{B3>SnTREEGePXo;F7*^^>-z@{+iwExcF|EPOW$~YO4$aA_ zTGCXNsNc;ZfQf3~J%D=r<{;P8yNBe&19Q@!ESRTHdYkUOl3WA&Xm<(|IM8XixWN+%MtWqX-`y{Uv;zH}!P|9^4=TDPY>;A~D-WZeJWS0NxcXAAV zUIzwpfV^M-|BYgVJ|Xcpvvc|*MWfT^)}(Cf35NNd$6GNS4QeMwp8TMhXv&3ejnabs z{H8!-jyvl~b-h;ZIj~*Fej6>-_bvcxt8F?J#7Ca&1alzk*yQ1=&n*77TK|sfO4RJG zIv%LbT>2oX^h8>#~;Wk%F$Nfb&EBUq*XV_G$u7wId1n!9IMVOw_0_I zx+V%*e{CcbEa9qmO)9q*)ijtiYU@5sc4MEDfgO18AHf_IC~B#`Yd) z3NwpTZ*FBx)E3?0-mYa|n*Ud=D+7SrkYxGJ4JtRT@4%wjw(Mf7I zol5<|t-deMzy7H^>Tdr!$#O<^?8!#jj@zABJEd@QFmZ8zmynCL9V;= zL2T+y(`52N21nc`9df{-fqcBtLw6z54X#8MdI4>ORne{zHYr8Sv_8 zlVPI`?$!tj;XTZl?7@}me)?eo)I&ee!%Kt${Qow_ZEt=J!2>tl?N&L9>ATt>Pmc0>P zh!jKRxOY83MD9(r<5=*@%B9`P%rH2plnBi-2zD#Tc~$G^sa`=3d4k@|R73h*k?ku1 z|6TH5X1=LdSmeynFMH)^+@zE~&YG!|fglb9=d_R8-0cbUk*O!> zU2>d}slbLyvJ`Hq@cXs@lEN)L3H;s%T|OJXKl1RKWnaVt<6DFDCBpbKtv*qoE0v=S zywAdzE1pXBZ<}9eG2d$OVkueMCS&%VSeNNSS z5>SyAws>GMADIUEaz^a(h8$L7=nGT+S73dx>gH|QC~)_$%?SI? z6SH2JY@8c-(cwB_NYmt#rXRo0_UKV5e)sHm$z4c$zd7sHyv>Nn)`1!kwI?tmV)dUi zB96#ykCYyQCHIrZxm}b$X$GDBD)-mS69#-FwX^aOOpeNRZ)QGM7%nzLjNJIl>bkX@ z%rT?oV|mlssO=Cob{T1}d(SR;(OOie-OfDZ#?%t&Ra+qRzEoIMFt~sCQNFK@uIH-5 z-F_k@xl|IP1QWw> z)noqm65Tcx-ObcdfRK1|ii?^OSGy(VcieeT19^ z+{<|WFJt>)QM-@L@c0l32;8Eo;v=W&M@Pg27MQC*h@Y0~2ks7He4T}>dH|BSDJH?4 zFeH)){E`FT2ud|CXAPcnN)QfsTaKEgj^4rJH2?eQFHH~L23NQ~_a z%)T$FX&B^hUjxBe1-3J8FLOC=v;jd+#uS<-V}|e(#}ev_t|>T} zBU;#hit4Wgnz8(zjS`x`@0`j=B7YS-V1m!PJ$$zDmFDa#$;@6=tgDc&%3{?ERG|6W z;zbyxc2&8q;P~2ASoa=}uL>>?*uM|v;I0QM?hJYqx!+Jkgo|;)q0Wj|4esUNkt@B! zRN`L34JWgjdffB4NiEcMrF$yZ$vJSu!`}rk_aQRj9uDa0k6h8p->S1X$(SU$H;a=# zKA!IuV#j#s?!!-WW+NL=RzhTa??j*#plt{C`O0x}FJix=t4$}iR9|T>j$0nMR2Rzw z7wZQWxPF+J0nR~LtHT;d+!f#UmR5V(mSFE17)g+A>ddps@_a-M2 z)rV4(dkPc8srv*~1GT+OwT4b-LnnQKQiWHggc_1-hG46Z%Imzc;7k&Cd1)9~>&HJZ zsTQ4@!<|N{p4G(bkdv)kV;dfZH2g}&p;k0(V^*M(+;%vcDG2L2mS;;Kww0Sx?Tx#} zJMcuiCMMv$CF(bAzna+QgW2?MwAH2zX;waMtK>Z9SapP+qjxkn6LDa=xvWw-XB$Fy zr1#<*=0$x$ICgo6a=!&9%LAX@CPAX*Vxy~g=BZ~|FRJBFvHpy8OKS2dyoSOCg$$bH z6C&Q%0mah1G<_sV*n6@lxO(^%kb7(MK0k0!7_BWJAobkh{cxMt^-;p~ToWUT2Wm}n(a z*sLQdPYy>oG&u!om!K2fdeiDoJ(?xe$^6@7^JrCSaoAbL8MW?F+>@=6TxK95Yi5o6 zW$&xx%{+n>`&w=5>5~Wux|iJ^r1OAVko%n7tz?qV#cmw27uEVFwpJ8S%Wb?;Mh)0{5Y_?(UzOQFdGQ z+_1^wc!L*AVt-eKzBfZA(z@dy=qm#pwqE^2bn`YZzxUQ*Fv+}kHu16T{K?C|OL)Jr z>U~9Pt8HH?mUyd|5vxGQNqnRwEV0)PZrKGfo>LqvHn$wt;$B^*lmGZ;tEo7@G#zer zZ|+PZo|@WzuGi^eiIG?QHb~s0tLakk{Fj%<=A?$R1ctPDswBk1Qr06)^{gGNnRVGv z{?5JZXuE1&3$?H%W!1cPU6gXsk$!TEF81chZMt}Xi@Uj)bGIG$J3DXLCLSyucz=@* z`#QU7iPaj&6QJo8z_ZJ>PPX;>01so=u;WqNJac(m5qoCpie!_WRBK9Ii$1azUbA29 zt%E}?J^NT~N#T<$NMu4A93)TlBE%MXODD9@fI?qs@`tvN23~Yti&0u-Tb8W`D60%4>6%+PTZE zMXST?k+mR7t&#Cv;RKazC5LS1x5MO2giAW7B=U!v?DKIf(0qwWJQSflhH1DjVP5ov zcdTbce>jgx`_)&mMxE72ZVuB4hQ_VlQF)`h^BydIR|-P*`yC;H^j_NupPRV9-@I=1 z@WuUN-6NSZnfzc4+NPcQsM9=bEp5>+_ohzxMs(Kw8vRn~-R2&tYdMD2`q6l?G-2{> z6av%iC!*Ikq1Sir%ev&2ooM$H#b>c=LvZm!(j#e(SAHw9k8INc;xt57dKWo{8DiNNoNdzA2Qdns|7dF`jnIn;M- z)j%Ys0ZtZ6ZS})&t<&kAfN^JRjB_`5jzy8MhsP-|1Z6r`HMAR~V2D&^3YqsA%V*4w zPL~2?7?MFz^ktQ2$eF80MrSj6D1Mq4(>%&6Sf+yI%9b&sxEc+);r%@r>eRe#J46OV zO7{V_s%7Lm=6oO42iAM#fUs5&8sF9IK$`{Y^_fEEeJ`v_|JN6U^{JwPu*x#i7~}q? zcyL$)z-kaW!f*dG5&G6kX{-Yz$n%}z#F&G=D3Dlj2J?d<6z)kKpx1I2z;~Tlo_2u` zdA$(VV8c4T#!#Fbx+w7P{&=Ejk)nY@rqSHv<iKv*!RFPoPbE+rWF0CktZn{^9cLMl)}$7Vuj5PIFeFLNvMP;0$ap<0t6Ig8 z>EjhbB49A}h+@BnO+&ydssXn_XOX+t8EIRAq9N?7;EI~E9F-%JPtkUF{B4HnOMjGw zK11BPdzk2odv6~*EbFZ?nf^*@WrzExqd@LmXjI>O?}uLk?`YF(pK?Xu;U8kY^L(3C z6!^!uz4;v#c;nGv4tC(XO-xz0bzXG=%66M=eXWx+BVRLRrg!Oj%t3qS%&@+>a!v)W z59`FMTFsa4=~U;wFIt*GLACR$MZRdp+1zHG)8&0c+UU1a%VasnHs#vgNxQJiZ;v+W zJ5xV)Uzk9z7^DWw-{0x=r>r;Lf`m=~(4sk?`!PU>w{b#-1guE(DJCA2*F18@yviTV zXdc=!cgT#UlTC3W-yfHx<>P{tm~F)CFhOcpGWckLc5%rXMz}9gl9BBa*g%m22wZ-l z0O|7tXlXND#@$COP2&y4q)MA&Q;jbX<*`kmcT(dD$_nn(<$!lM*!R<*}#GMKJZ!dZwH;gXp4VBc7i`} zp0HA9jmoh`g^KteB&PPp;vg4AC4KJGuBFwx~-xO+pOu`lsUvJf6nu|euMJJ(`IYFi_mbj zehw+n1U%3unosh-Ms`-kN3Q&-+FeV#)H9v-M%f&ocgW9!IXTztV_z`xZr*!s0vGS- zNA*YJAo`f&_#sA(I80dII@B69e-^P#Wy@8qyNc;naCj5V$Ev$;qONNVl0&e%jY|P) z05lY$M$suga_u6uVgzE$v+@(MVbGl8hTpE|=SWq~VoYl)E#^C$k4IsMxV67BN^bnP zEHyS7PH->&eJAXNX_uqGcj)Gt?cl28@ig;ha6vQDF3{*U?@)vJ3+GKVcfVc9u6l@!Zv;S>3Cq( z4d69C^3;XFoVLzKZkx}Jco8Pv$J{DEGd}Kko@)uf^$M-}YIG?LjGRIPu;t2F=Y@J~ zl=*a2T(>oUK1CV*uA1SOU!wAx_w&k&bxDJl)%tZNQ9gEY)Sl2E+lsuRrDtuOCW32Q zQ`2g@Q{cnptF0n&=1Mv~CBy~wj+z7$;rMpHZIpfC8ox;ZLenqs8*8Gms-e~mUS_*K z@b;-C4L7!h#Oxh*_q*f<`rj_sw=5e@j_D`t1Lb{_+|<~zmfm<`OLal6iM9Vxui}AI z|0^i;=KqZ!(>d$<*}O@EDKq5yYV*K!5y_fPx1TbDU>>EYV(~+KOC;cWWtaG<08J7? zbQym!!maBcHZMJGz_ZhEIBz&P4-&!qv-nH0x9Yazs9_c%81LfiBu-HAPi6`I@o7bV z<*V!q#ypy!QBp8`6|shIjRx8>Mr1?-LDFIS>Y8EKDjJsuko;aKfX>;%)lprPw2D6B z!xw6;qD~$!a?c7P!Myc;+%Hg|FyQQLOr&jvzh#$sLH$wpu--1EbiI zNjF4K9wH82bn4Y-}T!8&I$0*xdFDw zP1jzt9oV=WKFJJ#;~c&dwgWuU0Y>-lr}{;5NKmg@#=@lf0y9f_jdrw;+7886s9B?3 z)db*Iw;1h%w*!360Y-1wRe1^YSqHi}toe+;^QF3BTilAd))n)-FGAdv+2UW8%X*x{ zcbUW2xH$yaTYz;rK+gfzIl$+?3IX;K;Ql$lItREvfd2VNi$9vxD^|=Rz67ooEQo2? z08OZw<=z^fpxQjI*QPF+tA8((K=+cY|4qB>63IMl@h2;ZAI4bqyd-x--7p>atZxm>KTV@(x zp(a}OpqlV@#qjSLLU)nxT&3ICJ7>}*b+^f+*_j8uoO8gg8DgFOq$EaO?3!J8Aay^R zH=%ckHGd6ny%c-&=^%xhWIK_Kn09J#jqRcIReDGGz1D z*Y${Sh#x+yoh6>daG+m?XseL9&T0_0=kByE|H~Z?{-;lolltINI4|#fr;Wc2{|7sJ zlNK>iRxLk?%1v|PsJP~jDV@kEYo>-4HerzQ@@acH_ZFFFge(kn!7eSB6u{1%uh$m- z(t^L7H-)3OQg*timP>g~6|Um3qOgtMSmIpXSV!H=K>8R1x4H4lRP+1mc?HY#J316` zG^X6^Sfy&6m(K^A)N5Yb@KbL^(_GQTADeNBL@8p%!E{lJ=o2FV^Gf57_nyjQ&iOCr z(zQ1BQ?YqJtYj)lD zd@&X{&al6ZEu`8$Ih)_fnlmP6ZtA?#9=_j$lAd8uc)R8!#DY(zX%PS6eu&Xhv-h@< zpWleViH~9CM2(dAY4yjRApS&W&4V{7xsFz82_o@kF{XuznV1u3;_0Gg;OZH)!zzZa zO{+nMu%&KkRZR{dkfv4qlxq2;P}+TLbTmkFMn>1*S*)t_)Hc{}@IJ~hp2ev|_N>Wz3wL_$u1S@>U%QL7DcYxopFM|ZaB-Y*#r{zpJ%Z$<`R8gXGLqa%O zZnTF&A#B)F^x&wukthF8KNYVF;|84}d#f-Os@%#287g!E792Lpb& z7SpwCoKYB{8wF_gfuO9*!YxXf?Jq>h!eU+0(O$aDDatl+{|Y)?YQR4`*t4oAb1HJ+ zA4HS3)}LX@75zH!_Im-Gxy%iupQHHCW!|TKU|g{G<&RQRc22;i#6Cj*7m1jls_wo-7J-$QSW3O{yH_HbBtEEy3EYtD;EN<9-?!Xpp31PEL z`vL}EYydC2t?#u)-A!MH0Q)Fg4gOUKH?Z9keExpd@KfYU-EN-XfB+k_AK4(SHFPko zzYpe5SL@&2-va*b_D8lhq?QUF{ZcHRJ0GxCJcf7ksMw5ye;$-MU6?Wmx)_Vi*gX`R z@q1_6{@eg4U*29sw?==#Ba3-CBdSSe&8T+u92G04CP6zQ2fAQDxbyda7N;b~B3|3k zf05>D6CY2I{v9X%J1#`MSJv7wQwxQ0)zFJ~ec{C3<}tLs)OGr*wTsst%cGZAWIa-> z<#3)_(`R-he-i*S_HA1D5KJIA-&;{t^oDk)i5$*fYK$OLDhW?R; z!bIf@Gq{O0pGIG-!|h@%`v-T8FN=*GvWyTN`UU29-HG!>eg*sZG*!;Z;YbEJ(9}cQ zv@!sPsENZQEV>@C8>6p-B^7;Y77A1AF+WBPFQiytmfWWcXP%>VPJOn?WnDtK+i5#FT zUtZ`$!vFceo{;nSbe2{`XF(c%W)WEUFmEbWPTwI}I8nt;MF;;e4qee(^|T^7gNy#e zR$6QHn@s~F{?1i_sX`wGEaPnzkvob~^XJl24(M_^qlF=bTZn@LP*shtaW;!tc_t8~^G51atzQfgK z&R>R7`#87ouhfrBxJSEQ-OQ`j716(cHZUTkxFY&aaOXd)E(%3uVuR@&E8I7Ye zny^e_H|eKARgKt-5UFQk3ktK;O@=`14sCXHV|(TY+%9KU&mTz8lV#FrV|hXkzTP?9+NkvDWCI=f~&I7{(ogX=D>F-7Muw`6gH!RD{)+bb4V`ZXp?||rynMrz^ z8hEi_nY-iIGAxhvUPZL|Op)Bif}`Z7%!z_ZE@uGw87O)*?v@&M|0lHQmxg?f!FR_p z&imXS5ZeJTGmyJhr&0f_=FCYWUg%Qd!4CAs=SvEz{3n{N4=f1#F0AW)kHxL3ohnJV zznkm%KK>xoRhmoU3BZ6VO|}`_r*7u+k+7@D`rcnVxC0GpB~bo49Jl_HF8kOHp)TEe z)b}Ta8!0^IHA8kIL!UXckN;!*98Cb(kDcJsW&>ND1Hgj zStnIna)>OvDlZ*OxcmE(0H?qqk%sCn9&5ki6*H}qHaZRx9gV1)naW&$nfqi`rWfg% z;ET~mP-6-^w20W1Yz=XmV1;R%m9h z6<~ZLg>B>^MdG1Z>y}A-mGQ=uqup$$9O=ToUpap86O`i%M)^WfPOkrYJr?n=(d@BS zQ;FPHGT%$?N61kZ6)2<*)Spu$T297`&)wxCF8%=6nmK{HK!m$^n{F;yDGF>$&Nz*Z zkUgPM$lili(e7%Td||3M*}4!BgxJDW_Lzz;x!vcrxhOdjk^Jyhsml3D!rshHmqhu!r633vn6{vO(-x8IoW~6gZ zGK6gpt(SC~fOH8o;as<E~_d8gN4#LOMh2LZ()NXG>c}3_D=LO+u!Ar3EqxzYV^1E|_<}pmqpmjv$ zjuq<6N#f@%6cxsBq^Q8(1xlJKH`ZEn+W|kT%}R*ua0}V#(ztlBw!q%!S_wRoMHFk< z+tNipHH#?vtJ~sWi8i^Xi+DoZDH%we#6S5NB6L|j&Bvc|L{4SkulJ+ukm;o$(pJ!? z`afZoBr^`$sf8hJ-oU%`COPazT`p>ith)7RZP%18yuvbD>R|+>qi@^_0h|*wr;JsY zm)t072L4gF7dW=5iM@Lv5(K0=ak4E*B>c5LF2lUU^ zCHBB-Rbv%spF?$c`2!z!muGZI4g2~7!4CUSm)HX=_mw%o!8k-T<`29~Z<7Nj>yjF_ z?p-ddBOE_$%@oqc9{AkLAGVyAh=V3aa)b33HEE>5`k(P5VCQE4;q2U|$~cH34GbFQ z=}S5~((t2K))!(-MJKzrhvnYx@}YH&d*z<5k5Lzuz3k<=X9aTfNnecJdwA*Ja9u=5 z`{cf?;|tH#x#wj(Co1RBU~xC@hh0xqM;Cn4m+RQ*cZ|NFIS7>GxWd(lp8hm;?>o;z zc>TUtsVPMN{6360Ao``ake=tFB-LW7<~N@d{`prLt9D-W7E`k(3Ym(es zM%Exl3Qs!v$#%&~`CtucAxPv^X|wKROv2#b2*VpeTd+d>!$fW>TKgW{r2>4C>Mu|> zo4Cd3JVIY7puX~WNbneZEe#&G@D*REl+}N!p&>+wQz8EB{=%m*2P|Yh(4ru3H%s0H zS!wo}{u<6>==&#p{vSE-U#_D3JGS*!X-8e*K$?t3FOOm>|9XW6U3I#OXkSt{K5s>Z zNY0gG&~>1O9netcCzMG#TK{~g(x@iZ`@m-ZeIr3bC(2Tv`6nHnKgOk)`erDF*_zXo z;t_p?@#BPqzku-*cvQofCJ}(bDhZolsH;gdCOry<$4m5>A3Z;KJITErA3Wv|Oj3#_ zzR^+NO+H>ah%`>3O}B4D)W7KYm-yAg3@2>+F$cFY;3T zYwR)D6EHRKSbGe1=N>=o-M5t1g+Tkq1T?=EqM05t;{TM)J9R`Z5~UTVF(n)jCe`%B zkpZ+3kb^$oL4W#e2)9A^3ZQQhxjE>=9rUKKa)^qOjmU~9X$?c~;GkDxGkQ6>vGLGf z0_eGd=8OM#2YL2(R3w1(pJbY5ObgZRG9dfI5+%Mv-w z!>0;|+dWFQ)8V%CDovEG;gr(E5}S2w^i3&uMGtyEQg2W9svZ!3VGmk%I=UFcqO-FpV>H2OKx}VSd|)fFZUH+#G0>Bd8y_y>w468 z(H)EvX_TkmTN-8r9a@!mQLj>r^VkQmPWs<}XGcuI7k=24XPM@lEbr8HntauKa?6eo zjf3-vU%AaBdZ_*B#q-;~*w<0mqoXa=e@9WcIyR>g;9zU1RP_7}a9DncyTFi&zR6=n z^c8+%iK}^Ihy%aGl^W49j!e#UT&;#(sUrC4!V*#si7mT%4x=Z)}4PXY7S+5tgr3tj9N$iD_^FF+!`Pb7JY#&wu-jiJ3yKI;D?%}*oRNkj6?<$9NLN7O%G3#e9Vf`6-Q;5?K2z~g0 zKAg;lR^QtJcK!(WT<+U%-yb_hM3*!;0^jg6=brBu99zjk;uYXM% zLoG}~tyz^+VQ)TF6h`=s&Dvn;k9NqWsjVg|&mj#h;%+^qq7zSw@JF5@asXRSg3z-q><2TZR+_|>wj)E`LKbLQ`J6XN7>jlzMgmH&NLSVOXU zQ&NT&C-mSH=O>(x-rn>l>Z zG?&VW-EFRG{%hFOFtIxpFl_>}`&^3k3RUS(>dY>ci-jHSY?=2iJK&JlSE_6-vO@FmDj6l~1sAf4-=NK@t2<5fW|=b;kl!qW*meNJU~xCodr zyj~u?P%!??LKQLk=T{^p(S5Iu>*;p)6m?HK|D2b}Xh%{Z2%9+PGU7JMaEiu%b36e$ zpZWJ->SdUVJF~+r6DmHEdtIw{4Ot2ig6Vm|LIVHz)H4%tPGM4QMQn zei9?w10&X&mrHumKZHmlP+ z0x-|8N#B8O=9&fY1dadCzSOpSdpFe@X;*~Law``<&N)pA@5gy4yj@J;br~T?|D-rJ`vvKR zZhKI&C&W+UlE_>1DIL9{!fk@&PyXgRrsHdminEhbk7V>XZdODq`PJVVU!jiao=te@ z#_%px-5!@3JW5DbM6VCPP;4hv#;KwH!|f71NS9>)TkJEDN?fI{@YLVmh)h&n$@+o%qqHY z1;tAhF5*J(!vy7k)yoqLM6I_XA-9Cx+G)9LjEWB>m;Mk$glF%_poT^`e04_)zh*KR zzu3L}Z0Y`SgJZ$%X4vS_Y60L2d9s6z{CugNU(!uQBRvNjeU54Ly#7rG;G84@A(*Zg zbSdctuOijJo2he@Y3lGb!KP7@AIR>D82(~4wZI=0@v?lr$>=|LqpC%Q*t4~Bf2ZXb zT&@0tufxhEXyDKoC(O^Hsg<-Hdd34enc%>ZMCFSxBGTC36(t#sEERG-CbWBbx^h#y zo++mPfhN-5^Pl=3^zmOp*tZ)G9_#9hE=xgx)K>v*=N{paF}|n1rlXsl=UMgl(q{27 z>hnwpFEPsOOT^*>j|l(6jI`bgMiB?HZ?iW@5#!*qMaj#F%3bw6*77LdVAP#p&>zTe z$RR&fl^J?IpUjx)Jzl$Tv3JA|+1ro3d!9QtZk^7GV@riV`CN{cT}oD;?@6U4S7%>j zoMTXXv&6DpP=SN!Dukl&Xyupc*G~AZwiZdYlkzc3xiZUXS#?Jvvrr{!ab*XMD>j{`aa$Dh$Os5mAGgCN(sJF(6W}M1&$yl-$O( z7f5+_2X-aVM)rx0-ji#(c2ufi{mbSLwb>ZwmtJ49=Iz=cFL@O&PMOBRr)5=hhacvp zkMCeFbS4@rR!%u*dG+2M2ea|`ci9J-9M>UDuU_@A;E(1EsIs{|S#PfnYse;zJJ=DQ zEf3ghoK5Y`Is$RlbG;iUhbqJKZB0FsFRx&~n69iB$On1)PS z>p!og38*eI5xF@;&b9iVZ$-$i?5-}JcU{-s6518feYxmQ`sWF?VVsz|s10v-2>BsW zx?bv$xq?36ktSWzzw78=bl#q2>yUvjBkWhP`}@G>xXC^X##uRxk68}e9&4V%c#Fem z?!aysug+ndX&6({pBx(R)~{d2GhKYUm#&JZB2fhowEMkKqV*(zfSR#kf-KE4`_S41ei8tvP?HuY1n_3e4!XW!&c)5){|4ZEJ<{wK%e^1I( z;T`<4f5@zHf=EZ7t`{-r#3f&tnz9uQ712k5n*IZH=*w-Qx$qTTNM`F8P&-ST7F$Qx zxLUicMW^Smoc@(lHqQGcNhobi%@Pw4VB+JiHnt+i@z{b}g<8vAuy`!(#pi&O%@V7$P&8|5VDF2s^mMP(Q9&;z$SR>=+ zny+bM8QN!OpSg{EumDf;fi}@m!KnC2)b;$8gpi)ejQz0R>2COL=@~tAy7;i0d8|(N zJakmL%DuS8Ui9HbjeF6e1pN+8pV|W#x*8*%-pK_O>tnMXWz1f&EH>u>URG?0CH}+} zf%Gsae+2Q`ei-&CV<} zLpZ|CT(+983_`zzq?oWPKE(aW5a7Z5Dvy&P1L~x<>ZDl9=)~9^;ngdDEk#A-Cnx{1 zt>v?sNi?pC6|p(@k!v-_btLXIIt#0FbSLfE(XB`;vMhIWZxr1&cRbadBmM|U~>?txmx{A=sNjpRm1CdBS1sFEWVqU=r< z9$7UQf5l$1UkL~CrTZk=YaN?MlUV7(*(S^CeR2V}5?9%eaj1^?3kEqF7?es2H~uB_ z3c5y-D9tPRKC+_i(q7flCb!#Ddu-0%xzUk;FLOnte*L(qkDItu<0X{_G1Dp4b7^a8 zu2{o?kd0@u5a=H6ZJ|daKB1~+TZRYLGkRIE*l-#_+Ms! zXH9-gHzN^u$o*fcl=TQqPC;x#@9wVuU_dWZ0sX*Fv{m-BSaK~r4pKJPo|WN>=rr#2 z2iQe9Fz-{q*uOyA7C+9npf)jUlm^nf?#k?4c9`B`PpDG{qMw^>^=I7GLx}~$xp0wI zv$SLjre@Apo=7H}#YZ=(lM;QOWksI>)JmmDra>G>;n?tVMGo-pPXyRy4HZ6NU*;NC z5RfeTXI^DjbwT+$C;p8~MJs+t=r)B8`2hNl<{h>I z6^Rpv45wL*`sa=(IgiGrDrqYy!4^bLO4-kVPMR$Yo{OcctrI_dy_Y(|wk!J~&sA4X zAJ1N8c~!Aruc&J7Xk6D+Ii@ZS_igKFFY#m(EQ>TeE*(`a1xxJn@s@9$sPG?VlP%?4 zugMu8$t~5(RP{Wbnl9^|*Z3)$=Tk%V6WH=Vd(^PGKc7S)0<+qk=NEf`u|^+82F~1_ zq^|}3`vX)k!KKGgI4T$kEhtdxbpPUmH34dRoUngW;#~rKz+R3ekVW#$1Y}oKI-1`I zD%@CQT+-;IJo7TOl$u`87HiGEvkvr<$Q3vS0o%TFgdi7=Y=?0yhosxg-C zM{>n4{Xkz>5cc(}7RO`@tyeD*4A#N3r^RW4Ur!&cvzXIsAtOM_eg$KrS-uMCYF6D@ zo;qXN-6g;9How7ubS@y8@Hx^g(uy^o367@9`u+CSx)7}az@rtZ^ z+_^&iK`=(Dl2jvHCfZEa4f|O0bjG>4a|NH+is$U)Q{oWWa;sjj)RT+;^sVu7x*~Jk zTveW1nG$bBx7;`^=pV)_xKj8#UHLn{9 zS5C_o`x%QQw6X)dNI;p#pf9&yts|}VztDCUShB0Vyr9b7$czGoWZ|Qi`$jVVgZQfP zI9y$KejgZb9`is+hUFW7>ORi?L|t_DFEr~q9V@g*rA}1-d30QL^c7??Ii0JcRP?@+ zv>yo0qZKndU2I(%oR(YO>K{_5I_g=n$k?6k{}e+$W`TQmJewML7xxvfv%kLD3F_E- z9@8S8t#ptj?sQeJW{I~((-x1K*Hr|Yi%zZv5`t&8yGbXf=V-CgbE7fUl@=WrjN{1y zh{Zxr&Sase*Si&}23Tp(V%pSV7L9Q&rcIiz&daxQ%Jq}9yM>_`Qyw2UEQa7jPSYn zy$kTD-Nf*98ntA^WG?287jEv@&oI%R*$HWbg#%z0{?8xT$myo=99e&``+J`g8efe; zeb8dRd@`iC3k9|1Y=d$WxCa2`AHh_OKN#OX@K?PZg151hH=M43p(<^y#J|GjePDQ2 zM}_n6bXenF66ODjQ~8%}m-m(7ydMC{Uwk@0e{@*y4+l@0N%{QI>LSi~8qaFGOv*0d zBmQOT+1M7vYCG8W_7kmM64*XpzN79tI-F^^Fi+wR}hwm6{SSJ04(=6PzVvF6v{66E&`;+G2V6&U;Y za3PAOX+EFzhd=sSeUUlwYdy1cCYhMeT`Td;4VEZ+&dG5g+NK}PWXM>(N*11JiJoof zWq}WZr!t4xH!9@mciGR2R&Ej)r+lT$q|Toy3uXn<(cT6MYb;P@ryoj@Y6(chFK5)R zw9Fq*#CTL%BP#kPgFqMBKpdV1gsS>8gPcOp{th3a1=|tf?)4X&jg27wm8lL(RfpK+ zm2*HvA7XP4C?X8DIJ+u zl*i^!BL1vkhOn4X_-;bPy!J%#^k=QDy61fB>*fOuhc`2fM1wT$gn|DV_xj_jb>n%f zNpsb;fl{I(%@lVK(dCw~O-E0#8wBZy8C z7O}R2VyX^;k&$o~p2bIPU7_(px^PryvQ98R`992V7W4V*YCmZPjJ#w$2K~^(J5r*V zA4?@`J;oMQOFFnRvMk`e8>VuWYoA!+ISjzu^XGlEsBg}fXmne;C?lXN7e>0xyG6m4 zm^LZWSlG1iZ(>cX`7WTAH$B2VB_zsDFB#dSXRMYeY?3H!B2b;)KJ`of2LquSEgVnb zx(}M*Oshl9_W_kcW?R9bh}!vF^#?oN;P7if+o$xrAeeeyaG?5)B}G==8!d_UZ?t|= zVv@TlGDH$4Cv$w$DG)QfbP(XF!Gk_k`G?xJ6^>V`Esy*xUv-3?R*AoHlzNl^EahP< zyS<*Wcm;!9pHelQZ#&<~MYN-p`LbflEXH+yOI%hOX*?_U*mPMm((s5!^{NLmN>n0A zKC<-qV2v%*Awz>JzFJBrZ&368N@mb=BnHiUBotAk5TYsn3q&)*h|Y#@%mJXTyCeGH z{{qnwVMINJC{-1w{lr>6gD0&bcD=MN?zqu?1sy|9V-K zn;9FrQTFLHd`9_X2Ey2ahLW?Yn!bxPTu30FbwXw*$qM>UHFDuDF5hV?bMr_TfbuRZ z+EeqUC^qVoUM)IpOx)G2|AXn+xbEP-|3faT`!LGAMGR_!aUyIIku(97GSfOz;yf{- zUg}4v%>XV1TxM6R6n1AtoUJN?i9=O|f9W|QKd2*&)>pm6M<24qM1)iKQWxnHRPb^niG%sJ&vNxT8ieS+4@jy>5|sMXZDuZ2M#_b_VOj9 zQ7Fm*_Q(A-J2@()?9fG-dkBCq@)vR_UT1qanYU7SEk#h6{c(EC|7d;x?B4czhgi$j z@1;0;Y}j7f0~r5{L(TYj-|~)7k?lzMTbbpNj zi#Kq=3DJ_`Dxt8Un`?W!J?IvHluH%i4XedZitys2%1teBnnoO7eQ`@i?Ai~&igkPK zwOn&svD=Ph9NN_K?DT{1>~ZjR8(L-(I<>qub!@rU(s5-^ZmMeYR(KVcmrgBquD>f^ zlXhqlqM1*tfLNyHJv`gF#9h-7t!Q;Q`HK7#%ayBuAQK96d)Jdfc2tfZ9wk7BjOUQB z+&qC(((_8@D?5sZ3JgpM9^(FWvY|k1<*(1|BaKLsNpu0HdE-~$;KqX(*aRtd+`@&O zlxJ7UTa+nphg#iKz2cFo()?`0?#pMX7O}~@bIZMsWIv=srNCm87QLZ4o#oSwB-4@`(UNlckf)Q6?0n7R z{MU4M1=>~8)-8SJG#JH9(>zTr{DZCZGv$FVu)Do#>m5FF{u1>2M7g*4X{wwzJPyj{ zNBM;G_X~zsY+IMQzKzV(VNuOfVCj_z#pV^#JhA2pfX5bp*dvy(lPJ>Bwfh!DYSXi| z!K#>UqFhy-Dx7*hb2b%)zu*!}^f1|{vNUN`oZV07_;8pHPDRemQJU4Y$qls}WQx24 z^O_F(DJGl9l)|RP50Nol+>`u{G&fXjx_>{=ZW@J?pgJ|M5BH<+$s}$E!b=V)sYb2} z{2Gp{QoFOnKz+-Sdubn=KDE|>vZqTr+z{kZFzmqq47jMPLV&$uG zgU8sdjyMTYIN@XdL%2ahtc=26Vha!f<(2)7islN0)8AMK`)ZP#yyT196zI!~u`8bE9wo>ny1!1@ucm^+CsiurEd43hvdw!E$8)YXUoE5n{HLj`wb^M1`t`()<6J)1k%+) zgUU%&m}qGRh-|9tXe5jl+c%*6{T%a>7+*ikVahHV&Bhs{lVgi&W`6TOuyV?@lTx*7 ziZW9m0TL$~CE73X6qlaz{+nzw`*ovwv7R=s&=6xG|7k|iE8|6xn%Jne%)NMRY8Fy@ z{msCurF~F1B59E*@UQxg(NH>C6`mR}pVP}j)W5y>D(YaX1)^H-79PJ^JZen#PB;Hc zQ{|QAaW(J_NY*y`Kzqze5#VhPbOR0D^g?-dFXN|#zD(_zQ|6Y^j%mWUIy#%~92G8g zTyag_rkaW^S6$)scB1l`KbgSetKxJ1Xc_6H+>d6`S<>H<$Ab;{W6k%1f;w$HJrx~r z51z>AF8odzYK}i_`kp-D&CE*`eg{s%!FHE8sE_bRzUgGD$WFHRAj8X}HQKVKiJg9# zK!y8kLKBf_P~y%ObR{m9{(BD3xg}Ffhj+FXS@n4vP+)E$3M?qf5=n+QWKMFJOcaUk zG?p1F(Qy*R^2`C$ZBF_Yzmv;Y(szF@advqP0bn&r!s#nb_zpWMRlTw(^Pz;VE%R1R z_|6)wJPyf$-Er&Azk*6^&dDKB`@{rKkC$f z)QLxv)D-EqQJM_dm{3fB2o20RqS+l{3kDR^i*hdexmDSBhIV9oc^xa*s4%g-fIz>3 zSo%xVXvK@M#7EqqjUrRts7?3WZFDMvAh7flwZch-^3TxAOT8U#XL%udfkon-;VRZN zLR@5&N#dUrHsXR~E$X0>XKj>S!T_=DEb zT(9O`&{(;2@ju;ZkIq#m{_pJ3{=H)a-6d8iNzy&{X8r1(>}VLNqAzAb zhLZGKD&KxHYx9E&i*}yxx=tI1w|~k)#}A0SoTWowYm!^N_Rk8vnIG~%>c{^Ti3HjG zc!D8XAw)BI%~bpBYk8=xIHfq&q6Ijdxb)-mM}EDO-E(y6lq$Af6+4dqhf}v@V%>zA z^mR&Hn=_Ag^kyz~FV34#n}1$$ZN-KuQ%9%v9F4v9^U~x(lq8yjl$Iieu+huDrf@LTc+y8?jY~lz@+TVuQitV8qqi@dD^?hH66zlnWd5a zBeS2s_fixx|Hs9(>>lNc_>?GPS4OnlX(b*oJJzJHKrFXv6=H%3UP@U@_2T8&De+x? zjHx#^I%AWJqid4SB|jgT{C3@EHHmKu8hT?B^o%7aX=G&VuIHyLJSjb#{&@u5Z^QjH z$!{&>^|i^r7mKEeX_NS04({Q#$&wNd^30vpcl3|Gw=o<>S<7hx!^H=r8!X8e#ehlM zGC+n{U1k^>$q9F0(373XcU@S%L*}~}Q0o5!naUD7c52b+yfbN!-L2)?ie(MG8F+96 zIT7gKM>98+6o9&qid5vEj4dmoO8H+xJ;g<+HEZ+?bZ<+m9VZVbvuQQSTVNjN&lGK! zZ6HdS;bfYt=gf&l!JDHvAhV4#h&N{9s65UbbULzRv+2mI9}10-ZM=I0Qx=QVfc(CI zwEDkzi8gzNrdI5)tG$}O4B|IX3SIM)X4OblKFcsIeG)tOx5pA|B`Ru&?Itsfnlfn4 z!+Xox+SS{<4EGzR?*e^HEGy5h@R)pOCpEVF+_7ryr&V7s&%i zPm%=f=2bjqim#9xDZbd8LoFX`bR5p~ejSKmy85VCvsvlt-QYeZnRYy7eF_v{bXIs} zu{r9;TRqHlk&y3su?0g#5X4w4#JUe#tD3)a`xw`&;>HP6d1hw`Rmz*dZYzg<{ibv&d7HCB6BQJz)Mtj%C=BCs+nzp`y^r(d&y6$`b3olso3`pKY;RrG z8~i0SWlmDp+W9`VVA_QQwN#DXqs@WD9`kfc_Hz`5M!POsJD3sh>vl4NCES&G3y|B$%#w=W<;|0aH8CSdfp z@MR)3L4S+plEIP;ou*iGiZU{m1%|eDf4!A?8JU+aLnsFX!#WNKPTjT|tgP1vA#wdx zI^m|Ejp=I6xQ!#($NV|ZL*e-_GTa}Td|w_l`btG#T=damPb1gOOBrw=uvL6-Rpp~{ zrqrpjF&$o#*wiGqc!>{pWCj;)>4tM7*S(EfcK8lWmHq*7Qa9fsNnLPwS#|S^vF2sg zT@5>+fc|EORu9d~UlZAa9k`e%(Gwj+-@rIN&=4yfr>*kG4+A zM-6V@R9(>9OI$Ibpz)W9tp$5*1kc)!25(S@_v@w2wC#WNfExG%BleWL;aH5&z?^H0 z+rZQ+Egnn}stZHZ{FTR03m?Q1EJ&j;4a@M|99LupZ}xdsgskjn53)O|YVBu(-{iE& zA~MXTtJ5R%MkcmE=Cjqw_K}O_k{G$}9f}2|6fuL~n25Rz)2HNtXVe~RVZfdv*Jeiz zUN`dVWko7JuufsWN`z=fW;vprsC?_7I5YLVYb%Z`i_NyUyr8OD{zyixU634u||oIe+USyT6qa9}5g!H^~5w*m9-aU?yL3?X4o&!{0A^K_WfKu7o+B}D1y zhS?!t_?#nMz<95UVL*p32L!sKXP`TB+n)6x{ptro>CJU~{$5t%Z1{AEA)>K{4~~Iv zvR|ryIX#cx$PZXn>=;a+YpS7Iz_+WUom@QTC}3YdoS&zaYJ^MmPJ1YC8@OB;q;gCx zAQi|zNrb?RsUrd~$JDng3~Xx{%$QmXnExY}*VMToB>$GFv&F!4v?W|W|Bk6=0{d^6 z`hIvnl|f=h;hsig{`(;+_SJ{4_E6XH>2ehFMQnE5Ibhhv{K~vvALuP z6drZLUlVtEL=R^;t7xn2n%JzKB%-I6;p#t+pIr4ZN#ZK~Jx%Wm{I4AIZk-h(%y_&} zA97hp#4j(0o6(^T4VEzW#Z-7hg9K-73ARHW;X-Dd6A0=|7~D{3zGDAm<(`hddVMGt z7E>cXmW%p4WwAS10QS@Y(blq;K^YIdHl=}q>1cLmFIlnp{}ItCR|-LemJviOVr%u zLU~v>)Qinxq=^TB_bmN%a|KH=LRZBSX9Tf-WZ_U(?|0@Fsc!F%l z)j1OwZRZ2~Yk(uG_2D8|R$GMpFw$lp@$Yv)FE@wC#^zzaS^@2B8GtkM8XZydMi|Zo(`G zJ$9kDpBwtmYuC^}^9tTYoS!dp@y}a|I=VdUZq)iuDo*{ajKikNo%e||RL7y5>nP7+ zHr_%9q+AL%6(~HitHTL}49b0zH}@VU5CvJq{eyNd+!j)mjt&n`s^X_%f1Q4)$xh|S z%{KaRB|wlkP9ze)uAfx2?rOyg$>GHMX}d=gcJ2QZOIsV#o*!(wj+xoO?9X&U8af&{ z2wT=KN(@!fAYah%u2au{f1I<^k+NFJq>aN*E%K86I$@M+v3OIJ+k(VQalriq`&j7< zL}`FW>M}d5QN|40@I5_lng3QB?B9!yJ5=Cp%8UL`dFxbOH~+IddPO|0iLL%yw<;XM zJk|r>w|k0_JDiB9(DYkkR_gF&xs?HpA5d-%{`;`7Hg)_2d2MGuC=jh*-BOcWGjwgu z=1m};_N^15sl}}|ivh4s=j8N&-D=vid*VyCUMDfnlHxu-G1bpjIGSk|tido?M~N~A!J(mR zM-AOLYUq0`4qF7hBDO7X3yU$D=8=!x#`!}CzH9XpPr=;3(h5V&-Cmx)kH32jii>ak zf3u~Fzb$tE|A@cE-~9i^-{1Z};P11<*Rj7ap=SS`zjK}Z(r6~)F`&KTHYlvGj$0qs ze7e4-`nMgVXAWa3;TgBOf*(oH!n^wh2i06n zO2rnk^0)uoz2h3x4)hNspVY9ex-9Hmt<7k2^V_yy8xKdiPlcDRVRGk9Z}3Z+Sg!cy zQbNw7eK!xXqX*P_af53?{g7{1W_%E+FMZQXR(|z0!jg_Q{!{z!W8z#u#9$Y2?)aBy zz1ZT+2)BrZXhu6>jpNT&1?Awto%&}pham5YpZxx>+G^8FuJaNczJ^!6*SdgVoK?sn zk(|G#!5$Q!2SFgR@uH*HpY%9Yc2@T$(M{h>{W-b@6D<^9JbZQ#i+KZc?@g6@bX$4s zoBMF)!f+5V>UePO%cl3)_&eH5Nnp)}U=w)%H;V}~e!_oe374jB`Nw8IFQw9bJwE44 zv;;K7prO^TVOUN!i}g0u$9(9TrNd=*mSE%U#nur})&sG)7jTL&h}izP6TPJ;GP2Y~BN6P0%iKoP}S_7Y4oy11G0 zrla@iA_?p9s7@@_qhe+oo(%T>TY}{x4O)<>JkOh=1%@e7anC9($^aU3PT6d6k)O! zZ>^5V46odY7XKPwEqo$?R~;)hQI+oKhp|L;SMDX5Q@(`#6%?IVif2g?0%S#1X$i`a zmLcapDpS4be-3Xrp=#;W9e77qYp`*_F8RHP)0WX=4VF8FOdAVlU||`r3>;cJPbuWs ztM131DwDZ}YAkD}ir4}JgdA~PzbvC|R$nQg`&pooO9MmttOejj;UexBq4?`x}MGC{AHRdK2mKxU3rH99@dMEvKi;X zxXcaQZPVWsPrVRXgUu7+I}fP zsm4I!8etf1jcvM%t2XN-^`%IC*)sp88#s%hSt7rUydUTK11dddV)}dHpr<*H-#^Z! z@HD&hue8g+lXYRs5jon;$xS}R-Y?oO@MNuco0+h!hN9O7%SbLf`EnV_XaspD%&7m4 zg^?-~XDDZS>yv*V^VEPgn>!@{B~l0e2B5{Apm`2-XLHj8pnU{-PXJ1<2F4A{or1AG zocRs{n+cfzIHZYn<9VE;Br9#xOB<$d;ke^*hYg*<_x z3oc#srQLie!S^Fz&%d1yjc(YDI@h>`<>reJ7pChtQ;vGB(y-9xjOZNOGlgDyY#xql z8{Nc4F(ZJ0w#F9RSTdhPa^Frz26EG?+V1EPD^aIQvo_uH$kEu6?f!1H6^T|#JN2+u zj)5GYp!$2jp+7IxeM-zrCECQ7BpP@eQ8d}Ln#-GD)1vH7H$V8MuBE^~4}+AQva}BR zEk>d_T5zpSU??(9{2OO$PZ^dwu&DloR;}ocOB2w5;`!8rXH!GM59x`pfJP|jDoPy zsfqs}9%k|Tlt$+sT4`!4-k$tyP4XW^889RLjVlHV93!500SP)CyL1)>txO3{I}6y|_CR0!)KP#3pty zvZPg5Q_w6MDzjpl&EtEq<6jhCn|HKMoGCIS^zoAUWNPJ5`C40R7V=Dai(pm2c4D533vFu4iTfptrn1k}gc`t%`(Q*M&1vq&f>~TM9I{WM-y>DqKbXMG4L9td)(_L6)E!b#ly`yEf|NV4Ua+%fXun zSvV7u1Nz4Qn;cxE9G_vN-#<6fCy?({yhxp`MOrJfz}`49vOcJjJKmoicdFE2@FzQs zof(5)+|wXFPUm?6C#mw_pKaIG?&T>w_$Tty>K~pW=;@BF+jckG+8a^Y7ky%Bm%U-0 z7`e#Q0yvgSJx!&uj3r)xJ-lCvQc+9|I>l>$cSq(c=}m)ZVNzA8VbRuep+o*}h<_2f zDq|!?qGi#WqCF5f{$@}tJoYGXOs}g|(M^k2^BW8v<_qXB&1|8{W+1_z@~Hhf0ASsx-eA^wuJ(oi!nSTmu=oQ%++tMAu_Y#Qp1d^p6AQ`URc}e>o4hxK zz1JILko~P#78j?w<0-n7VeOWJ#)G^kX9Ry;m^$BtFlFkfHIfv?TCPz+pQH-yUstlu zH{oP^xMXqV8rDrHTUwEqn&f#1?-&!dn8g{$_Y#Xhzx^XrEXp3R~}|iVx^s#a;H7)i2)o?b?G4#HgH>m9dtmRbEZ`Sm-f?U3%dniCmVg zj}@bsK9N?g1TD{AS!tb%-j}I8oxO_oeE2G_7hxO&7?mTi{_ixv(oQfP4NqY=R-x>3 z)~+5yqU!Iun;E~cu%p|8E{+-`Gt^ouHrK=fn8KG9^K-sSFeyBHdbU zEj(>%=(2l<(G3*3QlSg-|1>;TIauh90v-D1K6v{;ciyTcZNuL)v1ZUWp4v~9+7CQY zI1PcwUdx79i^cP6H1oEm)Dr)yip{a;K$;HWcude7qW3flS_A#M`f@@tB^z~F7U(Kq zJAEEi5X3{*;kZ=>MDNm=2)hxEdGFHQGcQk=S}ZY8_)@iRKu15?3M**o8?0`65Cav| z&E4X!f>2`fP^-Wb@<5d;&LXkaUeqoH!GNV+FU)KzSDmtIzrcU|8?cZXOQYS}yxKE= zF+vt$Tcg;lBb2z^k1vVqO=SeFH<^8leA@Uj0x6^f?HLEvvI6%UOPrxZ>0#%yD@<&` z@Uq%;&q1TpRc$q!*ViDBL;}esC>@<#Rnz|V4z=k4N1u}Jvxf|(vYO2-KwMc%WYfC0 zYLd%p2e*xGSr%(ylK>F*98`n!vTYq)jbprak!nHEiieWR@lH_+GE*eQDq0=3fz^Pjj`0#YQM_=YvD&3t;2qLkP6?kOuJk{FM<6;Bpp{} z1L3353#tL4W9ccD63s~GV(t^OJX6D3d&TL%zKg*0si$*virRa)q;ccX=pG`Y@Bd>j3fC-K?F2VniG zbVJ1rYH+bROU2KM8!WDH_M>`8KY|KG;D~LP*^JHe2+j`#*v5;;XsYaI-pmo#!pSR+KBD<#c_LApeLLB3zPN4RcXvzu5(h8a#FQ`E0Qt;hG%W(9G z(MV?5#eVNNs8Yc^oWM=Flp9R;FN=iDKY|cEI>JZ)7-G|2`jFltHqH4XY+^48*t89Q zm|WdPKL>+dOa`a)(zl8gQl<#!t&R&~9xuvslWSN$vGlFvhhl!3l*XVByu^&6NaG;( z{1Zo*UTdV#i;YvM8O9D6)<#S+hSjl1YmPUugjpG>>etMOtJii)H_9^*l62z%5ftJQC_aa7M^XQ)g2Xb(Xr@(;Vsl^BZzS%>T1g1c`oko)UhQ;t|qfD zI5xlZoGizRKfuku1zq1Z{5;w5GamLiF@5f(ZY|drdZXr-jZagUZ~Z!U%@g*pIKoH8 z4VTIPGGq%Ik;w|eS72)k+TV(%uFQ{Dr%uZ+sm^;%J9o`$SHi@1BN}Qg2G4-+(mPg+ zddZWDu#}@->S`gb8AAA6ZGPP8$kfneLw*UWtTw;Y>zGv~vN|PDwOZugGEnd6)>a%> z3`*{e-I`2LS&~*3>m;(X?2?&`s`7ubT`~tvqyq9|i89)KY|#jC`iWI0vJZq8aag$3 z1}3>2$T&b+{Z)6uZmp8CHogtNJ>l*)Um#+M8OCJ$+(@^c**PaBSQo91x!oV3Va1v) zQs(9QDe~`>x+QU3gEP5*C@k%AE45%%hVHKtOBR#+yogH^^0gMIKhh zF^!Fyc^QgG%kI;{Q=`ecC}u?Pt5}9Za~X!RLu_e3a&pO}0qdYL6vZHG?Vh@yY4T7s zsbs;v5vn}5{DRS2cAjKA=ogIC02l%&eJ)a@E5%C3>91Fc)8l>*r*F$~+No4m_mE!T z9WYbU#2Kc>biyeHr}|c`o`N-2QggM?7McYs|z;bZRP@n+qE1xw)Y0GJ%#& z7hY_MVUEoO^$E=d^&E(IdiRd#I3QXk}Zdo)Mo0H{n%22b-;StXVclnE z0lmOLDD+>b?#wSGi0R6EdFfyI1TyeGGT@(j2Y0{iE)CoDAM80NevcEs>&5SS_}wpv zw>(qRPSJOu)g4~N*?8Q`s(%8L)53fYO(SFNdjxClbeh)H z_2Zkq$!plXI#pGV25q>dI(05_Zdy#j7qK<+5SBLme z=T2PF^EnC^$=oX&J9TVXhb_UA!qq06yvkK0D!*jz*(HOjslvE_;tp2$e}*>nPsFbH12%*!3rpC^Q%jO&9P6kQHbrvc@khm7U&-{-y% zyot&spVHC7&WOL6xVKjSC%4hy2Xw9kaw@i)zK+e_2>5pTwNKFA$CM@PK($EYE{VmP zfQ&ShpihF!P=_wQhzIX3n&Xpn|o!+(b}^%)-sX-Sv4B4y5e}W z(qVc+nyQ;BPh5kU6>F*8L1mjBuT2+T1g1?jvGxitb!u5`!SwU1KyyTG>SSi&YGn#v zKh9K*bB5QZZ)zgD+SKoK$@UtZ+)$HTSDXBZ^@y=%b?qZ#j~!QFi}oMG)nzlwHJVvo zS`&MqoynQx%Zd&nj%~-9bXZP64F}4VBB1W z_Sqe37}?XFW!TN)OYE__g4&8Nrd(E=I=8qsZ$s0x-gynZG%LoA$(n?`v7`wwk9|!7 zL#Zaoj5l36`WupJvG`i6HO2!wR##^|XwY{=HNsXc)0UYWD9}X0T*Kzfsm!mCkX&(K z%;@Ag8xWwjPUH)hAyJ$IP?pbCN74Jc0%7BF>^bj!3RrozeQK z$556RB7iM_aTnxS1Bg9##ki5lEkjmZi2fgbp*G8(a|?D0;(Jup+=h~h z3zNr<(~!Wwht0AyOQz(6y3?6zSpu37S(SsSVin8s%lOFVzh}Kbb8k2Zy)q!svY{1l zvBw%phQ}WJj^M5dwXp|Q)aE5Tiz(IySRPCfZl>QhAM1FYI~v<5*0K-frae?wOhza5*8>eF`NkYH_hV;MW;Dp` ziKJB^O+Gpszox#+9g;3Eti3 zvgsS39x7h>#G?HW=1m}!I<*h_P zMy8+VtvGfP*s$|c$FfGu(#cJ#M9vMmOA&cW=a`kKyJEk`!-|v(rjp;XEu=sX#oa6$M#Laar4%ZC2scktkD05s zV)d$;{Kp9DTXdZ6{=yx-vWh;*ulpbH5j<#-KrmCnW=pLu#Uv6VkIq>>cjues^Xhpa z8^vsz(K4Q_ZsDpw!-1V1HjvI1{= z!fJl;%N<8UVc_il7IzvXzdI?E!g6?;nNtxm&9eBK;48rH8XE#rJMw=UfK7-!)@G2; zJIEtugdqD1ate^K$CSBf{-Xmse>;S=0T|8PA-n=ef3~J{E^)LTb9V@JT&Qn(kDnW! zrOu8IYGU~}R;+%Pg+Q$)KIyqlO$=~^)SerHw3=83q!=*C==~>-RT%Kx#1NSA>2|+5W-X630I}Nk2 zN8?@oHVrv{wQ7)}2MK^|Z`>i4+6kbh%DyYnq_Gy~6$%2i%CcvwOr_EsWljSl=S8F? zF1jyRydkf0&P41Q6Z42R_0g!k;a3dO{`IWPS-LVbPJ?X+1RA+-uu_t*8;bs~8qC0( zcZ&l$Y_*<VxhT3yPc0j-^au%Mmh*>9rO*QqMY&V~nd`kFOf5l+`PLNE9P1ms znIuh>-U43)3mla8G zS}iftvug5U3vbpI<};BO?cN%ZmQ6+PePJ&WOZRdrDeHf9U*sp4tW@EO^+?y~!V-vr z)7(}5i3Q%A!0m%^HRo9J>c{yWSGzP`a|C$8$80c2C$v)OCwOxT#LK|@w&q=GbD_D& zV%6(accp|&uu5I?gN6N!C`n7YaP|L)C|RJN5<=vN0v~0xt-LV9=CJFg$z^h6ab~dU z45F*N)L1Npo|v!-V`+Z}+^2!02A7SX`3@2pXEg=5g!(WG2E$ioMv&fbPE*q(!ZrQ9 zOS0N$rxViF2loZKuG1Z{?Jd<{k?pvXP*V z_8=E4y1&X^!7vxmz=SG6C05bvv#+Qgzt!jh7tN;>PgT})lC$e`SD-eK@tJSpqPr!^Z%lun_jS`4!fk;Tk%>c5^^uz z9;C>=>Zsg<9qpK+N7KQQ9(-G`gjZ}v2*4XMW{ej4;Cw#Gr^lY)JvX8uII8! z+;-w>I5Bo3j66PAOrM(pu}RF@<*b)KzKB3fJV!+MPs8Su2s}5-0Iyzp4$tC(mJNLZQVYa!!D0^|G z23h#3v1jfPgJgf-9SjaUqg=7eLBc6;O%32MFL@ldLXD%m%n+F7Vc5%tI$Oo?hQGz; z>_Qf!)7Rxw00wC_n>W-{tgVfmvX-gx{F?S}MvNZ(93h5#<4i2Bso2_BRhxH45g@TS zFM^=XQ$jE)S}# zR}xFN9QuJ2W{ z4+X%)-?I(<*odv~nQZmu&WEUy?WB*aA#fiXKEHD~sf)MKWcFS11u%2vWpTQb?(`9pR(ib(=Z}LSO z&Pi*k7FwbfifWB}$&swODg3Zgex2e+esB6Dkl)egnEa-gu;c)=>H7uvFQtYN>0bo} zB7Z}dw|pdpyoq)!cFZ-)xHCD^&dM`fBPi-&gj;G(^`z5j*M4 z|7plPH9Pn4*VPjp4F2r>Io|5pjlcgMzcb%D@o$(M!rxCNd3n9?zu590@yBM{e$Uqv0LxU<+n~8&;O0S&YzL=7 zz`lvC=Ej=IB0Xm&6s=btY3;I${E-IZnkWEU?< zgC4JJd0C#lUQK61#rsE zH^9D3nPn6G)0rV@vEZ7!UzN1XhatA&DI}2HlXvAY%H}jEB$b#h>^Mzi<;qcW zg=ot)IsYhf$=;L8;(v+1#X6@P{+qku&s^RO|Atxr9{*VAryeza!M5NhT5G5%K|Uwx zipAn!uJ=&Mb_#N~E{6_D$r4Y;ZLTf!=#N*n*L82dvDv@1rV^e{_AfVtPQ}p?>i9Mm zBYZ?a!3J;5zZ5;j4yzmoKu^Ur*lG1di3Id&V-QTR^nlli(Bi(EA>TxAtRlE-zf+aX zQ?9jj^>M-8sUz=|io0(nm41AuitAP%vDpbnKR8r>@Qk16gdYV`_mXNhQMn_}k;aiM zlI@{8B}qq53V^t+vs;Pui~HHP{ey4*#U{2n(E#+#dqbjG3MPLiT!5{9R8(TCbYGtp zo4r_>b+<3l(UqqL^c@0yiOT2S!d2BU2<#8!K737O6TDLnyE@sDsJxlak%rf#<4g?! zQLLhDImc;{BKe%kFwCe3=_QHBfEh56LF3tmTH=$~q9#yn&vfCbPPyVk?AP7Q7XRQT ziZ!H@`P=IM*lgLPln;f~We;QW+3Kr^d?*!4ud{_F7Rq?7%o@tkNe_ z!KY1v(AlAtraWs=n8`kj8*(OIr*;oiXemS0sZ4H$;$12uajib$$BUh^QYxJVe%j!i z)}Agr<})`kE$}Zm(n%j&a;h)ZyjFGP3``^1Y+c!{NS7?&)Dn?dn@Sj&EgjSQdKKT1 z%VxpEYb#bXPGHTM6)(kvm_X@~EP%*tUN2z?uuhE?waJuVYm+w!mi>H9DgJ+~y$O7j z)%E{Bfs90iPE@c#u}*5Vp;`@!HL;`)3i=Et605ej(`qd)tq2KXzo3be0OL3|E^XD? z)>f^1U8|s06QBvARS=7yt!uyfjAJcoD~px<-=A}znam_;`|bai*DLdEcRBZL_uO;O zy?0`j*ZmgYHfx9%z7i`*0G9ic4PH=dC((JyiA*zynnB`ne{T!|gWe96^Gk^w^bhBU zQhr^yaSgl{^1r!8Oxtt`)Ey8%-kDpiB3x)VPZ&{tPtw^3Sby8R1G@}X%-sS0D-SL2 zyu9hmzE!PTOD-DD>sgVX@^-oV#FYNnN8R2B9DRx2+JkscTgr#00YGpMuM9ye?Dp(! z%mCf|%rl=||Dmq_aa2i#wrd-fOims+E7PmEXrrK*`;MV)`J*sWD7yhbu37pY0`dz0 zxgn?i2kJ`@Dt?a^=xDH1&62#{w)Ojzgceg>qJG^gG%nKd4JA&Ge!oXLmy-x3|e6y;_mBZ@@* z_gv~*NFCX^t(x~-YPs~bdHe>YHwCwe`a@m%lU(V$xYDQdxu=t z`1?<-4K?oRb)E$1;Vw+N!xX=ZbdBZKV!4 zY=_3=>ywkdA`=$wLH35!Rh@vqi2`%K+E}*=|4w7%=rxVWKR1qBJ1O}Gw!+=m5V`+) zrI|zw7rP_A+?af(aoidL5E>&>UeDe;=~1~PN!4wQk%x$-!STASk;H@4sfp@ZoG_QD zcXZte9UVO)fyWJ)Zc%C0Y84^u(j1v?phpW4E}EcKuX4i_por->8fq&cidoD3Cs%9!PmZm} zto}1pz=0*&IH*cUuU9=9gEKMyx`23E8@cz_^PB#`}6S zeW?NlW@@bKiKH(k%`xfuhfwX~7Mc>f{BV6psH;#E%^pWa9v-#ZrspeP)X80Y#M;+2 z-=&z8S|&%n;BmMQJ#efa&q@pLYm}7EsHF1vjpD`U) zUN!}1Fs?@IzXli*;e;FFsiULLRs#*zVsXqLFLa|K(v${KQD1)9&5Ogw8c7$Xe)0mP zc2m-qmxzFbK;rpD-0?HavH>_qtcT)S% zV^bqQ7$}N?FxHEJun|vBYA=!4vap|SwK4eu0z5SCwg8MQ@>O2?&JaqjG5KD+`xD%^ z?@UYYzjI^yo=~VV6yNm9wDc&RuGY4!jmcj2J{SrE%pEVh5eu@H@@Vs^T>__gy5edvju6{MiBnNlk;R1@1#%T=0+!SRe+3~d^o-b=`Gw%5OIHf`J+78}r?RoMJc zjruZ1M*5-dT0x?lnBaAR-1JGj@T^h($>X;6 zb3{6p*@`LR?ly8)wE5rwe3nNRRw9PmX|l8h*ln(=0r2CnJL1Xr0W`AkZW_pdlnDsB zxch$;Dys~|BG>k4m-yYh)FXQ4D2LSP9=Bm?dhE^`6~)Ir(~x{?GMi3x zd^ER3XnjJ1*B6!BD7l?k-Dov7Og}HJBCKXi5uCwrPvJ=l1YIhsVL>^LJk^B@xKq zJ(yda{;*jvS|LEnm%)LEss|3LY5YAiXRr_9x5g+ z7k|qCnqI6ymW0B;rdHjshQR0z5}4bzeN_$Fv94LCvN<-N^%<9`yqKU!-Jn}mRrY!H zt-P4y(Kozg?~;~E%F7xbh5xG&L04zkRf#x9^Hl;9RD)S`PhqfBIiWITMKm1N?_1_h}*KsiKz2p%yfuj~d z2gdJ)fc8|~ovpjm`5wT?Rl#cT9H;exaQ`xb+=XjnK#)PiVQP~5^a!0~(I@EIUe!ts z1X^^;&RcZc^iK0lNRu=zv;)m>z;kxk3~3xvTem90QU#?_k6$y7PwDWOKWng9^ktpC zkTB-@jUYCdepuuIK-bUf!K|VR{}2pe#TRx8COdt{I*9hFn|L9OISUz>hYaMwUM#TJ zWVA_PdPI`{m0p@P9!?s?ZlHj={Kx(*9EGcH$KAqKH|`68ADzKCp_TG&cN_MzCTJ># zt@9k+x|b?lkAR!28L#pieWGr<6n8EeP@398D8c3&_>YnsEFN|3TN`6#HG)8pI$*Wdhi--pk#>cb`2T#`S^BXIaiFF*;M_tK$_hX>L;fk3lQJD%@lrpMqYnKS zUWA4BZCU@3CvYqG5#{+ML7pD@y;t`j)@{VaUUKS86I*R^WE-rqWm!B4SENT=s(tg< zyv~t$V@k#n8vgLu;Zqi$^j%`aPyOMLv!^6aIu&EHVR*@;#qqO=P;dBQ>DiN#ac1CG zWiHl$xc7)^z!N*x+BJ2Ai(?#$uqBU}1zSdeQ;d3yI3A@lFr8Rhr zW!hCVx-*t}6v>j%NJf&IVyoYy&x&;H%3HM_qrzq=wJBAAX?(m%<}lAYOQxGrNZXud z+-phgNAD>fte{pjsFmhmC3sGqH1CsRF_FXH_FWZbl~_*7$aLCtw~Yrcp|B^NfLw}a zvi?g76G-*H?LAr~EP9o?l+EtypOxP?HJ9uUTlU_gqDnZhy)8`MKVgVSJ)~M}pO0uZiNPboiF%gm{{;U!5?TgWejGYi>>jX+S5Q&4kFC zd&u5Xgo%eXJHjBmxw0}{Hu7{5$vRk6qJpYKZ3clV&~*aizA6+Hb^;xk*8mmd1j<5< zQ0CtbU2M%!%a;lh`LjgY!UM+(^a56|nyd7#W+|w94;fVRKVYy7>!|WwNDc{^Tlq2& zGnr2DV|q>>rb?>_l*p=CsT+fS`T^Hnzmz$V*xZ4c8FwA0>|kYjt{qY-5TysP&AoD% z!-D8O%0UZ?^A-f!csijs9!rd|^pDS%W2MYEQ>9qx4&Rwepc1DOJq}~MWsllu!?wkS8tR~p%zTa*?%AfoY)-LCZH>A~n^eM* zjnmOLEn`*hIxl&R!|JHdaVv0aPervB9@JP$2T&yuan-Ch<$k6@)d!)XUeGd3vFyF{ zyZ>OZl+xDv58zq>{wal%KhlUqM3mSH&T zhyMY`FUa2NIt(u=9Zq!^QxYKKwzDsAD0JV`qc3?r;GBGl_8+(u)q>7ZOF3=H za;U`LM{rQHefEc)q3Q%of|+~Y`#Ms;z4*__!nn+$0rRaaDrFIiEns;_iuRF{XPk{- zenHDsI$l(tD<4<;4yh+(!qxqdwJqKD_T;Fy>17#AzmUPihS?YV0;6rHjJB!RYlWlu zqO*YHR`gP(%cWd(#2EIPodtxwRyN39+hBgdwQp~FabqlsS&rj`B{&_gfB-$5q=#F1 zU<0G{QK;gnQ6lXs3~Q!cz*@QglY^MA6uz3!-e-<~e&Npje3XjU@F_QBYCaIpz4a1p zTU#l1!CsMs+-_d7eT|I```YX)*bbr%Av;2JRhgz6_Pfdr_S{qIDoxRO$#Uj|beAP+ z-mI*jt`@lqt*jrPFO)zD!?oMe+ohc|DDAlK7p46O)!h0qM}Zs@TB3aBVQQJ_Gfehe_+!qsrnIRhk{nl-ec2KdkC+^j?G_=G8+4mVqBJ-* z{I^zG1FtAtu>KV_aHJ>#M6f6rJ^VRKc7Gum8NG-6x0vsDfGgQ`dP;}e2PJzlNM_>a zU+9vpFI4$EsWi(^rH(14x@2D%RGQ@{S*^jgH_80pLP7s}*O&{wRzR(CmD_cni1H}W zESVPA-iXpK=jOlNM7r(L14IdR9Z$7P^b+&fRpJmX#Hq51-n=?HON>)HGY)AU&3K9A zXnGMbPZNSUvl&M@`A)RIJh(6S&+RpA9ap%&K&8Mn{-u2}Yu}M#(@UOmcy^en(W~=< zR}QCp>eck%l_T14z4|e){8m@fQHKpg%x%Qkcly6N6~w%oLrlQ31Msuu-{XgvP~qoL zho71NKgWR)xQ#^*0g8qwx^*CmO16t3ug5TSOW_(Yb#VR#;>SFODtYox74h@D^EthW z2d^B4KE{;rzZ$%981nUM4zK*vT}@{kU4S7AC++yHFm&lDVCbD945==tOsk%1o+^7#@Vq2qSNRu>5M_^hOV}Z)1P!1J<%%a z?KcTHY&wGeCi3vf!xx`g^?5IS;XIj#WFu&K-3iWqiFygYRr3xUuZ$kaGGt%xVxOCL zk37O+gSrn|%4&}p&VnzU9@X+1_jA!mcnZ!&IkD8-OCmYknC(R)PW>jE!~k-sGvY{D zP2Wjd*zquVz0JCA-QKJ#*5P!s@N>OxuE3rCe-sEO<-758_&YNSxB}M?{CBsw;+&J< z3J_unr61d-Pv(6Fy)I-Tv7cVHljeU$uiJmWJ$m8FIt~&kZXa9HKlu0p5((o(??KN( z5?$a(^nS~`wZ{){d0QS(^wLg6^mvAb{WtVb!;Fol7vL~Y<+=ZDsTl6l!F(}c9zVB$ zFi{a^-JK%L>Tf|9#%%@N@4)yB&y8=VOP;X(>?geOVVPerrl(mvvBZC*OVb*pfqWVc zTv63ZBe<_t(ivVd7@qlm$5myHlt}yENs*|3pZeJ!gG~t*^KAU@V!(xdG8UW?yZ44| z3LeeLm4{+RVmtfVoIc=`JwRWqUIs=|2&+Ryv`~KR@A65L4kAN0pTcR@U-f z>sAe-`SPPDK1cb=eobwC1GuPWuvAAnCg86M;wd8SUy|c1h^ffzt_Rlb{4Su(i5$k; z$#C?4AL7M+;os_#48N#LD!jxlGP~6YkGw;V>G1Bkyj!4ZfH6{w{Rjb~Cc z`vSeIp(OkUxdTmw1}iHm*#DF%-BX+%PKQso_Q8>-O>^!3+k@8bhjmGYU)3cQ?y`%F z3v2iNdQ6AEn9ExtZl=8`ZJU0|-TAkl0Nlre;Q`}W?9=N8!^_#9Rx8jvcdW_Byxj8{ zdphPQ3*a948~cKMbU-h)v;z5H-ccr#Sx4qQ$+34iPB*tV5uIcXI$H40iwfl1I{uG- zBl+HVJaFrL=YI2gpnTgvXOMl(Fwq;{x}~IfZtE5XMjO>gTOSJ~zy{yQ+a#Uzp%XV_e-_1 zpe;S&6}+t*`xsY7e#)-GuWD7Vod50GnAZYs**-*xt^Ywo(vyXoRi?0hUV|{_o@Lhz zwPMjStnFs`Ec4M@Rd(d3cEa*)Xwsm_Io$d`7rZGnRchoxDp7NuW*K3sZ@&a7Rt`TU zVaFZf3)N|hwXjtNRM#AL3ENjof7|#VHS%d4@0rA!OONc*Ez6?e1A9qp7C<}6K~xgb zB#y}0D>lEpPTrEjdghiA!S*w4Y92H*u|RdDN05kJ1KVtl&o;1d=3Hvzk-7Sl;ac6Y z-X>RhD5xCm^Qo1ydu|@5bBEz~)-u(?`q_$1^~(cUp81nL3XcvBTgF4#HPrgx9>N1n zzT60CO72r@Eo$;GRKZ>RK8+V=l(bJHq2h0yp)E_WmG$7n1H|Wi+_c2Y1emEayPpqim{I6qiJU-g5 z@QTWdEHpe7t>LB})w>6z*ehl=a z9sYa{!1sg@?R+55Ryusq@1;s*=G+<HTvJYNs6?ok!J4knf=rEB~1hT#UpEP!IVmD86A<|3B)r7YA@lu_1{uKCXA zMG~2~wsk2Lh;x2p0;AmvKKj?53m?A8D+58`_-(ujW)~Q3_*Xwn#p&=b3-_dnQlG!{ zNx>)olRLh_#VM?P!>eS6GDa>Neovym0-XOGMfg))Ia5w7K(dX#E>t;2yeQ{iDbu~m zbc0KO_x}{6ck^FNI(7Pw9RrkeQ5jB#2JoNG7J?o#WuMKEeKvz0KiITIFwawf0MlKe zE|6xZREHhRSfe`GIQ(imBB|{Smqv3_=H@wAbWl;6J6qfdX5|Mz0cyAq@K!#jC+zAa zHxa$IoAo~ri#d|_DXmrrHEI0q2?}f$vEE;Y z8|2TasI*EJ&G+TXcp_xd`UpbD#=?(ek5a$P&}izss~MZ|2JsvjiK^ z9r~52hfuaHp`>W0EEn7pCRFng?ew18exX6^bMfSA;%F}9p)vV%LwcXvxQi$M*$_bA z5J0a%U^DrspH0@cMbb=llHF~&cp%%g#S4~vvspieq(^6+`X5|CNNxaoi z`K%W0&4{N@X1s7JrL29kp^_8OK8!3vk1~n;N@USDxv>cK__&V`nmYP0 z-ZZ98T~=o6F2LS7_Tu~%yf~i|_2S8oIIV~F$0=^@-x~;i@9ULt&qR1QgOq+Z;Pti@ zU4Vk5Ip7;oN6c(UO`U;$JtG&5&mJd{MYd;v_?v*-MIVAKh1`$h3~A2r z-R!Z)Nt^*rymI+5>4`&4h+d}^CPY8xhM3cxIgV^dC>9Ep0eWe#*Vjc+^WTxDK|+BT z?CsTuqEdX9Q#>&D!2UsuK3ky-o0?<)-v$cR*k7_Ht>l_C#c~!m=_X6zL@y`InZIC{ zvL>jxRRd7%>*Ds8yxC&QRT^S^pJjA7k(jHhOalUzqYX2HGniYQX{&4ZvZ}{&7FGeF zK2Z@cIx6?m2=p4=bU+~a1=w4IC9TrTeA)8(27#+~RfreK$LB z?Ql4bczN{J%)$d6IVGX}Oi5Ru##uqqiOsQhylu1E7D@b5AL#~WNOWp|1z;f-1HkgT0}wbC!ayL2tiSYFyjg_+(Z(opGG|Pu>z;Fc-espip3ILC zo=!=@j6yxoVj@)tx?AAf{W_ovkn~tQ4g*1_=}lfA1Ft-4|F};<8@7Yme5?C0dv1-( zVyUAR*JRyFF6LJR$sIdr#_$zEY%yeUrc;T(8zE+DQ`E&z_lE(`!`N;`!#{2+MJo{s zIqW8=HZ|4I3&H*~Zt7bmR|T91S7>ham8#EfF0CBINk0rsikb}D%yR4xyzcMI5<7P{ zmOB>6xra#M!w?=i{ZkJ|q7Ut#^6!`DbbHlw3Unsk>Jb3e_HMPvn!LLzsw*a*t~Mjs zUbR^qOK_yF`pX^RrVKY$Veb>w-cGohGVb}&7o>D<3?6TEnR&)+4M~O8a3zlLDX(`K zAoQ{3su|&p_br$F(!;qGZ*fjrO>ZodY=0j3SRS^Xj-e$y1s@bUT;FKB#j2le1)g|n zM2{Q5y?ji1!q>c{+lCv{#;bhAOHQbYCqChDzLz;a)0`^7hi-yiP4I!r0e`Js`_|?h z?ef6yqmwtiC#Xh$tzO56n72{3T$s|U)p4^}rGj3%wyKtPHL3&WWO%+l`X+~s^m0oO zOElD=4`(O^KD-VJ$fZy>oR3h&Zdqbwk9l62&gWY^eM$-Dm{+-0$7F$=jg}!e4AV@$ zbp7$ncc>55^hrEFmcrcmp?$d9nZD^m?y|?n&5Dm>F@nY}D=sj}1L|a0I!FX%_RF@u zhQ?E^dRap;{n=?^oq~7RT9a%O{`lHA*@Ug3ZvC9$hJegiQnEI%Lin_fVo(DdKRDYp zU4QvC+iggI3mSBXCCE4EC3|!Y$}GiGCM>9;cshp7-)_t%mU@kM4V;>$tqn0aAF68Q z1?y(Qk@Vv`XpV_9Ge%lrrM+>M)6k@Nauw_GiW-*QXB=r7Q~R%ouYIGjautKW*s=65 z<;M~s#woD7H`F~9S#;5k)L*wMvPgT&Ye)i3iKjl~E9A{_YU7x`#&N6S-CGYAbV?v= zr?GNPW68>fR7#`UenK{utckD9G*)iGT;~`#p%^8lOpSFPM>;-ah}OVDVBY5kR|tj} zMGGB8xdsMZVh#z;?L2!xWt}zbKd&*l0jV~2ea z&Zf_iJ(xB`N{QDAQaijbp8LyPmU83Pf|S%8^4l$CFsbQ3%=|9Z$37}ZW(A%WBm-

B)P2Fa#dvY90F=P;$@pH8#<4L4ii6@_tQ*0xXpt(e_19_XOmf5!qW>?CN{ zslgy!`pHs;9VB1hRsirYrMx>x={N+KUluTL-OA4z!4b%lmufZd3p}-6*$#0qZY+$H ztI&s2gYuNhYW~>OJo;Y+H6wi?|DYh{l3dDftLF1n^S6SUuhXaWNdHGR#zS{q;T#U> z(I?s~HZO&#SE{sIeyyb8_hSX9FfZNH!V#@lovUUmO(o@(`xK-cts;IEq*QqZ`f5`8 zFN-8Sl#cV>rm7L2CjSsu-I6f{g&2)a4GJ;P#RDm3aj5QZ|0rm`vC2U~N^3t-b)TwD zk76{A5AsBp>&-0%xe)n~|1Y7FE(o)M!Vhq5S@K~)GAsN~L9%K~Hq0fvYEZJ@2FWm- zDebk}4Ahx}k}VQtmi~} zZA!@s%Kn}Wyh!whC3=Y{1zTv9MRPeIq*yZd=sgxq4583pfma#;Jl<;LAJw&OMKu>2 z`8yum^Q^S-AXdV)&bl$*u{o5CfX?jD>b#PTIgcvUm8@6eRHK(J#ku+^_2exLGc$6Q zg*-*Ggz_$+&HR=nZRqOE2(DV2qmz%q)-$YNBmWjeD%c%r; ztjsM+dVf8FLMGhoR2ap@61fb5Q(j;v+q#Ni1AdGn9V*YK^-99|nkd-7Qj#aX*yyvroR~sj-30oMG1MWWQLzVenN_=hqjp zSC)<#yWigfFF*4Bi_rr$!x54${KD3qw4mll_2R~Xf;(2Ja^OoSk8vqC{IejXX@U>v zFhsSODC<|DrYP{Ye=kU8n&9am8O1$MZT^fe4h8DOyXZSyf%0c~8YEA* zCH~gIIZ13)+e(S{?v>}ltGn#F5UYk3_KKCHQVxe>vm+bQ2{{kgU09Mjqp@z~Y{GG; z;v_r*-zKc5b4D6drCssJqpxAuXb>HY44#T4-V)!V>!tO|{1ZNa*`a2+WKb)cTkt)} z+~9n2Cd7&+(6AcZ1R4@NlTvJkW0u{d)S|?SCdS;x8S+o4fvQNaaMYbDhl$)AJHO|u zG_kLB#|MX6)pB_Zn&rZH!f;Zu)vH@OXa8XEM*Qq04EnFMPXG)5*(g@CRQc-X4zpRc z?DK52@+_Vn9HxDts77{a;gB5gqaaK*Y~8N6)Ue{}r}Gv0LUtQK;Lezj#fuk9nVA(?dFfPsg4Ats8`e@Z_Be_%s53{YxYl zfZ~MdzMCxBJ$(f-x08}N`z2>ACQ0UB%U%fnr7D-~U^XzPSj^yOuD4?5>{U>k86@RF zZPgl&isdvRgh180dS`sDAcGknum0MV?|S{VUs2^))jQ0!r+!3129vu3E+a#3Ly~UX z{r=6goR-Ns1! zq3{`Y0`9^sj`7~+g*JbIUz?q$j~!sZKMtN%HjCKrj7yIgZ{3;+OxQUH>Bx~z|8Wp4 z64nMzHb}`lT=uJC)hHjjt>?9EKIjECQB+|xdkEdAd>k3vB@uV|IB0qfr~J`j=DPCP z4`(bAm!vRvzaxG$(C3REG!G?iE`#%|iW*g6z(xXK5r1|5#*n51%zmUfxv9mE&}sd` zTZFdXQ|iA%QTmt??Usd9m-|11v9gzUx*62|d6KjN*UZ$&4$kpgFlRgA>yC`hQM@ZE zuWZgYp)UUA5j_o&2W4aQ*d%Fgs`D{MqRiGj#KrX(VL}Mq-NyvwHE8>eD2)GJ;lt}Z zxTCRO=5vL^fH}=Dd%cU`z|z##OO&}mK(Q*A(0si zW8e8+={H6u|2bare!Ol&JaY7gc->1}UTRDqRf1cqA^A$YZsmfb*;h$D%ve z!9Rh4oinPt-yE$2d-i#z)tG!x8!x2H5=^J6YE#BMNPlH zNl&iY9PBR!{%}?<77Hcsu4>ga9b8l4Rc)Fx1yIgp>ET}68hJXOCAgo?j900AL(cWH z(MmDD{s}8++@6P}7^T>Jy^5X6nd=*zU-9{Vzai^br8Cl_KGYNks|q=lUFKey>oteK z^XBk14W+vZ|IMSdBZCBNy#)irJJe%E zI=-%?82L6v+SKh{QblePs#y&0Gs7i~Hq^=Oe1>-@f_J$UxHMuD2K2`o=7yb=_}Z#g z_gH^{ni0&jq)){J!IfnQW1i>w{xB4@p8xIr1&d59xTOi7@(wmPA!_3ioT;7-C_K~r zSm5`m22x@&-RR(#)x?cm`##1d2_i>zYo$|D&1Ia$T1xqvaWS(vWWIlXEtKp#@2qXB3Pxn8_|ZCN+6@*)b`?New*B zAMxo^zymUkkEv~D4!jwX(jX5Atnja>{x{$ejcW3EonUEOaTAy2{#S|A(|G0pu39($ zzF)N4o2>SI@pZkB-btW>jSd~vm~X9tX3BpRTpU#sR`mZg9CJo zj97Rr^VBoAjToNTF}3QU3xB?8DCbSCV{CmGCrNj8puHa+v0I>iI|)rMx7F3&+PA&R z7rjj{dXxB>wHA5r0>Lim7Zj8_#iIszNa z20j|_T@x6Dbgi3Xv&X6@sLjErQpb<6b*hN}rrK(m3R z=e^3~LDBK$HcA?bt4IP_xlJ(#oGtd~iNT-Hg?dSsa_EaWF7*A5ULQNx zt!`kI4akfn-UrPD^pwRTH!~hz&y!-NEHa^gy!vhGjHl*rp4ZNCxyvwA>11gfmi9p!W0v-PUvbjUI4=N%W;S~(6?O$})f1o_%y)NW%2fLQh-8vk2erhyq~6s`h~A#~pI zxxHjneqr73p_yGQR$MMHZ@y87D#|)uh z)_>@~nWWr>4w@hHLJk`Bj~&y2)=T0iK@{c4CSDYmfm0UhKiRxQF|%gLnV+NtpQ4VA zfLXSNqH=CnXcn%MSwOXJUi*+vtY3m$3WkFdch@M##`ApiZLkwb^r-68h+c2g8jMVq z4SXYpzakXcO!e$65B{sgDK=oGN6dBE>Xu^y^r$~OKxY}li1teEI7SH^%}V^wt#j!x zWibTHs8eAr$;*uos0Dk|?1P|l=7D;H9gvXY8PJu;(;{aS+07Xhn6&d`uTi%BNvXO# zw6(wo#2NQsda|@G?jM0VeLJB#6H9`qakfcP5YW z`LFI_VIU)!{7ab@waJpys{XDq+y@6{|JSfUiB(pB^vU-z~H8}W+D}0D?s9dpN7O$ zY(V7D*~MMaU|jer#;0q=XW|o<zkCpG$RDxx#%c%fBwq-$l8LC;obAL&+OVT}Xs}i9-3XSd3oo_ceUz^*!xXB0=lD zHCcsZSF)uThM263Aq|zQ8v?^j&lqMJExM1GV?i>^vEUAKY`vLdveaZIztL=>cFik@^4LU>peEb~W3a@urLcIPn_YLvf38YGE@m zaE_zj%isN#JMnhF&unS;GEr#i9U9V;hzutN_r*At_<~vSByllBQ*R|WoIn_2basfB zJVhY&+YRZj{G3?wqazPb*dMpuK@D}Q;<)WNfbw9rJI6EkK07FWJa#ORYZG3N*L}pB zk2=|iwS~TDd0F-+#2cM<;~t@-A`e%6DUP#ZGmfNeYoMMMd`^bh#FbNsGngZ-MT9xs zM@xCJJC0>+fom=Acf$*}uHPqz7w$uNC;L2&A!7!M2P1bdbr>e0GYM3wol&rg%!TQ-*&4|a?%vH#KumYCH za@9{=HgS@x%b!i5nLWXjYiRK6(#swPmNIsmK;_DxJPiXQH44SGwXZn~w`-WhLc?8_ z##D(;s4t;o0z&xvq!MxZV+A8r=?q4wdw$^}8=>yX_I%i073y8`JEb@P2H<-qsjJ}upo<<0O~TogqdlF zKKLMVnORQQLQ!WbQ99nGmu8;_DxyoGdcx|(qvF^ppiJ zB8iWbJY9dr^?PVpPw8P((-YVZZElyh=@r$;*j2covI;GPwI#pFp6tDNZg0@1YKHnb z0!>#2l4&vn#-q1cQLA$Zc8HIo!xf7Ze`?@Znt0{L_|hCX8zc92Gr4dWD{Q8<>=ELG zhzaGHl^Axy8yYY9L1u+LZ3Mc8%AWq5@yNZJh*HkcthZO?i&2)j!zunnx$Q$6 zQl)FrTw;_i7$va<)_8$0jXL*swT*0k#-lO1b(e2|%2o0ob}WP}!OAUC5Wu))_G~79 z9C>XAcF21QZ*XHa=~!MzUS5>N6U)ki7mi~alST#NH81|D>Bte4oYXLUT6%JrGdl2E zrelzMJ)+l;>}^QClsSaPFeuI54%pY|P?(NC0E2i@4m-9m}| zpg#MP{|Ho$5$^}pOLWDo70cXkz?KCqY zQQ4SWli3+8G;$CLj^6l^0v27(K^P?7^X?$=?wJ@sh^AuERhfz6xw?&WIJp+ZDaMd4 zE`UKYT|3~N&5J>4e_d@bNv4OVc*vW5lCCn1pf;^G7Lf~iNlavbBg^sna=drq7kV}q z%C)*92q+i}u;C~68cry=tv9zcxts;xKQK4lMlC$B3R;F)lI-msN4-?`cu(d~fLl<* z6i^Vp<3f|Q(jBswnSTo-WNT5v7m*kxYz-0)$zGv`OO>;@4U47F*{BIARC)dJBt{i| zEqBmF(0>%^@44SWJkgZ$VC8*zbkj+7Qw+yd3q2%ZKa%=#|BN7rgWga);yN=@1^pPzxq*q0K6#tQq!(cmb;a0PA|3vAVVKVz zROA2j+wwhM^*MCqL^wN#8(oXqGk4lR^=b2M^U6zF_F$Pl4J=)W-Z2W$(42TuXJuhv zrR}h`x7E2Pb!LB7P+@U>)3;Zjc5X>*8N#W7i7i9_UB%aKE^y9U#dpq7V{aKr#a9n# zUt}SUFwtwe=+z{8HF4hO;cLd?eQ0mBA(AoG}KKhk90_fG}Ike5$RB9Kto+T+FUXIc@9Q;K>>fAyc5A_E_)*}ggp-S*&2;3 zdL4}={_|Mj3teGOszYHRewx{-klKspXP4kT;%msFy~oV-iit7d#~j)WKEs2&rL~#= zf#29@yV+f|hBxxCTM5z5)-Bqe(RoB=Fx`Y>M&eTrd`$s-3Oi91^H|N!*_pWWw9}O) zChImtIym>U5A^gA(r5Vr^zRyu9h8NC1JYRFtpJ(fhl&VeCC%7;#JQ))x zyFY5UnPlFu_)N_A0vp*-QCaKQt_4ldG4s;(cKHCz$lmfPfwHV%wz&Nv)p;f ztX`q3nyJthHp>mX&R$JCbc+QsH~f-7D1Bwe+q#@4S;9Ok#IfdIUqrG2>Py!<~HW38(p0 zYhL1NIWu9QOJ$ngzF|j@@hSa*^j&fN*XBxDK6G1OYkiFhZ^nTf{-4~3%ZrPbg6#>H z@wFto-v5d!`&4}wS*Y%xI?>|iBUb32Xe#{FIeUemv-s3w?d22oI{thlud%ClgyxZKG5vC2}DHj%5QzwnO>^6>lm|Xr}0>iiT&a zOZ-(V-&Of&!*+{ePmTN%H9(Mw#$Ky72Lxd&W!@#ahddgv=Nj~QWqQ;%#&Pp{nEtdBSX^rusuqT7rP<+H zLl1K*;T>`{jW*KeZM+_ul{rp~SOo9fvj)Hl83`}zGViz-IhMdTy%1t1(=hg?V`E!l zb93d2?DknVxv)Ps>qAG(ero(=SNk5dXBRq*A+&dV7j$$yb?N9OU{|N(>;NNi(6N3? z@ZqRGty^=+Nq{;w*ah{Jn$&|)Ql}mhcTP%f?0#$K$>Vz_B{z@X)cxMD@!KXRdna}K z<&(y5JR)66Xy-cbdT-N~O00Om)#dTH3rLYxyG`f727pXiNuACAG0nliG)_ zE|6MCJ90l^P0VugwogoIYn{}xm$#K_Dnq6A8_PlQDD1&fJL;nXsg0?%bY?pIMH&X zTfsufZIj1~orX;szc~qimBVUmDx;BaKUXCmG^S#wziYeOpDL6JGtg241p-4lR=UB2|4@zeF4KqNm^igAf|29|d1%onN$p`-_0Y_p~o^07<7k~v)wKCGN zNKX{!KX45rfNymv{Ib?!Flo@0e^o!g3+11oJ37E1_}Fu0@{WN`;5YUg`!M&`pG&Q0 zexILX`>T%C^t1}E!qao#4hZmD2q1OHxNOA?<9B~Qz!(HAy((n3soS#LO*v%&9HQxe ztAmpu7yC1)m(pKcQ-EHh!XhD*7C0)@IrJX+ctJ9w!i*r9qr#BcR@&}^k}1F6OkJ7Z zAXEOGG&$3ea|sUMKZ^w~J`W=uUOgjd{&QOf@E_Jwp8x!-&M^QEdA0yf3kO>w$Y_q| ziEigQIGZ0UNM_BsDoEC3$qv5IN;_syGUfMgRb3PbXH(>D?1~exLWNkN8mzwghGPZH zwLl3)#R|Y+oMl-hv#^3QB#-z6R`}yg3ZD)a_($ezNENceiZcRS+`QGX0&00hY`K5J zHn4hcfuRtH_yGK_5DygVFYJX}nHOySEc}iKHX8QoGX;n<{7wf|{x$lV$H<9rr5|z` zt}5iO5dh$SNg2MQrvBx7{LF+m{NwZai`x6b=|OuRg!cWGfPWU)%IpPi_p36y8_?d{ zU3oFN#qa7>_z*zjiMY?4cFW7e>X&r5SB^KMRHsSxlleSpthzX5S7tAy$w&UrF{?VDP+^1sL2>2>Ho0jq5u9MVr1> z+@_-T%w@`|aBQNs)b#JZ7%P{I%cKsegH^{|rWfelS_yu+e*jx~Dicg;?mTum+zMT~z;cE+8hggBIF z;K{m4+>dXTVpxpq_LiPX)N|s+VN;~dd-IY5NwSrbgm*b6pPlI95lruB^pAxv& z>6fUvrxrJNpgnM)=8%fd9|kVdAcA+g&|c=hh+O92ja=DclY`nSCUp!jAI$dUxVG6} zX@fp=zYXBchw?$2{M2pIakE~E;6@TRq=wSENSdHboKLs%s~s+AYGY~?&Mj8DHP)>S z4&08kKL_n?-(O9F#@V$Y!LCU}RZk-P96hC z$ReB-)U(PP$I*wZaoy&1Z#!Jusg?A^(?_x^*Xqb3gfSE!w~QS?;*n{q1k||AszJMR zH7IaFaUd;wyLKFjA;(4q>=v@9i+mi-MwRDlRH%cJ3HB0yFsDX#W7;v}WaNUc?2|O7 zxk4>4s23==TAw^MRF-{Ar;P7v?L1ZBsDa6eW!amxv<^LcAuPEr@}oyUMr6_MRxt-A zfLX9gk$l}4S+o_wQP|_S)dVFsj9aIeY1fF=gs2-97d=awhH=acJd4BYedZYA3@FJX z{B>_RJYLz|h&!@wS<4q4f%mYD9y=wHDlIv2S9WUKwafw)8Sas^u@$%M224xwFtEP%z(Dwbe(zx<{yU zH#D>jgI(w2-!?-O3zzXt1oA(xUiA6z@Dkmx)P7iR%FpEIW2H@pA1+*}lIv^yYuVi_d)a{T)?5P4ihLWXkyWZQHF~sN)H9g2w}8bM zb#^uH>!1@_%5QdjUv5ZR_Uod}b^Epb9b-k6T?Ig!iyO#<7y7OK($SwMWm&+btmxEIjtM z+oMvtAekfQuPJiQLZg8Q5egKn>n0Gahg_wtxY4ntoL;qhcA@)3bo0+Wo#NBslL~_} z@lkXB5j^8aB;+kW%aUFGK!L5IX87j@$!ZL%HSu(fa38xj`E!<{hPgVW&*@dn61Q8(Fiu(t);+7zp zYsETA%IjzF^9<$YTG6`e;8qmN>-jXNP+np1D4iP&SJqm8>k0Brf05^?&0dJ9_AB!? zbw_}cIRZE^Fecl&Ls)J~l;yO^@cW^Ge*d{sB&)MNKvp$j(~nN^0}51PgmD`My3)Xf z6{|@s8G$YjMSgTMzpeGV37p_qcHpdmZCb_$wkoFa$g9_BzyfY1K+OM2R>cT+ZqxuX zC#ZTQI??;cvT4M_&|3fK@oMQXF;7kQ?jj&q`MsLznZ!*mp8k0?a-RrCfF6w6W7rkBAO3L>9fFPL2k|kXnJGzt;LU znuMW_@A6Uca)C};6-jU7Gs3#sN+eDVV$FV2x(zI-7sX}?5LxE$H>aSpjXK*DOxqsc z(}lU1-ql+7oBc(ni>M#!&cc3{P+^NLUi)^ZH}snv2DN*v{nh3%)}{e@GiSgEogA5c zSmfc;zw^=ZlIHz_WJ_+R2k?eoGSf@C+u}+y`;yW1{`P@Q=n|`}fm$V(Y=6aCsa*^= z8l;(z)Z22lw_)xYrA#lrPE{mvx8kxi|q?*8opQ`;kKQ|&VikrVfU#;Y&CqNJMKj}-<|G81x zU>82zoBQxl=99kc)BXjx3(N_Rx_N|Di%PN^{2Ts8z1yGvi!8Jl%p!VF?2?CMgHYcz z2G8OUngrKL=uxqtJ}TDqfAzLJ2GV7z#f#NcJmbSPsT}FJ&st8vME|RHd*!C8*(V@Y zL599ql>Wb(FR}yX*|o2=)gD__r2bGL>)jo&SfC;MS%qn^>PA6GUkV67Ec3sQf6Y5H zZw8qP;saVM$33*~?>iUh|9vUjpL;mj=(Be%`0yotIE@dT{#0Ne2zj7ZY{#YK>WNj9m;%TNd_aFf0vBln1Ey(c8O~tMOM~byf@l>Ef11uQ zudhpVQ9jWpP&}U~DrCpJ#Kj&~#|mLAvGjH>p_XQ)0W>)GvA^c{8Y==q$-?B$G;j^v zT)W)%nPymVj<;86W276VhY1850C8R^hHm!xT$(A{O>?x;+~TF%It7Gk{pZd@IG*H{ zIGUXCH0*y!?x7fuInzI*?T#)h&=ghV^Dj6|n&KR`(9ettNIrnxX2=wo#DYDsd3L1Z=RwV; zk_$;!;(w36R}ebVi74X3GxaK;I!D72zb>Del&r&hs`;Q!DI8d9cQ1MUP1MurC5LM; z8sP)wk;WwH~$zf8j@&Ujlt0~MgL z;)p7gqqn*6e^xHq8b1mWd>Eo*L z7{wAFU(~`n;H#wkblO;A8*86d>Om3v?{PD}>j{}Mg5w~Zm%S_qY5tSUyr|AMn9Te; zhI;s!0|Mgm!JVQ$WDm0)!{qhnen;h~>ZpznNo*c+(E_d6h+JFLSGHbEH#Wkx5^Ud| zeLC^+Y=k6nvDB~OB>R>iM*S|$sb5lzY`s|O*AA-4{sG)~lP~L&l87ydHc)FEGIzN!H)u$vb89uFY4{Y1W6&n8yvfED}mH(V# zkk7QSK$&;u300-cc6Yq07640=cwB)~ngN`ypPAr(MqeLpCq7S4jr>=1j}T4Jl;3o9 zyJdWryVdYz#sx2;JlhMSnm=FAF+%1X5ZuXDOV~S7{v%03GCbMt)tCeuyHn3ZKgpgC zuw|8Bz^~@ux$i_GT1dgFgfqLuNd7Cw!>yTP`FX)*TK+;oCdPR94=02aTNU#Uaw#^w zR*+(Mr8vnI8|yE2k&3-q#V&A}4l10JH4(W*#i9=Umya=MuYS9rSc7(mD|T{!u{A38 zYbthMS8VLff=niojTFoIZ?D4zL?jKiho2F0i|8K^%uV6R`&rrBoi+RJqUfVNG-)8(fAZnUlq=gdcm%n))Osu zozf$=j<&2b*9-mizw}Riji!FSpWz4a``t=iB)=Fdds9Gor%7(mCJ^_|gD7tF%h;6y zKBuo9d}<;rmGJU>8^N{_8hvs_N3dZ*dHK>U%Xg$RNK3)Wn7YXS8)J3khp82{+d1a z2=ztUzXiSn>NaT`+r>&m{7m{Uv{JjyD1L;Ps(DLox-`jD;D_E_*|2;gvr^$>DMciN zU}VHA2nBT&!saP+1#hA;y}=1o?LW^+nKZhFFB3bu790f5A{{3HgSf`k-F3;$7FKNK z=|cc{+X^*gxvElmd~ncWQ14 zxh4}2Hn^GyWeMn(v5`j}ccpCV4YfWYEBi?^kEU$OUOxUK`IfCnTECC_~0IX2!nT=Cip zp>1pIh)C#?9YvES-8L}8XN9i7iS$`iJe&3%=9eA~Sm|&_p(}SETH){41Xn&Xx#}=4 z@?@7O;gh7%&WiIh&1ITfICid6rnv`-+$)#H^st5SH2;>Pto(7$6=*=y*H2I5!A}92}OZ^Aze*U|7DM#9#{H4h4ERRSEj!mAR&GGWrXxQIN-KB zAJMubrg5!v61f3jPpe+R2a7!kt~x>R3gsyB9sG7|8CM>X`$40g@M23-AbS48Xe5`W za5^I$zN9eNXlIqy0D$0q{*wiG*+m}?7UTvm9rgJL4xPVq7GqmQ(&qGKCqFDsRA_15 zi7w%gxs%2rE6C;POXA>Z2Wo-Kh-|U!NQMECAALkcGH#~xv|uc)buFQ_yd)o8zW+6v zlKq1}nZ=CMV_%})xRtWqneJa5Nnb@FfuvS@`Pe1$FQ#galzO*&x?J% zakgzA!w~tG(>J)vnI)CoF0RIjXVa~kWiE9Xt(X|;(89z(oG=MK#$JIo*e!Z193`~9 zt`j%Dzr6kLec;X^BA@d9ASLagskxH;sUNH5BdTn(^X<)N3EKgm*lYww-)=IZj5z{q zv&BVF9f7?Vl;~zJ33TF;?S*}BfJK z-G;p&q+LyO`jajvV2r5W4F4bzHKF-sG@cIU(p^L~RK3C31l6X?9GoGj-IHGf)c@xE z?i-Z!$z43LT^tc?#C0KzvfPW5=y^wep z`{H~VC;CaXSG5{am_!T6Un65Prk^JL%n*On2p+%j14C`BMy9#>tw+bH7MHSe7CW9(iLZP_| z_E!b{O%e?#8INtQ3Dz-){r$?Ks!nlLHRP)LrvMyORbxR_-TyRA7A2voH_2n2(5`O# zRI4#+6!V9{5p)_AUx;X;G8K++qc+ocbT_1gya5$NVgJSVje{z9s7h?^FWhDxz>?Zv zwxWLzxP>2-s`(H|k={=T8+oNJa2|V%yBYI-YNP~pK#jhCIR2Rh|I8ErY$GI%%O-bG zJRVOOE}j1IY*n54?Vt&+BL12?ae%&i?+2W-8lT0_wKS=?<3mM57`n*3*4wxit@qo! z=-EwifjPhz27nhhnu2Vk2di?cz}(dVKUcUdwvH4@!D$p)tk~1hLRMZ~_+g$}c5kh( zJs5{%GuttRAIC;&XPBM}KVa4p;s%~;kpXd%iEIHG-U6v=NY0rvvO~q=-wDs>Cfn8D zCg4M|&sPV^Pp%)PXo;8crr0Sj5aqt;Wg-tJPheN#5a&Ws6HX|?a`Ww@Rf120gDBSt ziIpW{o?N-x0r}tnWLHogz#@7^7G?!Z5lShtmOVg#CYBw-&6%sc)TlMs|1BTri7%z* zBPut2@s}Myr4cBahx^{#*@ z^*8atzw7TXna@hetMwV9n^>!#@{U-oY})_+8o2y3_M_}|_&}w|(FzG^K~6WmzuvVK z4J{c>2BPhcdoA~#4ymGSLCyHC_O6!i^-BY;#a)PRRm4Q|j)^53#Q|DssnQdyyEE2E zhre=zY)&Z)iNB0n|B|Lp>{Qo^>^*{`)>3iR%<=#+lJMS0qzSD18OL2kjxx`7#ms`8OaNW0nK5=Bh;8BrMGh*b+25Tdg}$Yxeq2<2M6!w|$4!|#CuyFNYc>mD7eR%gYcsKp=zk~OOs|LZ_ z@bBOqfM3Bo@2)}k9sMcrejnc&{=fec-c?Txg7-$^H2*L7Wv9{b$~yf`?leg*H6+XumW;uG7)?>(ah z@1j-z9e#%ohWF37Og|Ie0r)Ki-m<~)-unCP!}|%&{7(PHr~W&5Pwp9n-~Im`yaV`G z@J_#N5Ptvp`1av#Gkm$-0&T{%kCO^r!H7DrM7e@-=pqlHHN7% zd(9wwqp{fDpe+wCRW)?S^zCKlfIJzDU|4@R#%lS8E`w|N1D$QB|4Zgtvp>(<8oDX2 zpx>a;Qp~!xE}GGDs_Zw6iAi`(dM53F#b8la%nvet$2MSXL+_**DH$J5stvBu;EMer z3#18~hb>mvugBm0e_ecQU>K#tm;bJyNrt#h>IEH`1MG|A-FO{y=6tLmXb=-3_E#kV zS71$MIS5b7Lx%KDE>(OUF%m~;UN=1dZ9e9<>|;?1LvX@NbUZ_%R8D(svAyVh%6ha( zP_x}!E9EABzheK6z6B$hIvA2XVZ{EKc|cY7Vx)Z**UT@i{AHKYRa5dXO5S26AMQ#{ z9$i@S7hK5`f|98@Q@aOL#Q_!R)@{yGt!(?S;P}-xRnbOS5n3S^q;B;2E$a1Xke=G-iIvjeUfOMDw zobLn!s3S9*(SPp{OZMWzf@EPO`*Dzr;_#yMx@5OqS&(c;CHp~;%!JIpiDdp=-)P>WA-Y^-wZMHbTRXE6(=-?a3Rn1&SVo;_D^240FsaI0v)=t9jl$f-!0daUS)g{{kjA%YX!rh^U^Q`1!QdU35$d3pi4jbVOrhe$^P3-`{A z*6|V8;0ccD=w|W{9A&TdlHK@Z{+DT4My{FfN!pnZifYAHd7u(ZM>M&jN1k_^QZ~Tk zB(q^rlZxe$Vh;$4)jFxD)>D;RteclU3Q_P&GxJOoy8V6Gf5d;CP`FO$H&65%;5~x?!A8CZMyEwscM32)9c=xSeH4bn7d6b+$o+pv>3d-IcZF0-_Mh=-Bd&4 zMq^SXpNqvIJsvafL{^h?pCT9<@6h-tahDGY(+qSx8{)PKZ~4i-3rC8DUi#tr>X=1! zygfA;dwFZsza>oY_Cy^*$_`3)Ii{UgFngZJtb<3rf4xnMZ?mPd+A+dgyt9#(V=cW^ zdW0u*K#$J}HozttE;5lh_b6TQ?m#s`@J$pa@CqkX{+UF-IYC%&t2$zdc=kGRLB7-R zAk0u+^+I`rzbx!u0Fk%Y6x7%EgQ?Pc(^UB@z?XaG zznAY7me3YHa)Xt>#xGBUA!XVHjSfU(?Y{X`aVuvD*T-wdmquF-)~hHfoK*|aT4JtB zTnw|dyajmaEn3z@Tbix!;|C;T8x9d2PmFgQU~)|iTp>r`0aeM^rxi-uhh5Or!W!Rv zDL^n>p%tk*u|i#!3ulB#RqFkS+qFwac^|(eG{iF(0MNIbJkJ@cQ2uXx<7IFc^@B>Qs&}#~bGjATnR9i2$=GLpqq<*#wJR zSS(j~uVD&VkZ%KgK}Pk+vZ`AHtXpj5^t<&2Q`#<&#kN)69)kNH;jdk4H}di)A+@%X zX#Qb&U=Vdt$j&3u$*YiXoJ0_EOn*AsDPfEq$HB9g)b#ef75oS5>I0y%gh8M~x|U$d z_Gq)60ii<%(*$o5xA38|+IXl{Z;`r@^{?wo1>j1(cSyS9PtM}6Fa&^%s-lKtU*5{4%$rF;6kVlErjX?4RAqq z;hTcWuC$THylylZ>xA7XC>CDc8F%Q__l=I1?wr_-# ziK)9XxMuO>4c<=O?5QFqq!e|U4FQHVwxT7Yc%5dd1W_)TTrdD$WpZDsvolOI6y&Vk2KGcbe1gw?}z4KjFr(GDT z3U)2>=Blcfl`3G(f zzbLr5de?kW%H;L z$8expwlm)qRAkjU1spVzB8?WSGm{W)RG_fuZN&^DsJ5!+wF?$<7y&@hhBF}yU_z;8 zUn%>HHb%78Q9|v+TwSGLYIjvZH|W&%LF+*`;s!>!eU>~*epj)1I}MZ?9R$SF;`En4 z9J0)yscl}?*qcr8vRmqWlpT_e+YL(bLv~noNP2@YnW?DDw>C!(MqA#a^dYJEfRV`& zyshAkJ@vJ%4VByLaD_?Ixl?6JP1J?$kI~X7_ z&y@`PZR?9-Q5j~tBGXJXH$FHmX){& zX~{v9qOl-W2e->U0Me|h(Z}m5w{Kn&y{5gjxpJNX;SY1g1nAY0#a4!-IacqCU`@OItxPHotb%R;XAqcGzY@Ue}f^`z28RDJd(gs1lxm?-xlGe9h`Z{w+VxEKJz^#os;Easks z+!gT@hRR+3$@&bhTK8osGC+4@7!l%WU#v7et8qyL!Xqw*{RRmM*~|Xv9^TmxQgtS> zZ#rc3Mk(Uy3@OK5Gpwk!Ji{;ktDyKWSN!#RLd8XA?|lu#Oyt5I2`sf0dFwN?C-u-N zp<)QdB5&9>{F$g!*iR!sz14HOJ(-}F?PYG|CMh88IG z7t#2~%V?;-8kz^GytJ$8^_xOf^%uP!;ZK`){{tw`4wQ#)N5nJ!uq<~c-Gme*jE^K* zU(?No4T8zjQkyX1<3nU&-*U88bE=`xmMXimgIB#kt{ABS#A1Ckp>y41M4x(Judw#l z@ho4dhQ>Y}2|Yjt)))928svd}uFbcH?IJ=!zN>O>sr{oD(W)((h&!eVxa3HY>PI@k57AH!!&=)LB zAGD01UGJw=)Hin@S06$t=teSjuyS4YCQer9Q_lG=)|nM=g&@-I18+k?bdcbMz~y$- zop&L`%AR73+im=xE-hZTWJj@y>DIN>B}D503A_Q(8AHgaQ;p1vju(?2$U}@YsP~R_ z!2CEV1Wc)bnU3lZ9I%(vw9oaW-WgIUx2cp`LlZjfhrcVHb|Qz$Yvbv;cA6k#D5i_oBQ+*34FhqdMX zjjY+>nlWT{A4BNzthg4+PxuCve$+SR+2>`se|aYjP4D3V={6p(7YcjCchdHze@pz;paTH7m&li58s^)gCXxH<{91Dyoq-8P|GwrSSFol&DUHo!sx4+e41F+A*1nxMmiAgxx$eiV5J*y7Xz46SyJq?8?ETQrWuH zyQ5NT>Qb+EwjvK(dg-mEzB=0S88jJ{zI+67a#YOuHIh$x4KNCe0yASw~LtWM6g~O7&1J(Blf08+9w%pwwN2C`HYT)dR2^v zrPewm<*V%V={f2MID_MG6vjE_t@#bIE*2!MCsc0bH$nAaz;EJ80$RAkh(U}uOv8FB zm~%%F6n7(7mvf_9PR7ADrL`$MH`@u4>??Gn%{zxK#?z8na#7YSzx0?kTL-uN*7j%7 zhi}*y&~&ab$NA!Q%QOiSL<|8pOQPumOcP*XmjYaocQ7#tsxIDDM{Y&ebDS0RlfW|K zcPQukUb{3qm^XuI9WYN2*O^-;yA1%3<}9IK`M>gZ>V19xmuoLNM`sTIX(U&~O(`FV zeCZpV@d+QZGP)fnmQ;=sZAi@a)l*;Z{t-Tv8qHgQ@2v;kLNMGanG+%;gkWORv?Kw7 zFwD#2oC1&l3CoGSqb7BQZ;ovq0-%-G~r-N_bX`vbozTfx_ zkFyG+4!$L)hO!xadltYqk)pu2G_3m#K9vWGN*}&j!8ca$`R%`TNvLAiK1*g)wVnmi zLTim0Bna_kwwCtNMVxxLIf5=P@Vm%i^T&U|%E)`HrC|M1EEd=P7e*oq$04NYyJDJa zJV?D1!$%i=-q+auH^Y&ylo&$^+g=hZQ2K_N0R%j316Uw)kE$~ z30J6)RjTr=!r@VQR;lpr1EKWzA3ad9T38jxMv7*K<2_FaVa!NzpP#M5vi*G{t8Hv} z0ozES@>Dj^C&goB;IthsaP5;)m1mU!Ay%pIHgxc9+ylN{{f4Wo;rE?&^81s!!?$4p zd@%>#+@?@AgHPpwVt@}{f5BHF`26;-Xz5;JS8(3u4ZR5y;2VU5&k+!RfQauFgS(Wy z%*|zqN1G}GYQflp@O3+DDtkSq*L47ouZK|-(&_5(`@rXW9AAv#IRs6u(tb5;sRWnUjS#uI2c*{gyGm!vyOLn?#gnJDLwh`V# z_KnHDI(My~edR@Bu^>B|kMnyhyKoKI)dIUVd#YIj)<8?o2434t4HTBBvJ&R(?m-wq zW@h8MDf>^RAv9gZp;ZTJbj6A|GI{c}c%~#FXzJ6Wn)>R&u?i24-1MT{+vg9CS{2GL zAUj*822aop5@e_G+LPb^moEzigZI?aimu-NI)>j2o6B{RM*pqQONyW#P4>?3m275{Zi>U-U95MT1?UUkLX)ZDoN*BWdvW{2?!1wx5IF<9%=KH8gcgzA1YsXfHZ*TLE5RUx|-7b%F`>ch<15pJH5EpJ1$dNy&2V zH?r7&A3OwK6;_ZFMe{$if(tzTFc;mZ4(yHePkWy}w5?6+nQnBNH6+=fMs0WveN4kE zA4s;tmli@?SF?0X>J4t`cpV1QB_`bO5--q1avOsuP<~iUF{jsoe@_1OQKv} zqrc_Lzle@&=QCH>RoLe(^!M1+e0qT`6QE9sjeRff!!K9!z$dH)jjG%lIP9TH4`}4A zcd`sEzam5QayfWuGE#SOIlm_^A#LT9h_Vf{8@h*m5swb#8i(<$Wi(W7-Fm|CUfgZL z@(SN~eCCVj3BXkz+0RNJx17MW-k1JG9)`-+y2@>+rgCTP8sF*koftCHq@RZli*sTX zY&IaiaKpddF)7yPZ+FDM$(pu^7jxV0_v?3^?v;F|y7j2aVetij@fjfgO-|RBF8O{v z&i;x%{=!+$-#`bJWcz0NrdHvae{F{sG6z@F_RjH4-^b&8+F?aztUm0bNSUo|r~*(a zmY-pzTo2y*HcJi$!IX`y|LWKS7nOt8PnV-3dJ|X)hOEDb+UK2@PtNHxpN`Y#{=MDj zRTt)lKd<+#cvprclv`=I`4TFw5{@q*Kqp?T@6mD&FV!Wk&M?K zGn+90kSu@fk>#p_EO18lQ+X#i!Sj$%ZDcC)&Me64y-wU>_Ea~gC>&o6h2z2dgjgPG zY#$q{5&Rc<{i%^2GhDuiZj40lPi^*I<=!JcD0QKN@Nbd#7Jt3XnBj(od|dEMMr{?y z4_3td_|Y{K{H6F&Xv+c&=^PAL0h_YlXsr|mXw^-~`e8=cPKuPgP<>)a^%b_T(8lRviXr;Gkw z_|6%;>yFp`FZh0m4%yAq1^DixYu=WC_SBogI;eU%o_sgT{=$RL+6WV(->+JaDgnPg zluv#&o~iF7KKZoCWncKilhmylzp=#P0^t%x;}x-^QqZKHf32Y{DorsmfyA zy5oJNL;3HB28^?l&+vaDFKyoP+2H?6r^>qUA^dZ+dD#9CCYg(X`saMqJ6pq>Ne#JY zh0wzClPS*>)60$jDRk>_8^~m;Du;}%%UCuU3qsp_D7oM(gQ~6=)%Lu_OeTxVN7TER*eD4)#Cy$fok%p?2-D znoiI~$efwje&FQdu7YCs!HV5Zf^@5QZD)L6@?Vy}lK4P<&8IdL_;%Je^$pU#zD6)n)! zN5g$EVJ!Mt`=G24tqUwUO@Up>SSi*zzFCD6#>Hh&g zovXaZIe6Lo9OQUI{rnD_gW1=t(!P5~zKEze3Z`RR_*S(SpBv<&qj4bt`ueE8fZao{4-ts(XRBUw{E8>z>0M>AQD<(|t3- z^&8eUC%bnPt=pZ`4jB~Se_6b z5?Yn8sS&Y&(+(p6{dO&N_CUh<_|tcn!VsYC0~q;FqT3Z`7;t@8F{7B z9Ff{oEn4y~-Vr&og9U6(qg)ob;-7Mm23J%QC(Zmn!#77vd^7JlZt-#+Vrp>p!}B=@akne0T; z0ed^eY`ka(rHapB#_dEv>rt_{SozbSI~A$*2ID_Hl2ghvk<@)W=+fW;M;w2kw^ZDsqnT}M`6=s~fBRg1aMRBx&kg>|6 zdbel}W^$Y-7V}`3X?-}`oC=AkrSwO7;=(H?p@z4;?=GfykcNM`uZ^8bDrMA{mvT@8 zGMx?9l;{%TW~$g_VwV%``sO| z_c`_K#%udFbPePlw#d8|0L8rVM>3MbvBEW{@i{0=0E7bqkD`9uNk75ur%r0e? zRNChfu|Zyi>`V2zMXv63=sSzsDbU~f!I+G_W%Lk1S*w(-(;`Qyc3)fR)4 zikjpq^3FNcM$clJl1D%rptPjz{7Ts5)_q{U0t+V5#0y44VsL?y&HqfixWR$t)+)x?9 z#n?ainkX_LNuKv$84y%}@90c1XCcnJGNcc$ZtHXr(>!X+?d9!M+LpdvGlS$0y&C#9 z{h;;xXv-7&5WDhy8-Yn)#N(*28OUOLuHad7dCB|g)~5Mn(c|#e8Et+JM#PM{JZqKA z$>8+ma*Jh->r7eHw=QtnII%#~Dr(RkdlwLpiKP53+uj6P=wgj{W>L^O`+w(=lvyMY z1X_hx$%pK@4sUbM>5jJ#UlHEcHj!tA!&|^%UFea$tMh5-X0W#7>k{*94-lLXW%2p6 zEFMz3h}DUv;k&gdmqmkhj+hggtmERYEX?bbQ}O92$;Dl9M4Q96egh>>(bUp zUCpu!ch~25YQA#d(S0Ks`;97U++a+q-y7MB&9EWVf2B9;7UAr5|8$9?kdK+jkyD() zvh8T*b5q9#sOJ^lhZW8OGK&N~dKCD@UKkfoT`d@rv9JE2hK9sbN$W8g;&@TmGvW|| z9aHb$`g1Aqg1u><8_zSb6Au&4mH~_R<;~)ti_6*0;OQ~-S=LOkOk}uaf`*^v5gQPo z`9Z@;tKo!bL13}Hku@(xlXrqnoRcfQjc4{<;g0<{)Sx^U(Xc{pNU-UMLfpqJo0o2VlE%pdcx@sG*MT1WtWV2xvqAO5N8I^M zUi7AbQ_`)*9cg0?i0pcD0Wv`z(3+Pn+?z820@~sYcsUtsT5Gh8r}lk0`O1y; znDw*VyNhL7D4ktv3EJ(LiJafynmr(p5#>Bg~h2SdK||iXqSEHkLu*&R?$7$a*heA zUmW8$rWxqzxgyJ$8XI)Zma?tR>(!;+^b-$pYTk@qF^g8lWX5;au_ZLg zNvuVOrB7J(EeFux%G3cg&%Q0<9X+;V)GFgdYO%pgnAI$WIgLrVaZcoYRdcUo>>A6@ zeys83xuk{(bgpC6Jf&rH=zKPVyDs%cmOC>$8Fet+9i(VO*IlACq|%IrjV@z-A@%GO z$9i!cSX}lRpOdj&)JU{tbK1AyA&_5>;$EmSc>IE*XH8YnI!1qbjuS@X;nRl={&bUZ zZq1h${tlll412vVj8-ONEB~%O|JrEEIV&swU&dBwScx^frxYOYIM7{lejvU~;u~`} zh`CuU@U|z4SmM+8iYw^bxf0Z7`ti(S^~pOzO})>SIdH$+8^s#}>}FZZ z!jrcfAF{97aC@UJ^@8{E?V`-M;|!Ej$c%(lB`EFJ@Q#6b|HJg97VeF5%=G zLjyQ;6H!ADdSu2HmayK zZgjCla%X%<4b=MT>;6*bix+6{Mt-W*nAQzt{lC{^deD3NVNLF6`$L+%K0yE zYTU9!?VKWP0*^ec#8l)$)tZS+4JtpZL6r-Lqz+uOak1s^!TO81R(GAC5xP4QWm7+5 zD1{E_kJW?Bhu%s!9}f+T>z1nVtd)fy?nez zDgE3_jlF#Rs%2}iY#uKmLZ|vE@MPG2!oJ|J$+=kf>3^#snUU&Ib`;u)xNdhj;et}- zco7BN=Do&5Ju81`p?rzX#N#9SpoTQzg}>tr05^Rx)O19y95t{=LC?$!zva@FX6A+I zvQO;#ma-@4fY)a-QPUrw0lXpl!g4Qrog*)GvV|#;ATbsBj16br z{_Wb*m|8*$k1prWF8lx7>HYTi$}UnxW*sL;|m$afSxjsmtRvOBT{-QFPRD;_NL>XUIw%g3S^5RQpeU5=iv*uPuTbixVqA zfhx(^JdK6vCoD6Z6)%hQ1$79GvRC(&0H~9=>A%XJVNu4+FtyGg?ze;k-kP3q7k6_M zR;0<{wTeYd@dD+<(={tEeF;C-&(9GK*SIy_zt4Hy5J`kTP-8K{wN^7sa|U9f*69r=8u#(UYj`q`;0 z$4||Y%Pca)?aKgT{k(pEx5ke-FVwh6uzfzX(_s2Zen?pS?tRO6Sa@j-^Q6ezgpA%H zuA0Zg!2%Z3)qvNi%{%u3`cQEHNjLb9aO163<86e-+la35W-)|Ze*JgJ%uK}eh9J6# zH4=0}FZE9<1qnD?n;}GJ6jPHYoODLsm8kxUaGZ|(ezoL>lGAf68L?EQb6Amj$P(k= zBUpvi_(HakG1bHrw8$Hj(nkhIy6gzmLC$JT@)@gq{AQJSveetGTTyMFNY7CP8$3hA zBfARqh5w4Qx1uOP#iyMqfEhW-Sk=pL9%t4FY}bX6_04cux%<9I-&68jAI>>Vs~a}b zwXID{UC2HA^3#z8yGw2T1Ne#>rvrICErGDx_-tSrjFbC-H5NhkcOSh?&-tk{5xZ`s z3K?^ZK#A7MX}S3>&ZP0yX53f@#%8OWrX7lFX(9K5d&?};n|B9`xVb0dnT2ZIyH-oO zQ{@4$lLeQ1&H7NI4^~CyqI&OqecIGMjUt5G%pb}EdMiQ?(6yi`(O#jCJPgo-x9DeL z#QkNdK4Ar{k?8&SjQH;B^QfAjrylYhXRF2wY$B^c_Ddo*?ho>KxAdk>WI49Avu0q# ze!g#JJieKvCg6%A=cJHoZR2VAQeeSIBV=K~NHB!$Ij}w$&UZmFt45Q=?75da$MUHa z<2os;39Oftdq@63VS7jKH&CwZi_>L?>FIfQG4AH(ZIAI~kt)x7+Z*>QoYPeOPyT|C zA{96C4>xvcv3EFTdhS8Yi;Q8x0jg=2^<|qELAxB+YO=3G3<=f05cdA4^G|;i4uFtH z$y@Ue@qqQ8v7FIcCbIu-Au%L*>^sJ8ZK@Ps#jtFHl z_*5P!g0T0&f^P@G=eK|1iJ=nabl<0447>*pgKRAf+=Xmg?_y;{{EHQ9);oU!C-pZk z4#r81O6&(wwaVc=obk;(=|IlBod%CW=#I!-6ez>)vY==y@3V@%^RL0-!9rBy(?JdA zQG++0&%uWitx7eW)OzogX9MMbT<_hh#Ne&%lJ8)nKGWK%4He(5cVSIxNp#U?eNoOw z)vRpXI<;JGzBmkiwW#Lrxzg!8QV%Adl+J~UUTg!{sew&9j0o=_{Nk`t`PCt8ZZ9@E zM}(nC20U2V%8_ZuJww@S$|L#-Fw2#7I_-x&y638JxsI}2OUdP(2$y?fjz3XP2K@s-nXQ4jcr_zjz=^ImpXYS|^! zu)+7e5~$z7H`Kv5D;%b1@Tokx`uQ6|N(5h2@cHfEe@Cd|-G!eaPmy|pgYLZWwBL-T zq~ENg^d5T4L~3^rRbrGr!8PkB-ASY5+PFuqJzXwG={E#g14Q;t(lSB;rP0c0#5|>u zF(FFNf7z-ph$1mc|4m4t^A6UOL(x7vhhQ~K&iAu9OumcQ0NDCNL)i?IDol8l45)O&&g_VO1axX{jm`H{r6g zgo`KPGPLHI#tJ7~DgxnxYHihw7t!L2v!d08;bq~a(; z6}wz+pZ1;V<^J%Cx1*~y5%#kfmJeT~UXDGJUT)VJ^peih779ytyZ4PI_dv|~%TXAv zWi7|b+s7PN1}Q9f6wfTj_y(O|*J3~v@cWcg*46$7jl*JYY{aJZUzo!rq>naE=gI-tDwPZ4(pp3it@ftD@AuGL=63;=xD+XOhXzsV0A zAK-5ACLO#;(6ccBvG@5Ci3g2bMk8|2Y!&W+O*tsWd0s2J_n;$Tvp5oyvGbo(2XF!; zY(+&40k4~4`|#ofn5~81553b*1=tAy+YLSf<%Q1)f^VGQ8%Kr`f7+2hmnM2;z49^E zwXXL0aDNIn3GYBUvdL21HIe1J4$L3@vVdpox!W#x7-P~atz|EWpn5(V6@B=? zlE6$`k%;xZL6H+1b{^QTvuqEVU`A+DZ3GXb=YZIO&jik?6b9K#3-#tp8%BD0dT*#R!E9ZS7IA&n?@5?hMi1Z=7aalTYFRyfS zVDek0mt_xCtJgT7HaZauy3f%oA26~`CnvK(6ISWS={pKdWykR24v5HY6;JQGDtTGS zdVk(oB#(~%hT|2_=9scE(b2C9Ycm(CQCJaew!|$_%mg&@ z7Wv{r#U01n{QSk>{c62~kXpq)R^*;|dIvSf#U!ks!seSe=_kmE4=gD=Fd-((B?fp0d_t7r=Ig?zKdVS ziC^o*uk{7|+SY03CmF+m?%H%&qFr%T?nGYT-D4MFp6)(6Uc7q@sp+!QT%KmlM>--$ z@TPyF&x7aF90Y>8%%VFYZ&F*i z!y)Nxl=0oDlow~{i3WB?h8q#I0K&3SiMXjaFrn@&q$u&&1MS9ruEItOuOl%Ro z=9%WzjR%G-OmuK<+M;DLlRHz7SPZ}q>xuzTza~ol)Wc%qxEv%rv7f4A#=u5Z?oQgx z-O8a6Q{jd-PJrrTs>jBRJS_kk2=D>k#+)Z4Jsu=mw;UINN>xy-!2yTXfK!dcXE%8ZZ(vT(Qk9v1hFAP_Q}6!-n|{Yo6{ z+_2~3|6 zG?IJB+gnu=f0O^D5Ruq{AySyt{-=jTiU&@B6u)?X>6DS+qFl0|RI;En5&QL%3|>xS zjqPO*n}XOPFTTb>&Vmse6PHD{B(2z6&3Z!a9d9fx%-|@?;9oMnwqU zbQYYV(aUBcwB-kG*0JHT8>O7+)_yn0GLifUxZ7JXy_hwS559FMW5O24tICkwMx&i| zeF=Oab<<;=v-T>3lsk^5z0SzKynEYUXlbQE+L@HHNIMqd%vW0hCOJkr zZy%Xka8{cRPh){(KIM|JRiZ#6J7wDLG2+Y`qqZIt6lEWfKtS$* z!i(y$g%VcJ^6a(x&h4vV1JrnK{|A^a-7p#KyvjRS*5ARWM$1u#ox!|&8%(jZkE;B% zF#)A;AxH8;`)Y7T4cFRYj;|nXW#Y~I#n`VLM>pAq>xZ$flm9qh>Qor%KiFr!zJn+G z`Zn7bMsI4RI6y`htY<0*RoQ=UgO|0bg-0sJbZ@!>vv|-ZU3Tcg!9|_Vr^>eDV=}hc zV&kJ0kqv}SWMwWQL=ZPKL_hsI?1z)^FpId3Z5aVu)3(4a`66EPPQ$0oy+@j7Z`7<= z6SilJz3p9>P)(7~wug;NjDqOI7`njn4PV0?<$7fe47sthAhBoxYP!& zYF^KQU(}Gzz9g2w{@G4ApvgzEu9C4~(7mYfIPA0vRqFC=9ORhlACCq3#-yVr*HhT&0%rNnxdOZfHqAw9FT62_9y=Dj+c)rG{5J?2MulBH0`tZS?_ z7k6W1H`$)RPl7C$S6FS3@3A8=318_-^O}zaE&GG4yd-fCUErGkew4;^!T$O#eddM+J4ym0nl-=V zLdg>LV|*!YOU7Q&Zcld>JK+3t8^1GWu#<@q_5`V{->lEbj;B`2@I5!VKuV#g0kLFy zAQ@ZuxOff;-YO-KdzravUK=d;-eScTS+6~sX1vHS(b>hitTu!~f z8|ArK$=LC#J=#(&aFJ)iB+EMioVS2<-jD6$xWJnZBZ;k8Vcgmk#8iOM5Hi4LMi5{O zFoHe9iVK<@6nA>t9jshd?xV-7!8v|8@)m3H^ksc+oa7cxP3F{t0(T#r&8li%ZWt*U z4gTFSUwW?0YuVZJyX@>m4^yv&rytM zW=ir5@KP2r{$2KTAP3p5S2)u~aZuMembN_G-_l}VZ!Ll@_m1IncB!dPW>MDtrN8xC z%Kn?d=k+_196FAz8^0AYS0eWKBjBN-ED^g~57B0w>S;#VQW?ZTp(Av1!8q|r^qNE! zznx__kv*Pn)ki4tTQ$Ob#_% zA--Z{da1L*+pMtNYxDLxCcM29hm-($sdAk)m()|d+*@@RR`iS0cyqNS+6@Y{&Vu!M zG7}K)DfRC8hwL+jM}jL6_il>(*Tt6l)Po zDDpPvIlBPjAXWzv;}`N4cJ~)*KY3M`?P|-o2R*EXx|a4SI|5ukhHF1-;Yg~cALT?e z@YAnm$pxNZtT0Q@<|iA=79p*)O(cWS*>~Olerk))>ZJ+LN>7_1bI*I<;w|dApWNh6 zv*=kMfBX$j-jO)kReQNrPG32GhVy5bu2`FnOTgb;#XO<#*6_eie<)FF)3D@{wLFi& z_?rL}pbq~LCnKg0sO5Jm7gS8*d4#r&SSnE$8VE(AljBROb+VZ46Ye+fT z68_L!OxzBgMYvpHWt!Ug>1@)5JP;D>!Q=7r*Ga&!L=Bli_Ya2N@#vBb4c5!&>T3!k ztdgZBQyTEZO67qk49oWkLk`Q`68>NbA6=?h7sLV9)S3*W%3V3?|LjivZP zalOMSb71emf96Mr8juZ)JSCeZo0)0O9I?sPAc zU_(`csti?~k#im#3>D~J1@R{)G{iyt^X|i!O^PWK$>B`dcjS%F5|`WcIb^h<${d-! z>=H=%_O_zEE+l&uhk~;;g*XE_jD)jcTPBBGT?GVKdcC8M6NjC8gUE^~v8J=sV)BP# zPDgE7(^$f!>_BuJF{0;^z;T^8GUL&Q_Y2l7Hba&EsEY?O{r}BR=St1JqPhEIJ|gJV zSd!&$CS#ihGGR0);Tt>UT70hRf8qm!#Z|p>YpCu4SKZxR)n$)^4Z6vT=uC;{LYX1d zF>GW@o2Oi4{lhoGSmhgut>XA}SzlUA87aHCh=6_=gjop>-0}g=lM5$Fwlxm)kM-3Q z5sT&yzI6#4l=LRX@T6?;YniHB^J+H~Mv9d{!{FUW&5$em7(^ywpYXS+Q6|)@!nmrv zKkiJZ3Ma=RE0l!{F9sQYHwH`UFMPS+;*e>$BhYx&x5_l!u@0&$(A`E#SIRu&-+gejY>P-ZfDnN@b zgmWX81wem&zY0hGKvhN>co%F)iv4)9X48?QgPbSe4eDZHQuYZ_9U*}_!gmO!?B>}!vHqfBSx)?5~b8gY-4MV}`OLSJ+{m z)6N$wpDBCTGGhR=(w0?|dtzDSk9;kb=lbq^&d4mw3BV^RXC`uG@ctmI$@`hX`-wE0 zo8^5o2Aq6hIO)bO`@8W~A(4Swf5y!>Uy+gK7Z94Bu?av z0X`-_IM8*W99>wAMRBwx%n`OUJPzWuGZN>oH}-Tx^w6MW8XBncRuawHv?MMVQ{ZK# zj~7>IN0Sot&$W@#ptpSYOwc#0qQL(rz6;i)B9&W*hSx?E^;X?zEH|bylpqVjTi_BN z8Xii(A5-MrN2q8NeYMrg62eh&cu#OQ{C}pt71%^zv0^hHi?<%&aDlXH zk2e3CCJoVTm>VUQN5d3B#_ZZq8&CEB*RQ~A*(dy^qQB`!jJ>C^p9Uq&cS&M_PdZ2a z1wtHz8~`j*7$cgWZ`?y?B1T*OMM7(=#gRCR<_q)CioM^40o_-Zry}eusJ5T@8qq|z7;DWH{*W}8=>#fGE!wh45 zG0!DDy=RCoY%}^SmoPXSGGwbs=aSIoO*{yOkqa3WxZm}Li;Wv*60SoIkcPjYfs zw58QD%$cXp?#mSW(*HMNGo1s1SGp+O|4m+N`mf|~G>{}`ZCx7B4 z9eMUnJdw+5A}{hW+A>#Mn~t2PrWumgwiDGcKHW5%id)(*+&`XfnrN79Z`{Tt(bJb$ z9}f#aeUK2w5U8T+3KbB9xxch|pV&?mXWOvGNniQ}MJHR)0&35=icYG&}Ws9>Rahz zW(O5iZzLbSI$IXXQ{;X3eV9oBdof&V1j#;}fBJ)QGA)ySBhTJ$@SEMiRyaZEHhu_C z*Z9E()Kmn0CVxgrK7Ih!pD4D|c5ib%rLQurQS(ByWp@=tk5%NIOf9n@cVN-(cB1H{ zWHef#UK)`{vy@#Ay`&b?DVbjim)17_k=-@c*T>~6@1e1L&&t)uqi|jVz1iPtzH}O1 zd)Q-CA|!iiXu?ZBM(Q&8^t*aaudvfWW``m;_Vq*AdMn#zel~1AvW;Oryq0PIj7M^8cKQyWB#;@4C;@66G+FzPnr=3|- z6R&PK3&u26t#jPb#&9N_(CJ+-&S)?WDyc+QlEh5J_&Q@Yk|Af)7%Oc*|6BM9SwSC% zqxMX9t+>izXa7)_%$5BJ3Ecn2nUvYRXx1Nw-TL#{FZYN2%~6|aXv!^5qi=>Z402{t zQJ|bpXBHv%gD$(d^gQo|amo(XosC)6%O)9^gH8U{tMa^_c$p*hJib*I@tCLl67-sk_eJ8|igJ ze|GRs(%SWcMXIZDh*xC0XEoY_yXDT^huK{hKXo}?ywh&t3a`J&v$Xfqq93K$3U9or z6@2G;?mVD8I|W{fXD+GsE+7cNMdf4`wbP)L@lN1tJhe3YG3fPniIL?7hv**s$DDJX zyT6xBFghP{tt#REUN;ilZ%8IKS1u<*_Af}Vk*Sr#SC9PWvy?j&lCuhDlT>q!U5XKH zE&E=oa_qv+)X!5NxrS@aZ>*dC6JKe1se)@XN zmDiBXubfzhRQ6uwrqQ{4R~*t*g@aCN)nTO;nS}j3Ci!Ep=&cA%?|_R`wX@-)EjB5l zu7rvvzwb4@BDi2Xc?k!^pTwyt*x6rWDn4Bb#6{D0krBL$C@?9G!++|S)GKxA`wa)S zvi-KouOugtD+h`u>BrkuH+4Lhd|Dms)%axMY3Kj{lfeftKrH6_8qp!xU?-*|GW;tN z-&2-gpKDbK4Nj7)X$oH(H&Z%2Tq*~k>w&Xes0!A$z@26TC7xnj9z4a>%_Z)VY|N}T zR#Wg0Ic=do2RO}@9u2k5uKdi}^QqqS>{?!za$VxI2uhz7$@un>GQbBa`iePiH1}TVfNj z{!w;3-xoq2ghKygdA5liSIY$Df47HB=zO_o%hkAdnKxW-Go8zLq4K-?I0L=qbl%gE zZ8k)_MK{!f40fq!{mYl20XKh z_hAq*QoEt7>;$V4Ewy-e2d{nCG~Tvvim{99DaWAPSzCd{$N`pR9WHA!*MaZ0?|*pE zXnMA_pi{qVb-w!uJBZ}3b&5J)k&KnhH8i|MC(#|r#XfM)8CsHV+SjgWpPk-vr~B-t zefH%l`w}^010R1=c~3{)NEnZRsxKW)yN)2!f3z| zWjos|!GI9;fc2GxVpuXmqfzZK^S)~uE$ew_5N=I(|y@Fk%&CfEMPe%4qZ9@&jZd8`*ajR%SavE!CM^v=S_U zlnP)-Eb?7B--~d`*rT*XV;p|9P?-YPir09IfRxJ-AxrELu9rs;E-X8E7ayxd1+1D( z*>&y{^_;DGxU7TC==DX>=J{@%%u>40xPG-8#1Gns{9w!v;@|T<7%x}x><{8!2j%ZJ z(&x)Xn|DzIs`+1a4*q)KqD99;h_>u&+}VH0 zG_9I$V(yYne1=sk*01LCTy1$R7H#<}44aHyzMgUTSYFcoPoYB1P4~37aqjIpqF}iQ zRP3GZ|5YzYK$dIuvBlT~9V$yk`*72H^rK8-v15wn0mfhQ&wL{Mk|CdDM>P2wUlG-{ zTASx83>bRQcOiy;5QgSP0*1161)0c(-`087EiL_Lf?a|K!i^dRL65ud{oU4#@& z;AZ>c$>8S^5a#?B_wdAr+k`>o8%$h=&%e3=!a=tV-n{@2G)A)cz`A;|t6r!k&yrhB z6poE0n=9`T4Kih4nrKDQ9I>+#W%eCobHr8jx$~ov8~Vg|ADeET_MVX!CUhvy*B@pcF1jZKhyYGmNX@4ZYEYQ zhtegmI5@kFk457}DHo~B5p}7Kcb)I)<}l@}+p{Z0 zZ6??=wC<>3$)PsWY%yW4OLxV$IQDxVk9K0fpR2c%ukCS;Jd z+V1P)M@}Mi$D2PRjv$wJ+>VYhf{~eLr87|m?%Zww*t%p7g$%-=>P6f$#skbY$NvB)}R@PDl2%C+rDCSs&E)t3Ogzqb{Be-@%<{ z=<^O0-h77ERH}jF^-Y|>CepPkh_N3yh!BBycl*@s)w^jJo!$(Ct;c+v_2?=4(N|24 zp%@qZ54^x9QOgW2vaA2Rkym<%z#>EP*;0bIHOoT;d%2vqAGPQ1_p4qPK4s<52AcV7 zO5yJRn+lBt2Ma*K>7LRCi4atevA5Mj>8+OT6$vy!UVJqg+l#4DS zaL8$GD^7G2agLEEzV}7Mp4I(L6_$@M! zAJztLm?sLPHdka!h0OZ6=8m>2P^CD}_*s*fG+V)PxpM0tE0~w71=gdu@Ls`6^Z1&* z6kOPARCAsih z+(+cwjC|=iUjb>&oX_|hZHf2|<)x>0G+z?2=_kV|(dJ92%e$JWy?7eMBs+U3U!vD8 z(Q|VLY9ANWFnifScB8&3-gfwEdtAw*=055#3}IXHCRZn(_Gcnj8&59&*7|UQiha#J z!O<4kCGs)+p5JuYrKF34o9*oa_hx&+*iXs%nW*#M@X-Y$5sT!9;x}#^IKiVW4?{08 zJFt{`&BQc{w0@j-h%t)2*0oB5d-Lv#TB}!nqb2U?UWRZo|8^rxcjGrc(`|t@;TT9P zIP^qc5H}u=7sJ>p%+#-{6imHq7gK9YJO%G*>pw8f{SDN6yn)5`uWhltN6t&h={+MoDTuq*bC^;eHT*GG z)}p=T$PQ5b6sVQK8tmc#-`;{##EXnMWwsczVcB=h=vYW(Fvrsd0m)fnMQH1*nVO+BW6N~H)3`sobtlvRl8i!hkXy*kQttt7jkY#a z-7e^YKBft>IoXAbgKL*$*Xj`n>bpz2!~g8?RUfB2T|@8tq?5p!(Pposa3c22Z!`{D zrt)Glu4b#Uj`-&?9n9;1F}{cqX7V1jvl-pgk(ve>j3EI1)}sUP83n@u<~ z@V&57+FE#&_Y=flRuWQ5(pEj<7e-266r3le z-f(Ceb#Hm|3N*Xo1yN(ZtkX$fTQZ{-;A8WTx?E*!XZz^2P zrWG?n>m@O&&A*I**$PLWUv7crgu=!!XP@LMHfyTGce)(5T$8@7)GMt&_v{A~?)rGm z+l{|V-_iy&DMBKjR`uLE*(+Z2L-f|AL~5erfIz*gYF^X0hY*RkkC8I5!gURO&uLlu zPA>MMSfdo2BtckdL%}<1@CXqF$FFjxIrWdpd>aPvjpQE=d%}z2|#0s;wlU2=lQq{s?MRuq!NX9vM z8PF5Kp^VLN)vonjB#eH&4V-p6W40TAP0@L?<+6oJWeb(6jf!{*lpGDUsm~d&ZhMMX zOf5amo9(9GZxs_1#9xu2#I4VP(gBIs!Q*YL>W&XJ2c{wYLU_0cm1-=*d7g{ImpwXZ z*-mO(8!9uU<*wT5Ht?IWpkq~oIi|roC!xW>T2RzWS`6#i^e1Us8Jk>8j&T5l0vNih zJv%|^=3)i)mM4C|V)%E`98vP+6Mvve^-pamO#E+3Z9J0{)v13JYRursI*z_M&hq=E zKG9RZUzaU%qQ(*>Uy8kfNT2LsVv#&DB%oEVSAH3M_6V`xYKF}K^H?jUrQ9`qvX0up z*q8G)&Iz(7S|xGr?VQs_eiY1Hep&-byc_#cvzLn-YKFiKqj-|s=|(>m1VujpEU=GV z9DxhB=;cCry6D!`zgrjnpXio}%>2|>R*@}nfVK$-*p*=e;8Eqk0NAV00JxdYosnCW zn2FQ|wcI+873s_UHF@7Cl`$MSgB-aIMR4@>c~QX|ZEawgkx95;{zCNu-uTN+oVWd4 z23mc^W8%C?!3hQ-pS|5&sKN*DhqCn+)yDhTm^hGawp;4{KCB!pctho>EC`M`tqsbY zH=94!J}DLX;Ei%NLAfPO&KLF;r3}9IpF#~AeE(3SfeKo~SG%}_(LLZ>5B{2RULkKKV*4JW z5yR*WWbxUQ?3z+^36HSJ)Vh-9*deg783o3Ej2Yn|h{GP>J&GF7-Qyi1XwbHK9oxkM znoswD=l-L+!Sj|(iTo7jKf|-he}Jdb!SmFh{{RpBfh&8AzeH?+U~;=s+z9D58fOa| ziTV6x)))v=9StOfQ|jID#Q$kf29$^|P!$_ctI0|)IUm~Z{6!cWkif2`DJ2u> zj|bKN+c5ibrZL_QKZMvwB=oirM+Q)MFT!{5=k$Msve_{EQVC>pY`pCimhI}|kPT+T zOy$WH46~m!!b%xIp0!WPFAcLJ9el@qA8Od(yV!5o4YQ#RzPHzgvKf3w7Qok%G5FRN zb%#&ofg%`YzY%;BTlwR+U-D_FVjE@`6P4KJm3$-ba(7~*HmX0# z7RUehA+_o>7;bME&O4L4d$YZ4lo#}W$}!#L&5MU?d}{~EBa#a5Y)siCqeedM=7zqX67=`)^^vDaO; zp_a`~LspJuP4o4`{$H28mKRw_`pCcN#e>AcD;{F)ns+Q}JDA6T89ukCv} zBI!|m0n-&BFR+u3-!ml><}nn%#n*h|J=T7mAW-YM{xHBRGR>$L(=4(l zOq5wT4k*3v_ORy(Jd={+EgLcNE%aRG*ZD-Bv(ICLadbr$xt>$5E8RQij(d;keOKO7 z4V44E4(CVTvn(V%Y$Evywh92+9j)FFiH)Jn{MpQT>Q`?T%8!qL_|xA?c8u7J$_e9_ zQVih}W#M*P%3&PdYS~dcj>4diZ3QFa@#IDIMUBNvJ?#(5eVdm&?xAqNb=3~@mrKz2 zd(S)EZCuL|Pf#&V7P&%Gnm@_kU<2Y*p^U!ODiL@_PEsPd4xef{7fV3lW&iLm)X^k1(7&*h?HD=2ePYje zY6Uw=*9I9nnpBnk*_3G3*b?F~0H>%CBek}=v$d4!y6h3;*bgW8a%>YiB4|Mo^4l;c z!Ru`yu2L^Jd?FJ$>Lfq=dz%(yH?bshfu$ptJzHT+8@WAb;Nf2=v5*qkSB!Tfj|J5? z|3c>3%6z>t*TlKp;dq|1)A$px5&Q#PSa-0+2f@uN{b5<9!Wkkr7=X%=WRql}yg!NJ z@QS9gHlNKzD&O;G7^BBtB7imoa^a)bVD%bR1Ws)2pWU(9{k~T}%WPT82s@#}p z*5|#S=vFQr0LyPd`_Y-Jpxsm~ef7OU6#6F&rr^1Y&#tfhu zOa()JM0Dd(I?Zs<;u4K}oy(FrK~>s8fhJ|@w6rXz3bKH42qyko?#2Wx1k2e7bP@)1 zc+dQ?3l2$`DVOA>3vD}XnJJqcQF9V5)Jk*AGu23yIs_*ZruADj!ueQ!jJr49Z*)Sy z=aka8J;nDg)9>)W_Z{*!dM<$?INj~}8;zv>MWTX#1^hXM>sZ5c`$X)?xLB#5*TRNa zul)t}Fj&sf@ofYD!;Iz#T!3Blcg!sc8y8)RzRun2y+q%#7lnZWfGY715|}@s@_E%@ z)ToJ1iq6=bK_Fa|;}W<>wB?`AN^A89dkjFr>RJB`y8|g>o4U9)P2Y@hIuh;5z`sQ7 zg0A z$Urb>BD0V6FQB!$Sae zrlfL$do&LPb~~uVhn6^%x22u7(Iq}^S=RyI28&k(xcH_oQu94yjD1Ie1)RC1$pB$h+@^CP75w7I}>)18OGne2;_^T*4K#uKUKn!&Krx z5;#c%{zHg_jPt(RN^CU6-upWqB@V5RHb2L^GeqP-pU+$J;u5@GVi}Xmw$E)m@|Y8M z8*w4TzJ5zMP?$j6=;vlOyha0YR4#D@&qwa>1v!kT(P%8yntrpTUd_Dn!2_eg7;GFZ zYWSmSwHN|dt8w|1ZRyc);OUmg{;{*@1V3_1cZ0{|!haZlJ}c#E(6Ct|cGD=y2mCYn z@QKb^q;waHLP=i?qOr@STkmXWnAK%Z2-YbZIwma5Jysx{dg#w3!hN9$kcmuK0tBfg}et-q{%#6cqHi;aNiZAVLgJiSWsQcPTY|YAsSS8ZmIM9v-;oO zV1|abcpJlNg`wQ(P4HM@bak(0Av{YJW+5yM>gu%t8ufP8J+JltMt5!NMUVa|tnHUb zV7!1_FLwlg_jHTYjmcjGle1s4Ba!|i7)R{!a~%WQlP4Bd48IW|G0)zFt$;4DaOld zD?l>&B)$evWf8v>`qhWP)HuHrbtO{++El38a`8AqM9NFG6tRrpz88pDMEC%D2qe@m z4lBww@ahfOfbI?DDLh2!Os(YQ2P;gj|f@GgYH;KjU>l%Okh}sirk%eu(<5n^lm&%CA|jIm`Wzq zvOn-F^XJGUil@fa$J4WI0~X6>10;rcwUz+LyGy+g$0cLmO|()gEsFuwRAJ9{QX|(E z&Z+WW0mEVw+68aR8VQi3JRr%~W3G-%l+i!0hgOiIxV1i-mv?JP8q(9Uhh8-)gUB_u zz`R;0&zPk`kW%lUTb+=g53OE=GBvGh`DxsKVY$`Ne_PdntEf*rb2#BuZAt|}8`D?I zpSJu?tN(wzy$g6%#nu0R0yz?tc!GjP1sgSLsM-cEZK6a^6x$sQ8nG(cw;GFDwAvyh zfC`v!65x0|7?pa(7HzGz+NxC%)M^6M0N%J*MQy!T_vx{Um&!#;{-5ufeUhC--rw(i zf6w#hdC1v&&&--NYpq$cX3fl+q>Iwj)uc>KRm-Ym5VqbYKuN0BqytRZ9a(ZLoR01f zXoSU#w_mI{HkTmkMZcT`;4v zZ1fSynNXFisc{AV8;cyWmgv{B+$AU#nLMom5j|&c$f`tYBL2U04ul9J{Ssbs3I7Qn z`~9v;JYgqC;^m!9pYsZKDt~y`%Rfxn7Lu*aUoa3J>3n~;O778zX-)$Ptz)W-VslH> zf15vCWyXdRt+PP49c8&aB{ombfzJ9UdUk?r9eoH6m# zpCbR~cL|Ky1sWDOx{n9Qv=b*g1u8v!j6p&2(x)MT8@$c0c^%uh@$;QBFOQX6F`xPn z8_jn(so^j%zwQr&lWr(MR_gRr?k||dfSaCKTF-dJMb&R<*x00zY?J>mTNJ(2W&CGT zxitfEkX|q_89HHnfn7Xn5>;3(E;5i=tEBjJz-IIpx=bNM#A|ns#Q#ni zLE`*4bKT4n^qKD7)X#o9S^Vfd|Derfq47SZ92V^#A$-4gI3?Mgx}pR4nwqaNiLE6w ze@OUddqEY>H|T7N;J(D`RRuNKC*9$@7a4{>^@1Q;8r2s*z-#soO1PtU!U83*og_NT zzQgPP`cf!dN)JomU3D5){`Hm2gVl*djo47RFf{T;GP^hhHZmL|Vk8OvhSQ|Lp4VlH zw}edQ9{pweu}^jMrYmVmDVLCHD9>KiRX6~YK-smdyDirCt|lYPQvEHNbu_sOS3WPR zK1`C~5Amt-F(p3GKXH)~Z=>Z2r6p>&+qj;lIl(*8Ky?e=cX-V{0t<$h_D&eC1Z@k>x9_y@U8Cfsv@n4e-d{+A zzs8*@|4p%k1!D1s*5#Z3M)pTySp#E9q~T=eFxAV~rdx!2C*QePh5urTI0;eIKb(yl z-BTp{SEtgs3p$8l;orZ_DgT1(t)@kK(RUha$YJzo-`(Lz)yD$Yf1E=jZT=%);vnsJ zfBfE*N4Xwq=R5qj)VET+Bsj<6&rylBz3cn$@{j)?=HLH+nEz8K@jt<5d7u30mQvdh zZT8FO`4GPO!%1cg++SL+-?aNpRNePOGd6E056$n{{n?e+Bz|$~QXAx$fy7!a6r9u} zr8D%Q@`%{nz4&0$44n`DfKft@gTNr@F$T8p?~H+3Mx!>0RwtHLNE~7dj;2UWYH7PF zYVC@(d{YBW;_4X~zu$0=lX)D*V|D7mF_h6_^Ou0ANj(^sa^t-vD{KmR!=7- z^`^3^+YH~-)EQpts>wi(#}Zd|LuL!Bj+L8p!IZc&rexn3h;;4BdZ{0#^j^EJT<5tw z&{4L|;whUy;76_})JZQ*@bYxp!7LmmOV|B|9I^{UOm^38(hoC4ZmN9nEqnf=p~y=u z_3gPU)=GF&B8#Iv8~J=onQ(=j7C=l>`qsZ0yhWvxRiJX@?3?$FOx>N;ofEOI71U+q z7#Z4K3|O+P5=$e-y%sZi($RyJ3p}FxTCR3cc#^qt6IG|2jc_$!VM3&Np1^Y-$2uuQ zj14Rc6D=rUP7R|Ax>+Wy=oJ?sl8=7X6;d=>tZ{M~$Z_+^Nr2VO$Bz;4#_;%~BHw66 z4;~gt*<;c**}D7ua${7^(xDc|qYx^tZmI@X+gB{3myG2?rx&9%v+>XVp&L73lw(Nd zcbfJ6AH_g>p+Rs5pn)9mx1ZA&bS0o`lgn|LO~d+PO<)j@8Jh#PIPNjlI&qfSCVE3$ zNGf|iB!a42BG}z5d`wRGtWB*}vF(U{8P!?C$*O=77;3L9-Zi;1QV zGGAy}v2tp`)Scb?-)xz&2S+=VY#Qp5F`Wj8l;NM}MRk2uH3!y)=Fx z)iE8vcHytgipz-(ymPZ-tL}hDzG724nJzg)@xgoS1)%)|Xu6srz-$#Bqg>E&@L@76 z2PNYzk(0h5eB44$;Im9e+m8vv`Y|2?`74oDh>M3MfuN&KqT2(zNrp{{gv%)*q`>A^ z#d`3sc=)TX>@Ncwz4v%W$gU45cd1Mx{XyG7Ev$zFzXAep=Ey%Xwj^Gf_P%P`nm1jG zGUe9VVusO@6-`?T8$N8>5^MNC36v2SCG^SX?~WywZSL#eJzOfi*BDPTZN^!W+`04k zd`X$tIj0zVPycu<;ju}N={aRQCaP|Q{z&4V^({H4h;J}A-%Ecl4?ad`ecwxuh$Hr| zO(uh=^4g3NJ*3CH#te3nuEXqj3uTl)z)Ra^f<)E#1+kII*Vxx4WtaF@3}ue>fG!wg zkC0L4Ec^_jP6;l|xOrxB2EMRI>3*Y!%!=ilO4i%ZwYuRDyp8efi+&@KFufE#mjW=L zI-Y&POFu5;{hg`K-Mr3~JI{v}>WKG1{QMJT?L6}-Qm*r5ed)QM#_L}GT;VxM_UG~r z&426|-h3UyYdBt0Aic+yaJ1suRax)0ae*ej<(7pUL5u@|gWS z_N)&1$x1)2&C1sHD|@sntDi`tV&M-j=dmk#xW024Bjxq4`vA*z=ShhX;#|l2HC8|2iu8&I2H*s05 zyP{YVB;HeEYc!Tl3LWcd9dBbj+Q>Zu5xM;>OW;mEs})TA%Ys@Hy?X440Z z4xrgAoL(}=p^f@e(bG?{=p@%ZNhU0g#eAfbF8BklNM#)V z|ABCn``P&5KZSP(GjUJ2;iV7(`Te&eVRV$ZH}N%vyBO8s#U6Oo%Nx1v&tys-mDNvb zdsC8jggAsa4Jjq5z&~}XI!s}a6^-WEkIwQD zj&;ry`ex=XfG`YCzb;siJeNRa9-JwlfwkE`A!hEb8u=KTz$|q5)TUQ|ld4O;$;9ef zThHR6<&vhV>7_=&F{TH*Ppf*JCj_1eK6NJ60#5%7WM@JHjC(CS|52mhc>TbdxnDp# zFGbK4cYh{*+%ig9_T`cNZ?3-OfDmJt|1Bm5mkJ#WZ9Iml%_dscLk&plx$CFnIbu_y za>J~ByosMds((CURDM}Ml`l+rI&-;IKKyw;a5ru1Q0hq6L8C>bP1M24%YZHh7=r%c z7QfaaZ%+IaHr+vf!WS+uINM{1y$#G&Qf4 zj00#D6EgafhO;Xk7a`Uw3i)jlsGr5@i}=)4IElYxAlRUnJiS8Ndom9NJq-i&t2tCN zKd|Y9g%pHxE&Ge83eUF|&3vY4EvaEN@{{cS3Sf|Qz{$=$0CAdeEyf7ouo8Pte9GiXLB{ z)1aw%+!}H7EqIzAGG+W`hUhL@lDX=npoN#bCw(=1#h>WluA!A{uRcPJRV&RPiKlx#YcklCaO0{df@1uF#;(F(yTg;TZu>5Ssi5_q@pl^ddkrwVFnc!dEU zS#5=N!>;UHcv&Z1P^3Q;>fS?yaF+YOxWEmlWQpdfcrrSGAMU?_54M>&s3aME?IE^2 z#3d~0suy?`ZB@TNngw~=3!#Rf`ZBxHh&ByP^(05UiMFSv9(Lv1cxBX02eU>u^RQ18 zDA9voas-^dMT>CBOo(vPf8^5VVy{h zNy(qyBoB5!YK`(qBeNr?T!HuN9fHI~vI=#Oa+K#3o*L*hl`nA7c;z|q#tUHv@m-s$ z9^$g1NaGl6QiiMUZTPl>sk5njxavIK1~sO7Gzs_`UYSE8Xe;aRJ{fV@OQP}H?;0^iycEJ~xDwJNwE6Siqk}6VM&JHDu226?M~~ESqc%MJhM8H# zdC{Zz#PYWeeeID;Z6xZ1_!e|>$tQOOe}j6mcZ604`_vbk`(Ln~IwwdTnbGivvm+t6W!@f^a;?3zJcn40Zci27?sWSi{Twpm zaEu(!_{cWI^(e~9HI4tW>m`##G%PwoBOE?K?%-;3#?|n_eCjIP#U-FeK%k8o+D0ML zbKma))|wn1Js2@&REz&D2V=r87Uub@IoU0W6todPRB0kT%B!&cc+i}eM|iQ=lJ?A2 z*%{pp>v;+(xIVi?COio4lI_P}JnemEAYNqNZS*}5bp3OWw0`smVY9mvtb?8C686YJ zXmk)-MuZ@IM-WDk5v7LJ9K9UetvXMcX;2)yNd}F)G zOH$)4TP)ZEX}FroIh<_dDowUqB@?9}en#Xn|7-_1^Fj!)DTAgX03~IP1ec)2N3e=f z?En5Gt6VwTqRj=ygMg8! zx|vGp5bvR`EZPrIs#>o^2U@)v4`sZfLhX+fm*h$Hc&VeFJ6KxbJ6bktwT+9ZqfYw+ zmUq?7$1;!aB8ol%)Qi0IQ%yJBf^vH$cI|vAmddrUYbWX<$>8gD$EaOh?F8H{h%BR3 z7Q45p>g01lw4pFjH6C~%`6elLH&e?CJf((@xrf0*;b4W-gqHPes;At zalLo(`uOoNFqHM3$2`3O^eaD&U3V|NKT*|as^C|2(R{=}qB21)AN*;Vd1SC+cHE8b zwfwgM*9LF=s;e{lG_U%n4idKq?tfF39v2f@Nu3ZAJ8oU3Ci8@}zjgg3lV8(3qzZN%P@*rMf` zw+wOGNeMgU7m5WI@nZPqg8k*f`}rsQM_x9qqrqtp%^gI2 z$O%Q6YM)?dUa0`gy8NOoYM*px5{e#900L5Aa>V~)Gy5Rv)i|plm-=SJe+M74T3^uz z;^Q{2)3k)~Ut^Ad{o-Y;gXqV+%Ecp~wveMmV&vT5)C=2kMNT~aadnH)W_u&H=E#!7 z{s4(hAGQ4Vg2^;~Klqrd8xfZRv?lEi0tOw@q^Z$%tY2%Tz$E*Mm=-;BpS>Bv3L6c< zA%2-FP_;JoD)65oJVl#dz?kW!7zYrK692Y+d%9=^ zAosVL=)rgXHCO>EFeI4CMF;Stf2yIxP|g%Vd8(o>nh_zoSu45_gH+*gfTf0a9ldXa z$?wAU%(MDByz6&-9huSB*Wh_(7t|1;k@ERTKD+L1)-?`~o%$;G1l);M@|V4aiYpCN zTpxR%&84!hknh}EpCd9K$ zml|N2typjXFf}!wL1S2AdtR*dRF3$Cu_RpFLq{m8+P&x|$&fIEY2?C%aPgZ#kE;qq|%nETYj?1UNq#h=2|~)X8Y7 zz%Goh@GsbiP(5H%gdN-O)2>3cFiS3lAB>$aCHmfC^YG{LPim`Z*1wFgV{oBU??vRmt>zNXIv<{g;Kxc z6;Qksf`t+6Bmcqq5d<-}#VMfBX?PCSH^j&u?0=~|y*w0{wg@V)T`$=9f!s&E%Dwxg zKaxt8P%@_u67pv8x-`WbQtE7#&tZ8Iv-Xh@n zOFw7!^s4{%%e1fW`H`OXp~!D>{`xm|Mi81mbPkOBOWy*9mv+Bx{xMr5B~F<^xT-bZ z6^blwMmu<-e~iC7(BbO{E)55Nug}`;3Yb)3gQc<+R&T>Eu{ZY1s)~st54Kn5F7_rK zRd274xa(q4RYUc9NY&o<^+{Vk@W-;|4PAGeR(jeA;RW@Y1ji~EL#)gY!aQsvaKf=%tTwLc0+Qp<&@p5 zZ0jAsXTqXooV|i+D2#c4f|FVDKLu!=Fu1+dqVK4|M7^tN*dTh=e}K4F)+s-?Byj zeH(&CIAd_HX9SA1-U(#?Clo^5PY#yF%%((`BK`sx<*!z%3S=6T`DmB|eT!Z`~N8jj78M4PnfYn^_9; z$@Nz!M77~@#WcW(AlDws^?=J&-7nV{YAl4umLXdiRr*Je*WdSOM->yYR8t+iR<}48 zS+nM++S=9f)Gd=NWpzVUYOw5z!?-}sQIe$|Gng?USY)_eA2TN+_Q5Se8SV(=dAWLG zcHJ`jd5W%c;CoH%R7Wg-*byPD+CU~mwteem}mC*_O#1`Bj zG*Ux4a7to4+`3V(u%HnZm_C5=^-$jF2HPy6MQ!?WUFsnTBLhuwY{{|*d1P)fbvKsn zRxT-wR4-M$J99I{o4WR%>U$j@0lGkq@CioRPuOQ^DY<7rTBAO0QU_{WS` zYqHEC%Tm$3s8e2~FKBnF@ZC{33*pn3yd{?>Hzc-pHAHXSyfvG@dE@ByY}@0azf+%O zf*8lmxZnwL;YnHWFu%>)n)tg^e`2Su9kn4j^66V_!$}FBmy*x)dVO$_zPLeDs_EduS{c&NS<_>GeLF@Pk*N7?A-uS&#^aGN49hS~7NXPS%(N}m6 z_RTUVL?`D;zu56r7gvr=071k%AYb!JQI)+0%R@^8bdqaS3SlW??NZpY^K?3&vg$7v z>EWXQ6!hy2YMEN*|LH?$kE>%{sOR8%iTHzy)pG{^1;+0h>dCGXAna7Ag>)ELAZfvq z=A;^2xYH!R6nABhU_<`~1Uuh3tIX~r@=(+~v$kY?&Mo1;p zNvcO}IWgH$z0N;zREO@8ZJkeLT*%UJInghyH`DG5tqbbr;D#edcd7YLD5)AHaw0z4 zKPuKd-d1$8mmJms%6M8O*ST%^jK*dRpYoo*(wn~qtL$%8PEGA8SKYj|i4W5T;W=eK zjU}EfX~`R#&aXI;CFfI8Eh|LJvFTw&ystkcnZK^9eQf2bDX*WH&aX^v*)%rxP(p3x zc9>2%z6FOZ(_M0#Fk#K1=YPT8%dg$fzfS1%iZLhjE8ISQfG{%IX0l-{Ft@pm3K2-) z+7rCu^9jc8pG}1nDu#{|U`AC`laF_j=t7EH#>Q%lZs&r1%Hr?di910N&MK=MdG1+d6DccUCX=E*fldx z<1K^W*yONM*plxr=UuD8to|f<6rc&L%CMG9#F*3sy4YkQ=zThUsC`J*6(Oke|SY-C1n*j7JV+&;ZHQT00r8fn~>Wg`mOBEf|0 zB5r6e@Yntwdoyc@sICnD7_)#qG+EsW|N5tqx)1wkTv}d0<{{agldF;&Mz7!eS@KoP z{ZECG1gj7I+SSrtN6J(kI6`@%Z&*+po(42b<2o;qkuh~YwGS=+gH^N-xApG~Ee&xx zbYjJcI63`QvW{}35cSd{_VUs{WI#P~qn94GvFl~!gt$FLil(ol65L?M`VtyRj6;MV zcw&F&=Fre{IQjeqL)HD}KLsHUuI)hPwCvJAS>@V&(C4{!_vt?;$~H`_Y?A(&A^kH$#;1mSO$k~aW|Wo*d9OZHPA!XF zyUo5_Rm55GdE(mT{@UC*kir7tMu(rwOgY@lu9l1R6-%v{Clu1)>MoVDYU7ZeqMZ`rtX zJ?wocHtz;fYZ6}#h|Rf5PnDZ$W2Zh-lODglC-_fMt@hfuz4SU1KQtpB(8--+SJ(hh z)74&Ec|zH=U27y7*famg90Dk<4#@+A6*TDNB!^{{ZPl#3(NW7C2Kf;QQw=5F%zOe# zV8zL%-Y3X?D4ls zrZ7X3j3hp6!b6s55>b1<%C*P&19XwuajT2UP?+sNkI)H)t4f_GNZv! zXX^$G0;w7h|mJN9A39rjaVW6312!Fn8~VexIrxM!7eD! z-d*6w6fh?VuBV=woor`n<@TkBKXaQIXUHqMtF?Xl@P1iGnTL36;1Hlio)F8SA^W_5 zI-!e{A8)d=a~e1Dpj z=aD)Mk+iA8T7>MM`$_grL-sTWdPlNX5RyG-e0k~SCL;)Zzl4L|+4uYts6Tss@A_hM zUsJ9==WnA$O`5%maWHr`8`#prFD#aC*ftJp(_nh!!VhE+=`f06rlFo>Xg>0_t0|p2 z>RJ1#dQv}dtVBXyrg661-!i)UaEdw(Er8`(KjA5^CzR}^h<{>bJ-w)KlvOo^A#?Z} zdkPI|3}(wz$^ho?c^0j}Dk_syRv5qxQC7PAQ-0Y?aQXm<)CK4z%C}i~kWA;}fIfsN3pb`$To{ zT;vb>fm$Prbz~`)Zk@>vbYik_F>ht`tKIiyjV4VB zn3w957tSSbVBwR~h4EksInBd={_tI{j+`i#OZG^T>Y}K2AyRxD9pX;lBM>*(4=yjS z^0lcaVT$IHZx0#HdnBq_hKqWDAG1dg@@xy|Ed4*OgMSwwzoK3o>UpA`2PFSSC9&d+ zT3*YsKmRj!)wTIQ;?9^I`&(mk4?~r~!wS)}T=e9!5sox+9$_F2PY)?b*W~4*D-JB| zoCf9!D)xrD8C~(0?~3xU6}mV|$U5e!$iH!Xj^>UIg=?-dia*OwqUtwr0g9VBn2g@T zH>3FRd1NkOOl}ahQ-!m46B2p7kT_mQi1HBq*k7uW=uZSXRXB+sdOg^fYk)CnCL&h( z?9^(n<6Wpbvl!}*VG4GTYH!@hOCDLAP3f@NnM60uHjAj`5Vb-?-5p^5v3$44!Idh6`YXep%prev!#I+REKv&b7oyx3e-8l26s@xv>XEcPH&yj*LV|zrTP=(M%~9+CcE5!R(h-;2itIG zgO{duoID`)TBRBi_DyG8&1ch{joR>~_vFZ1>#i!�|4LH+hbpAV8IC8!zw_X3(x; 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%0A8T&|pLJFL|8KCtK=2xhIqzq# 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