timezone-detect (empty) → 0.1.0.0
raw patch · 10 files changed
+1817/−0 lines, 10 filesdep +basedep +directorydep +hspec
Dependencies added: base, directory, hspec, timezone-detect
Files
- ChangeLog.md +7/−0
- LICENSE +339/−0
- README.md +17/−0
- csrc/zonedetect.c +1190/−0
- csrc/zonedetect.h +91/−0
- src/Foreign/ZoneDetect.hsc +34/−0
- src/TimezoneDetect.hs +47/−0
- test/Spec.hs +1/−0
- test/TimezoneDetectSpec.hs +27/−0
- timezone-detect.cabal +64/−0
+ ChangeLog.md view
@@ -0,0 +1,7 @@+# Changelog for timezone-detect++## v0.1.0.0 (2020-08-29)++* Bundles the C code for [ZoneDetect](https://github.com/BertoldVdb/ZoneDetect)+* Exposes the `lookupTimezone` function to obtain the standardized name of a timezone, given+ a database file, latitude and longitude.
+ LICENSE view
@@ -0,0 +1,339 @@+ GNU GENERAL PUBLIC LICENSE+ Version 2, June 1991++ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++ Preamble++ The licenses for most software are designed to take away your+freedom to share and change it. By contrast, the GNU General Public+License is intended to guarantee your freedom to share and change free+software--to make sure the software is free for all its users. This+General Public License applies to most of the Free Software+Foundation's software and to any other program whose authors commit to+using it. (Some other Free Software Foundation software is covered by+the GNU Lesser General Public License instead.) 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+this service 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 make restrictions that forbid+anyone to deny you these rights or to ask you to surrender the rights.+These restrictions translate to certain responsibilities for you if you+distribute copies of the software, or if you modify it.++ For example, if you distribute copies of such a program, whether+gratis or for a fee, you must give the recipients all the rights that+you have. 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.++ We protect your rights with two steps: (1) copyright the software, and+(2) offer you this license which gives you legal permission to copy,+distribute and/or modify the software.++ Also, for each author's protection and ours, we want to make certain+that everyone understands that there is no warranty for this free+software. If the software is modified by someone else and passed on, we+want its recipients to know that what they have is not the original, so+that any problems introduced by others will not reflect on the original+authors' reputations.++ Finally, any free program is threatened constantly by software+patents. We wish to avoid the danger that redistributors of a free+program will individually obtain patent licenses, in effect making the+program proprietary. To prevent this, we have made it clear that any+patent must be licensed for everyone's free use or not licensed at all.++ The precise terms and conditions for copying, distribution and+modification follow.++ GNU GENERAL PUBLIC LICENSE+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++ 0. This License applies to any program or other work which contains+a notice placed by the copyright holder saying it may be distributed+under the terms of this General Public License. The "Program", below,+refers to any such program or work, and a "work based on the Program"+means either the Program or any derivative work under copyright law:+that is to say, a work containing the Program or a portion of it,+either verbatim or with modifications and/or translated into another+language. (Hereinafter, translation is included without limitation in+the term "modification".) Each licensee is addressed as "you".++Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope. The act of+running the Program is not restricted, and the output from the Program+is covered only if its contents constitute a work based on the+Program (independent of having been made by running the Program).+Whether that is true depends on what the Program does.++ 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the+notices that refer to this License and to the absence of any warranty;+and give any other recipients of the Program a copy of this License+along with the Program.++You may charge a fee for the physical act of transferring a copy, and+you may at your option offer warranty protection in exchange for a fee.++ 2. You may modify your copy or copies of the Program or any portion+of it, thus forming a work based on the Program, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++ a) You must cause the modified files to carry prominent notices+ stating that you changed the files and the date of any change.++ b) You must cause any work that you distribute or publish, that in+ whole or in part contains or is derived from the Program or any+ part thereof, to be licensed as a whole at no charge to all third+ parties under the terms of this License.++ c) If the modified program normally reads commands interactively+ when run, you must cause it, when started running for such+ interactive use in the most ordinary way, to print or display an+ announcement including an appropriate copyright notice and a+ notice that there is no warranty (or else, saying that you provide+ a warranty) and that users may redistribute the program under+ these conditions, and telling the user how to view a copy of this+ License. (Exception: if the Program itself is interactive but+ does not normally print such an announcement, your work based on+ the Program is not required to print an announcement.)++These requirements apply to the modified work as a whole. If+identifiable sections of that work are not derived from the Program,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works. But when you+distribute the same sections as part of a whole which is a work based+on the Program, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Program.++In addition, mere aggregation of another work not based on the Program+with the Program (or with a work based on the Program) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++ 3. You may copy and distribute the Program (or a work based on it,+under Section 2) in object code or executable form under the terms of+Sections 1 and 2 above provided that you also do one of the following:++ a) Accompany it with the complete corresponding machine-readable+ source code, which must be distributed under the terms of Sections+ 1 and 2 above on a medium customarily used for software interchange; or,++ b) Accompany it with a written offer, valid for at least three+ years, to give any third party, for a charge no more than your+ cost of physically performing source distribution, a complete+ machine-readable copy of the corresponding source code, to be+ distributed under the terms of Sections 1 and 2 above on a medium+ customarily used for software interchange; or,++ c) Accompany it with the information you received as to the offer+ to distribute corresponding source code. (This alternative is+ allowed only for noncommercial distribution and only if you+ received the program in object code or executable form with such+ an offer, in accord with Subsection b above.)++The source code for a work means the preferred form of the work for+making modifications to it. For an executable work, complete source+code means all the source code for all modules it contains, plus any+associated interface definition files, plus the scripts used to+control compilation and installation of the executable. However, as a+special exception, the source code distributed need not include+anything that is normally distributed (in either source or binary+form) with the major components (compiler, kernel, and so on) of the+operating system on which the executable runs, unless that component+itself accompanies the executable.++If distribution of executable or object code is made by offering+access to copy from a designated place, then offering equivalent+access to copy the source code from the same place counts as+distribution of the source code, even though third parties are not+compelled to copy the source along with the object code.++ 4. You may not copy, modify, sublicense, or distribute the Program+except as expressly provided under this License. Any attempt+otherwise to copy, modify, sublicense or distribute the Program is+void, and will automatically terminate your rights under this License.+However, parties who have received copies, or rights, from you under+this License will not have their licenses terminated so long as such+parties remain in full compliance.++ 5. You are not required to accept this License, since you have not+signed it. However, nothing else grants you permission to modify or+distribute the Program or its derivative works. These actions are+prohibited by law if you do not accept this License. Therefore, by+modifying or distributing the Program (or any work based on the+Program), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Program or works based on it.++ 6. Each time you redistribute the Program (or any work based on the+Program), the recipient automatically receives a license from the+original licensor to copy, distribute or modify the Program subject to+these terms and conditions. You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties to+this License.++ 7. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+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+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Program at all. For example, if a patent+license would not permit royalty-free redistribution of the Program by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Program.++If any portion of this section is held invalid or unenforceable under+any particular circumstance, the balance of the section is intended to+apply and the section as a whole is intended to apply in other+circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system, which is+implemented by public license practices. Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++ 8. If the distribution and/or use of the Program is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Program under this License+may add an explicit geographical distribution limitation excluding+those countries, so that distribution is permitted only in or among+countries not thus excluded. In such case, this License incorporates+the limitation as if written in the body of this License.++ 9. The Free Software Foundation may publish revised and/or new versions+of the 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 a version number of this License which applies to it and "any+later version", you have the option of following the terms and conditions+either of that version or of any later version published by the Free+Software Foundation. If the Program does not specify a version number of+this License, you may choose any version ever published by the Free Software+Foundation.++ 10. If you wish to incorporate parts of the Program into other free+programs whose distribution conditions are different, write to the author+to ask for permission. For software which is copyrighted by the Free+Software Foundation, write to the Free Software Foundation; we sometimes+make exceptions for this. Our decision will be guided by the two goals+of preserving the free status of all derivatives of our free software and+of promoting the sharing and reuse of software generally.++ NO WARRANTY++ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.++ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR+REDISTRIBUTE 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.++ 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+convey 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 2 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, write to the Free Software Foundation, Inc.,+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.++Also add information on how to contact you by electronic and paper mail.++If the program is interactive, make it output a short notice like this+when it starts in an interactive mode:++ Gnomovision version 69, Copyright (C) year name of author+ Gnomovision 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, the commands you use may+be called something other than `show w' and `show c'; they could even be+mouse-clicks or menu items--whatever suits your program.++You should also get your employer (if you work as a programmer) or your+school, if any, to sign a "copyright disclaimer" for the program, if+necessary. Here is a sample; alter the names:++ Yoyodyne, Inc., hereby disclaims all copyright interest in the program+ `Gnomovision' (which makes passes at compilers) written by James Hacker.++ <signature of Ty Coon>, 1 April 1989+ Ty Coon, President of Vice++This 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.
+ README.md view
@@ -0,0 +1,17 @@+# TimezoneDetect+++++Haskell bindings to the excellent [ZoneDetect](https://github.com/BertoldVdb/ZoneDetect) library.++## Usage++You'll need timezone database files to work with this library, see instructions [in the original repository](https://github.com/BertoldVdb/ZoneDetect/tree/master/database).++Once you have those files in hand, you'll be able to get a timezone from a given latitude and longitude:++```haskell+> lookupTimezone "./test/tz_db/timezone21.bin" 40.7831 (-73.9712)+Right "America/New_York"+```
+ csrc/zonedetect.c view
@@ -0,0 +1,1190 @@+/*+ * Copyright (c) 2018, Bertold Van den Bergh (vandenbergh@bertold.org)+ * All rights reserved.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions are met:+ * * Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * * Redistributions in binary form must reproduce the above copyright+ * notice, this list of conditions and the following disclaimer in the+ * documentation and/or other materials provided with the distribution.+ * * Neither the name of the author nor the+ * names of its contributors may be used to endorse or promote products+ * derived from this software without specific prior written permission.+ *+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTOR BE LIABLE FOR ANY+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+ */++#include <assert.h>+#include <stddef.h>+#include <stdint.h>+#include <stdio.h>+#include <stdlib.h>+#include <string.h>+#include <math.h>+#if defined(_MSC_VER) || defined(__MINGW32__)+#include <windows.h>+#else+#include <errno.h>+#include <sys/mman.h>+#include <fcntl.h>+#include <unistd.h>+#endif++#include "zonedetect.h"++enum ZDInternalError {+ ZD_OK,+ ZD_E_DB_OPEN,+ ZD_E_DB_SEEK,+ ZD_E_DB_MMAP,+#if defined(_MSC_VER) || defined(__MINGW32__)+ ZD_E_DB_MMAP_MSVIEW,+ ZD_E_DB_MAP_EXCEPTION,+ ZD_E_DB_MUNMAP_MSVIEW,+#endif+ ZD_E_DB_MUNMAP,+ ZD_E_DB_CLOSE,+ ZD_E_PARSE_HEADER+};++struct ZoneDetectOpaque {+#if defined(_MSC_VER) || defined(__MINGW32__)+ HANDLE fd;+ HANDLE fdMap;+ int32_t length;+ int32_t padding;+#else+ int fd;+ off_t length;+#endif++ uint8_t closeType;+ uint8_t *mapping;++ uint8_t tableType;+ uint8_t version;+ uint8_t precision;+ uint8_t numFields;++ char *notice;+ char **fieldNames;++ uint32_t bboxOffset;+ uint32_t metadataOffset;+ uint32_t dataOffset;+};++static void (*zdErrorHandler)(int, int);+static void zdError(enum ZDInternalError errZD, int errNative)+{+ if (zdErrorHandler) zdErrorHandler((int)errZD, errNative);+}++static int32_t ZDFloatToFixedPoint(float input, float scale, unsigned int precision)+{+ const float inputScaled = input / scale;+ return (int32_t)(inputScaled * (float)(1 << (precision - 1)));+}++static float ZDFixedPointToFloat(int32_t input, float scale, unsigned int precision)+{+ const float value = (float)input / (float)(1 << (precision - 1));+ return value * scale;+}++static unsigned int ZDDecodeVariableLengthUnsigned(const ZoneDetect *library, uint32_t *index, uint64_t *result)+{+ if(*index >= (uint32_t)library->length) {+ return 0;+ }++ uint64_t value = 0;+ unsigned int i = 0;+#if defined(_MSC_VER)+ __try {+#endif+ uint8_t *const buffer = library->mapping + *index;+ uint8_t *const bufferEnd = library->mapping + library->length - 1;++ unsigned int shift = 0;+ while(1) {+ value |= ((((uint64_t)buffer[i]) & UINT8_C(0x7F)) << shift);+ shift += 7u;++ if(!(buffer[i] & UINT8_C(0x80))) {+ break;+ }++ i++;+ if(buffer + i > bufferEnd) {+ return 0;+ }+ }+#if defined(_MSC_VER)+ } __except(GetExceptionCode() == EXCEPTION_IN_PAGE_ERROR+ ? EXCEPTION_EXECUTE_HANDLER+ : EXCEPTION_CONTINUE_SEARCH) { /* file mapping SEH exception occurred */+ zdError(ZD_E_DB_MAP_EXCEPTION, (int)GetLastError());+ return 0;+ }+#endif++ i++;+ *result = value;+ *index += i;+ return i;+}++static unsigned int ZDDecodeVariableLengthUnsignedReverse(const ZoneDetect *library, uint32_t *index, uint64_t *result)+{+ uint32_t i = *index;++ if(*index >= (uint32_t)library->length) {+ return 0;+ }++#if defined(_MSC_VER)+ __try {+#endif++ if(library->mapping[i] & UINT8_C(0x80)) {+ return 0;+ }++ if(!i) {+ return 0;+ }+ i--;++ while(library->mapping[i] & UINT8_C(0x80)) {+ if(!i) {+ return 0;+ }+ i--;+ }++#if defined(_MSC_VER)+ } __except(GetExceptionCode() == EXCEPTION_IN_PAGE_ERROR+ ? EXCEPTION_EXECUTE_HANDLER+ : EXCEPTION_CONTINUE_SEARCH) { /* file mapping SEH exception occurred */+ zdError(ZD_E_DB_MAP_EXCEPTION, (int)GetLastError());+ return 0;+ }+#endif++ *index = i;++ i++;++ uint32_t i2 = i;+ return ZDDecodeVariableLengthUnsigned(library, &i2, result);+}++static int64_t ZDDecodeUnsignedToSigned(uint64_t value)+{+ return (value & 1) ? -(int64_t)(value / 2) : (int64_t)(value / 2);+}++static unsigned int ZDDecodeVariableLengthSigned(const ZoneDetect *library, uint32_t *index, int32_t *result)+{+ uint64_t value = 0;+ const unsigned int retVal = ZDDecodeVariableLengthUnsigned(library, index, &value);+ *result = (int32_t)ZDDecodeUnsignedToSigned(value);+ return retVal;+}++static char *ZDParseString(const ZoneDetect *library, uint32_t *index)+{+ uint64_t strLength;+ if(!ZDDecodeVariableLengthUnsigned(library, index, &strLength)) {+ return NULL;+ }++ uint32_t strOffset = *index;+ unsigned int remoteStr = 0;+ if(strLength >= 256) {+ strOffset = library->metadataOffset + (uint32_t)strLength - 256;+ remoteStr = 1;++ if(!ZDDecodeVariableLengthUnsigned(library, &strOffset, &strLength)) {+ return NULL;+ }++ if(strLength > 256) {+ return NULL;+ }+ }++ char *const str = malloc((size_t)(strLength + 1));++ if(str) {+#if defined(_MSC_VER)+ __try {+#endif+ for(size_t i = 0; i < strLength; i++) {+ str[i] = (char)(library->mapping[strOffset + i] ^ UINT8_C(0x80));+ }+#if defined(_MSC_VER)+ } __except(GetExceptionCode() == EXCEPTION_IN_PAGE_ERROR+ ? EXCEPTION_EXECUTE_HANDLER+ : EXCEPTION_CONTINUE_SEARCH) { /* file mapping SEH exception occurred */+ zdError(ZD_E_DB_MAP_EXCEPTION, (int)GetLastError());+ return 0;+ }+#endif+ str[strLength] = 0;+ }++ if(!remoteStr) {+ *index += (uint32_t)strLength;+ }++ return str;+}++static int ZDParseHeader(ZoneDetect *library)+{+ if(library->length < 7) {+ return -1;+ }++#if defined(_MSC_VER)+ __try {+#endif+ if(memcmp(library->mapping, "PLB", 3)) {+ return -1;+ }++ library->tableType = library->mapping[3];+ library->version = library->mapping[4];+ library->precision = library->mapping[5];+ library->numFields = library->mapping[6];+#if defined(_MSC_VER)+ } __except(GetExceptionCode() == EXCEPTION_IN_PAGE_ERROR+ ? EXCEPTION_EXECUTE_HANDLER+ : EXCEPTION_CONTINUE_SEARCH) { /* file mapping SEH exception occurred */+ zdError(ZD_E_DB_MAP_EXCEPTION, (int)GetLastError());+ return 0;+ }+#endif++ if(library->version >= 2) {+ return -1;+ }++ uint32_t index = UINT32_C(7);++ library->fieldNames = malloc(library->numFields * sizeof *library->fieldNames);+ for(size_t i = 0; i < library->numFields; i++) {+ library->fieldNames[i] = ZDParseString(library, &index);+ }++ library->notice = ZDParseString(library, &index);+ if(!library->notice) {+ return -1;+ }++ uint64_t tmp;+ /* Read section sizes */+ /* By memset: library->bboxOffset = 0 */++ if(!ZDDecodeVariableLengthUnsigned(library, &index, &tmp)) return -1;+ library->metadataOffset = (uint32_t)tmp + library->bboxOffset;++ if(!ZDDecodeVariableLengthUnsigned(library, &index, &tmp))return -1;+ library->dataOffset = (uint32_t)tmp + library->metadataOffset;++ if(!ZDDecodeVariableLengthUnsigned(library, &index, &tmp)) return -1;++ /* Add header size to everything */+ library->bboxOffset += index;+ library->metadataOffset += index;+ library->dataOffset += index;++ /* Verify file length */+ if(tmp + library->dataOffset != (uint32_t)library->length) {+ return -2;+ }++ return 0;+}++static int ZDPointInBox(int32_t xl, int32_t x, int32_t xr, int32_t yl, int32_t y, int32_t yr)+{+ if((xl <= x && x <= xr) || (xr <= x && x <= xl)) {+ if((yl <= y && y <= yr) || (yr <= y && y <= yl)) {+ return 1;+ }+ }++ return 0;+}++static uint32_t ZDUnshuffle(uint64_t w)+{+ w &= 0x5555555555555555;+ w = (w | (w >> 1)) & 0x3333333333333333;+ w = (w | (w >> 2)) & 0x0F0F0F0F0F0F0F0F;+ w = (w | (w >> 4)) & 0x00FF00FF00FF00FF;+ w = (w | (w >> 8)) & 0x0000FFFF0000FFFF;+ w = (w | (w >> 16)) & 0x00000000FFFFFFFF;+ return (uint32_t)w;+}++static void ZDDecodePoint(uint64_t point, int32_t* lat, int32_t* lon)+{+ *lat = (int32_t)ZDDecodeUnsignedToSigned(ZDUnshuffle(point));+ *lon = (int32_t)ZDDecodeUnsignedToSigned(ZDUnshuffle(point >> 1));+}++struct Reader {+ const ZoneDetect *library;+ uint32_t polygonIndex;++ uint64_t numVertices;++ uint8_t done, first;+ uint32_t referenceStart, referenceEnd;+ int32_t referenceDirection;++ int32_t pointLat, pointLon;+ int32_t firstLat, firstLon;+};++static void ZDReaderInit(struct Reader *reader, const ZoneDetect *library, uint32_t polygonIndex)+{+ memset(reader, 0, sizeof(*reader));++ reader->library = library;+ reader->polygonIndex = polygonIndex;++ reader->first = 1;+}++static int ZDReaderGetPoint(struct Reader *reader, int32_t *pointLat, int32_t *pointLon)+{+ int32_t diffLat = 0, diffLon = 0;++readNewPoint:+ if(reader->done > 1) {+ return 0;+ }++ if(reader->first && reader->library->version == 0) {+ if(!ZDDecodeVariableLengthUnsigned(reader->library, &reader->polygonIndex, &reader->numVertices)) return -1;+ if(!reader->numVertices) return -1;+ }++ uint8_t referenceDone = 0;++ if(reader->library->version == 1) {+ uint64_t point = 0;++ if(!reader->referenceDirection) {+ if(!ZDDecodeVariableLengthUnsigned(reader->library, &reader->polygonIndex, &point)) return -1;+ } else {+ if(reader->referenceDirection > 0) {+ /* Read reference forward */+ if(!ZDDecodeVariableLengthUnsigned(reader->library, &reader->referenceStart, &point)) return -1;+ if(reader->referenceStart >= reader->referenceEnd) {+ referenceDone = 1;+ }+ } else if(reader->referenceDirection < 0) {+ /* Read reference backwards */+ if(!ZDDecodeVariableLengthUnsignedReverse(reader->library, &reader->referenceStart, &point)) return -1;+ if(reader->referenceStart <= reader->referenceEnd) {+ referenceDone = 1;+ }+ }+ }++ if(!point) {+ /* This is a special marker, it is not allowed in reference mode */+ if(reader->referenceDirection) {+ return -1;+ }++ uint64_t value;+ if(!ZDDecodeVariableLengthUnsigned(reader->library, &reader->polygonIndex, &value)) return -1;++ if(value == 0) {+ reader->done = 2;+ } else if(value == 1) {+ int32_t diff;+ int64_t start;+ if(!ZDDecodeVariableLengthUnsigned(reader->library, &reader->polygonIndex, (uint64_t*)&start)) return -1;+ if(!ZDDecodeVariableLengthSigned(reader->library, &reader->polygonIndex, &diff)) return -1;++ reader->referenceStart = reader->library->dataOffset+(uint32_t)start;+ reader->referenceEnd = reader->library->dataOffset+(uint32_t)(start + diff);+ reader->referenceDirection = diff;+ if(diff < 0) {+ reader->referenceStart--;+ reader->referenceEnd--;+ }+ goto readNewPoint;+ }+ } else {+ ZDDecodePoint(point, &diffLat, &diffLon);+ if(reader->referenceDirection < 0) {+ diffLat = -diffLat;+ diffLon = -diffLon;+ }+ }+ }++ if(reader->library->version == 0) {+ if(!ZDDecodeVariableLengthSigned(reader->library, &reader->polygonIndex, &diffLat)) return -1;+ if(!ZDDecodeVariableLengthSigned(reader->library, &reader->polygonIndex, &diffLon)) return -1;+ }++ if(!reader->done) {+ reader->pointLat += diffLat;+ reader->pointLon += diffLon;+ if(reader->first) {+ reader->firstLat = reader->pointLat;+ reader->firstLon = reader->pointLon;+ }+ } else {+ /* Close the polygon (the closing point is not encoded) */+ reader->pointLat = reader->firstLat;+ reader->pointLon = reader->firstLon;+ reader->done = 2;+ }++ reader->first = 0;++ if(reader->library->version == 0) {+ reader->numVertices--;+ if(!reader->numVertices) {+ reader->done = 1;+ }+ if(!diffLat && !diffLon) {+ goto readNewPoint;+ }+ }++ if(referenceDone) {+ reader->referenceDirection = 0;+ }++ if(pointLat) {+ *pointLat = reader->pointLat;+ }++ if(pointLon) {+ *pointLon = reader->pointLon;+ }++ return 1;+}++static int ZDFindPolygon(const ZoneDetect *library, uint32_t wantedId, uint32_t* metadataIndexPtr, uint32_t* polygonIndexPtr)+{+ uint32_t polygonId = 0;+ uint32_t bboxIndex = library->bboxOffset;++ uint32_t metadataIndex = 0, polygonIndex = 0;++ while(bboxIndex < library->metadataOffset) {+ uint64_t polygonIndexDelta;+ int32_t metadataIndexDelta;+ int32_t tmp;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &tmp)) break;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &tmp)) break;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &tmp)) break;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &tmp)) break;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &metadataIndexDelta)) break;+ if(!ZDDecodeVariableLengthUnsigned(library, &bboxIndex, &polygonIndexDelta)) break;++ metadataIndex += (uint32_t)metadataIndexDelta;+ polygonIndex += (uint32_t)polygonIndexDelta;++ if(polygonId == wantedId) {+ if(metadataIndexPtr) {+ metadataIndex += library->metadataOffset;+ *metadataIndexPtr = metadataIndex;+ }+ if(polygonIndexPtr) {+ polygonIndex += library->dataOffset;+ *polygonIndexPtr = polygonIndex;+ }+ return 1;+ }++ polygonId ++;+ }++ return 0;+}++static int32_t* ZDPolygonToListInternal(const ZoneDetect *library, uint32_t polygonIndex, size_t* length)+{+ struct Reader reader;+ ZDReaderInit(&reader, library, polygonIndex);++ size_t listLength = 2 * 100;+ size_t listIndex = 0;++ int32_t* list = malloc(sizeof(int32_t) * listLength);+ if(!list) {+ goto fail;+ }++ while(1) {+ int32_t pointLat, pointLon;+ int result = ZDReaderGetPoint(&reader, &pointLat, &pointLon);+ if(result < 0) {+ goto fail;+ } else if(result == 0) {+ break;+ }++ if(listIndex >= listLength) {+ listLength *= 2;+ if(listLength >= 1048576) {+ goto fail;+ }++ list = realloc(list, sizeof(int32_t) * listLength);+ if(!list) {+ goto fail;+ }+ }++ list[listIndex++] = pointLat;+ list[listIndex++] = pointLon;+ }++ if(length) {+ *length = listIndex;+ }++ return list;++fail:+ if(list) {+ free(list);+ }+ return NULL;+}++float* ZDPolygonToList(const ZoneDetect *library, uint32_t polygonId, size_t* lengthPtr)+{+ uint32_t polygonIndex;+ int32_t* data = NULL;+ float* flData = NULL;++ if(!ZDFindPolygon(library, polygonId, NULL, &polygonIndex)) {+ goto fail;+ }++ size_t length = 0;+ data = ZDPolygonToListInternal(library, polygonIndex, &length);++ if(!data) {+ goto fail;+ }++ flData = malloc(sizeof(float) * length);+ if(!flData) {+ goto fail;+ }++ for(size_t i = 0; i<length; i+= 2) {+ int32_t lat = data[i];+ int32_t lon = data[i+1];++ flData[i] = ZDFixedPointToFloat(lat, 90, library->precision);+ flData[i+1] = ZDFixedPointToFloat(lon, 180, library->precision);+ }++ if(lengthPtr) {+ *lengthPtr = length;+ }++ return flData;++fail:+ if(data) {+ free(data);+ }+ if(flData) {+ free(flData);+ }+ return NULL;+}++static ZDLookupResult ZDPointInPolygon(const ZoneDetect *library, uint32_t polygonIndex, int32_t latFixedPoint, int32_t lonFixedPoint, uint64_t *distanceSqrMin)+{+ int32_t pointLat, pointLon, prevLat = 0, prevLon = 0;+ int prevQuadrant = 0, winding = 0;++ uint8_t first = 1;++ struct Reader reader;+ ZDReaderInit(&reader, library, polygonIndex);++ while(1) {+ int result = ZDReaderGetPoint(&reader, &pointLat, &pointLon);+ if(result < 0) {+ return ZD_LOOKUP_PARSE_ERROR;+ } else if(result == 0) {+ break;+ }++ /* Check if point is ON the border */+ if(pointLat == latFixedPoint && pointLon == lonFixedPoint) {+ if(distanceSqrMin) *distanceSqrMin = 0;+ return ZD_LOOKUP_ON_BORDER_VERTEX;+ }++ /* Find quadrant */+ int quadrant;+ if(pointLat >= latFixedPoint) {+ if(pointLon >= lonFixedPoint) {+ quadrant = 0;+ } else {+ quadrant = 1;+ }+ } else {+ if(pointLon >= lonFixedPoint) {+ quadrant = 3;+ } else {+ quadrant = 2;+ }+ }++ if(!first) {+ int windingNeedCompare = 0, lineIsStraight = 0;+ float a = 0, b = 0;++ /* Calculate winding number */+ if(quadrant == prevQuadrant) {+ /* Do nothing */+ } else if(quadrant == (prevQuadrant + 1) % 4) {+ winding ++;+ } else if((quadrant + 1) % 4 == prevQuadrant) {+ winding --;+ } else {+ windingNeedCompare = 1;+ }++ /* Avoid horizontal and vertical lines */+ if((pointLon == prevLon || pointLat == prevLat)) {+ lineIsStraight = 1;+ }++ /* Calculate the parameters of y=ax+b if needed */+ if(!lineIsStraight && (distanceSqrMin || windingNeedCompare)) {+ a = ((float)pointLat - (float)prevLat) / ((float)pointLon - (float)prevLon);+ b = (float)pointLat - a * (float)pointLon;+ }++ int onStraight = ZDPointInBox(pointLat, latFixedPoint, prevLat, pointLon, lonFixedPoint, prevLon);+ if(lineIsStraight && (onStraight || windingNeedCompare)) {+ if(distanceSqrMin) *distanceSqrMin = 0;+ return ZD_LOOKUP_ON_BORDER_SEGMENT;+ }++ /* Jumped two quadrants. */+ if(windingNeedCompare) {+ /* Check if the target is on the border */+ const int32_t intersectLon = (int32_t)(((float)latFixedPoint - b) / a);+ if(intersectLon >= lonFixedPoint-1 && intersectLon <= lonFixedPoint+1) {+ if(distanceSqrMin) *distanceSqrMin = 0;+ return ZD_LOOKUP_ON_BORDER_SEGMENT;+ }++ /* Ok, it's not. In which direction did we go round the target? */+ const int sign = (intersectLon < lonFixedPoint) ? 2 : -2;+ if(quadrant == 2 || quadrant == 3) {+ winding += sign;+ } else {+ winding -= sign;+ }+ }++ /* Calculate closest point on line (if needed) */+ if(distanceSqrMin) {+ float closestLon, closestLat;+ if(!lineIsStraight) {+ closestLon = ((float)lonFixedPoint + a * (float)latFixedPoint - a * b) / (a * a + 1);+ closestLat = (a * ((float)lonFixedPoint + a * (float)latFixedPoint) + b) / (a * a + 1);+ } else {+ if(pointLon == prevLon) {+ closestLon = (float)pointLon;+ closestLat = (float)latFixedPoint;+ } else {+ closestLon = (float)lonFixedPoint;+ closestLat = (float)pointLat;+ }+ }++ const int closestInBox = ZDPointInBox(pointLon, (int32_t)closestLon, prevLon, pointLat, (int32_t)closestLat, prevLat);++ int64_t diffLat, diffLon;+ if(closestInBox) {+ /* Calculate squared distance to segment. */+ diffLat = (int64_t)(closestLat - (float)latFixedPoint);+ diffLon = (int64_t)(closestLon - (float)lonFixedPoint);+ } else {+ /*+ * Calculate squared distance to vertices+ * It is enough to check the current point since the polygon is closed.+ */+ diffLat = (int64_t)(pointLat - latFixedPoint);+ diffLon = (int64_t)(pointLon - lonFixedPoint);+ }++ /* Note: lon has half scale */+ uint64_t distanceSqr = (uint64_t)(diffLat * diffLat) + (uint64_t)(diffLon * diffLon) * 4;+ if(distanceSqr < *distanceSqrMin) *distanceSqrMin = distanceSqr;+ }+ }++ prevQuadrant = quadrant;+ prevLat = pointLat;+ prevLon = pointLon;+ first = 0;+ };++ if(winding == -4) {+ return ZD_LOOKUP_IN_ZONE;+ } else if(winding == 4) {+ return ZD_LOOKUP_IN_EXCLUDED_ZONE;+ } else if(winding == 0) {+ return ZD_LOOKUP_NOT_IN_ZONE;+ }++ /* Should not happen */+ if(distanceSqrMin) *distanceSqrMin = 0;+ return ZD_LOOKUP_ON_BORDER_SEGMENT;+}++void ZDCloseDatabase(ZoneDetect *library)+{+ if(library) {+ if(library->fieldNames) {+ for(size_t i = 0; i < (size_t)library->numFields; i++) {+ if(library->fieldNames[i]) {+ free(library->fieldNames[i]);+ }+ }+ free(library->fieldNames);+ }+ if(library->notice) {+ free(library->notice);+ }++ if(library->closeType == 0) {+#if defined(_MSC_VER) || defined(__MINGW32__)+ if(library->mapping && !UnmapViewOfFile(library->mapping)) zdError(ZD_E_DB_MUNMAP_MSVIEW, (int)GetLastError());+ if(library->fdMap && !CloseHandle(library->fdMap)) zdError(ZD_E_DB_MUNMAP, (int)GetLastError());+ if(library->fd && !CloseHandle(library->fd)) zdError(ZD_E_DB_CLOSE, (int)GetLastError());+#else+ if(library->mapping && munmap(library->mapping, (size_t)(library->length))) zdError(ZD_E_DB_MUNMAP, errno);+ if(library->fd >= 0 && close(library->fd)) zdError(ZD_E_DB_CLOSE, errno);+#endif+ }++ free(library);+ }+}++ZoneDetect *ZDOpenDatabaseFromMemory(void* buffer, size_t length)+{+ ZoneDetect *const library = malloc(sizeof *library);++ if(library) {+ memset(library, 0, sizeof(*library));+ library->closeType = 1;+ library->length = (long int)length;++ if(library->length <= 0) {+ zdError(ZD_E_DB_SEEK, errno);+ goto fail;+ }++ library->mapping = buffer;++ /* Parse the header */+ if(ZDParseHeader(library)) {+ zdError(ZD_E_PARSE_HEADER, 0);+ goto fail;+ }+ }++ return library;++fail:+ ZDCloseDatabase(library);+ return NULL;+}++ZoneDetect *ZDOpenDatabase(const char *path)+{+ ZoneDetect *const library = malloc(sizeof *library);++ if(library) {+ memset(library, 0, sizeof(*library));++#if defined(_MSC_VER) || defined(__MINGW32__)+ library->fd = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);+ if (library->fd == INVALID_HANDLE_VALUE) {+ zdError(ZD_E_DB_OPEN, (int)GetLastError());+ goto fail;+ }++ const DWORD fsize = GetFileSize(library->fd, NULL);+ if (fsize == INVALID_FILE_SIZE) {+ zdError(ZD_E_DB_SEEK, (int)GetLastError());+ goto fail;+ }+ library->length = (int32_t)fsize;++ library->fdMap = CreateFileMappingA(library->fd, NULL, PAGE_READONLY, 0, 0, NULL);+ if (!library->fdMap) {+ zdError(ZD_E_DB_MMAP, (int)GetLastError());+ goto fail;+ }++ library->mapping = MapViewOfFile(library->fdMap, FILE_MAP_READ, 0, 0, 0);+ if (!library->mapping) {+ zdError(ZD_E_DB_MMAP_MSVIEW, (int)GetLastError());+ goto fail;+ }+#else+ library->fd = open(path, O_RDONLY | O_CLOEXEC);+ if(library->fd < 0) {+ zdError(ZD_E_DB_OPEN, errno);+ goto fail;+ }++ library->length = lseek(library->fd, 0, SEEK_END);+ if(library->length <= 0 || library->length > 50331648) {+ zdError(ZD_E_DB_SEEK, errno);+ goto fail;+ }+ lseek(library->fd, 0, SEEK_SET);++ library->mapping = mmap(NULL, (size_t)library->length, PROT_READ, MAP_PRIVATE | MAP_FILE, library->fd, 0);+ if(library->mapping == MAP_FAILED) {+ zdError(ZD_E_DB_MMAP, errno);+ goto fail;+ }+#endif++ /* Parse the header */+ if(ZDParseHeader(library)) {+ zdError(ZD_E_PARSE_HEADER, 0);+ goto fail;+ }+ }++ return library;++fail:+ ZDCloseDatabase(library);+ return NULL;+}++ZoneDetectResult *ZDLookup(const ZoneDetect *library, float lat, float lon, float *safezone)+{+ const int32_t latFixedPoint = ZDFloatToFixedPoint(lat, 90, library->precision);+ const int32_t lonFixedPoint = ZDFloatToFixedPoint(lon, 180, library->precision);+ size_t numResults = 0;+ uint64_t distanceSqrMin = (uint64_t)-1;++ /* Iterate over all polygons */+ uint32_t bboxIndex = library->bboxOffset;+ uint32_t metadataIndex = 0;+ uint32_t polygonIndex = 0;++ ZoneDetectResult *results = malloc(sizeof *results);+ if(!results) {+ return NULL;+ }++ uint32_t polygonId = 0;++ while(bboxIndex < library->metadataOffset) {+ int32_t minLat, minLon, maxLat, maxLon, metadataIndexDelta;+ uint64_t polygonIndexDelta;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &minLat)) break;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &minLon)) break;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &maxLat)) break;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &maxLon)) break;+ if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &metadataIndexDelta)) break;+ if(!ZDDecodeVariableLengthUnsigned(library, &bboxIndex, &polygonIndexDelta)) break;++ metadataIndex += (uint32_t)metadataIndexDelta;+ polygonIndex += (uint32_t)polygonIndexDelta;++ if(latFixedPoint >= minLat) {+ if(latFixedPoint <= maxLat &&+ lonFixedPoint >= minLon &&+ lonFixedPoint <= maxLon) {++ const ZDLookupResult lookupResult = ZDPointInPolygon(library, library->dataOffset + polygonIndex, latFixedPoint, lonFixedPoint, (safezone) ? &distanceSqrMin : NULL);+ if(lookupResult == ZD_LOOKUP_PARSE_ERROR) {+ break;+ } else if(lookupResult != ZD_LOOKUP_NOT_IN_ZONE) {+ ZoneDetectResult *const newResults = realloc(results, sizeof *newResults * (numResults + 2));++ if(newResults) {+ results = newResults;+ results[numResults].polygonId = polygonId;+ results[numResults].metaId = metadataIndex;+ results[numResults].numFields = library->numFields;+ results[numResults].fieldNames = library->fieldNames;+ results[numResults].lookupResult = lookupResult;++ numResults++;+ } else {+ break;+ }+ }+ }+ } else {+ /* The data is sorted along minLat */+ break;+ }++ polygonId++;+ }++ /* Clean up results */+ for(size_t i = 0; i < numResults; i++) {+ int insideSum = 0;+ ZDLookupResult overrideResult = ZD_LOOKUP_IGNORE;+ for(size_t j = i; j < numResults; j++) {+ if(results[i].metaId == results[j].metaId) {+ ZDLookupResult tmpResult = results[j].lookupResult;+ results[j].lookupResult = ZD_LOOKUP_IGNORE;++ /* This is the same result. Is it an exclusion zone? */+ if(tmpResult == ZD_LOOKUP_IN_ZONE) {+ insideSum++;+ } else if(tmpResult == ZD_LOOKUP_IN_EXCLUDED_ZONE) {+ insideSum--;+ } else {+ /* If on the bodrder then the final result is on the border */+ overrideResult = tmpResult;+ }++ }+ }++ if(overrideResult != ZD_LOOKUP_IGNORE) {+ results[i].lookupResult = overrideResult;+ } else {+ if(insideSum) {+ results[i].lookupResult = ZD_LOOKUP_IN_ZONE;+ }+ }+ }++ /* Remove zones to ignore */+ size_t newNumResults = 0;+ for(size_t i = 0; i < numResults; i++) {+ if(results[i].lookupResult != ZD_LOOKUP_IGNORE) {+ results[newNumResults] = results[i];+ newNumResults++;+ }+ }+ numResults = newNumResults;++ /* Lookup metadata */+ for(size_t i = 0; i < numResults; i++) {+ uint32_t tmpIndex = library->metadataOffset + results[i].metaId;+ results[i].data = malloc(library->numFields * sizeof *results[i].data);+ if(results[i].data) {+ for(size_t j = 0; j < library->numFields; j++) {+ results[i].data[j] = ZDParseString(library, &tmpIndex);+ }+ }+ }++ /* Write end marker */+ results[numResults].lookupResult = ZD_LOOKUP_END;+ results[numResults].numFields = 0;+ results[numResults].fieldNames = NULL;+ results[numResults].data = NULL;++ if(safezone) {+ *safezone = sqrtf((float)distanceSqrMin) * 90 / (float)(1 << (library->precision - 1));+ }++ return results;+}++void ZDFreeResults(ZoneDetectResult *results)+{+ unsigned int index = 0;++ if(!results) {+ return;+ }++ while(results[index].lookupResult != ZD_LOOKUP_END) {+ if(results[index].data) {+ for(size_t i = 0; i < (size_t)results[index].numFields; i++) {+ if(results[index].data[i]) {+ free(results[index].data[i]);+ }+ }+ free(results[index].data);+ }+ index++;+ }+ free(results);+}++const char *ZDGetNotice(const ZoneDetect *library)+{+ return library->notice;+}++uint8_t ZDGetTableType(const ZoneDetect *library)+{+ return library->tableType;+}++const char *ZDLookupResultToString(ZDLookupResult result)+{+ switch(result) {+ case ZD_LOOKUP_IGNORE:+ return "Ignore";+ case ZD_LOOKUP_END:+ return "End";+ case ZD_LOOKUP_PARSE_ERROR:+ return "Parsing error";+ case ZD_LOOKUP_NOT_IN_ZONE:+ return "Not in zone";+ case ZD_LOOKUP_IN_ZONE:+ return "In zone";+ case ZD_LOOKUP_IN_EXCLUDED_ZONE:+ return "In excluded zone";+ case ZD_LOOKUP_ON_BORDER_VERTEX:+ return "Target point is border vertex";+ case ZD_LOOKUP_ON_BORDER_SEGMENT:+ return "Target point is on border";+ }++ return "Unknown";+}++#define ZD_E_COULD_NOT(msg) "could not " msg++const char *ZDGetErrorString(int errZD)+{+ switch ((enum ZDInternalError)errZD) {+ default:+ assert(0);+ case ZD_OK :+ return "";+ case ZD_E_DB_OPEN :+ return ZD_E_COULD_NOT("open database file");+ case ZD_E_DB_SEEK :+ return ZD_E_COULD_NOT("retrieve database file size");+ case ZD_E_DB_MMAP :+ return ZD_E_COULD_NOT("map database file to system memory");+#if defined(_MSC_VER) || defined(__MINGW32__)+ case ZD_E_DB_MMAP_MSVIEW :+ return ZD_E_COULD_NOT("open database file view");+ case ZD_E_DB_MAP_EXCEPTION:+ return "I/O exception occurred while accessing database file view";+ case ZD_E_DB_MUNMAP_MSVIEW:+ return ZD_E_COULD_NOT("close database file view");+#endif+ case ZD_E_DB_MUNMAP :+ return ZD_E_COULD_NOT("unmap database");+ case ZD_E_DB_CLOSE :+ return ZD_E_COULD_NOT("close database file");+ case ZD_E_PARSE_HEADER :+ return ZD_E_COULD_NOT("parse database header");+ }+}++#undef ZD_E_COULD_NOT++int ZDSetErrorHandler(void (*handler)(int, int))+{+ zdErrorHandler = handler;+ return 0;+}++char* ZDHelperSimpleLookupString(const ZoneDetect* library, float lat, float lon)+{+ ZoneDetectResult *result = ZDLookup(library, lat, lon, NULL);+ if(!result) {+ return NULL;+ }++ char* output = NULL;++ if(result[0].lookupResult == ZD_LOOKUP_END) {+ goto done;+ }++ char* strings[2] = {NULL};++ for(unsigned int i = 0; i < result[0].numFields; i++) {+ if(result[0].fieldNames[i] && result[0].data[i]) {+ if(library->tableType == 'T') {+ if(!strcmp(result[0].fieldNames[i], "TimezoneIdPrefix")) {+ strings[0] = result[0].data[i];+ }+ if(!strcmp(result[0].fieldNames[i], "TimezoneId")) {+ strings[1] = result[0].data[i];+ }+ }+ if(library->tableType == 'C') {+ if(!strcmp(result[0].fieldNames[i], "Name")) {+ strings[0] = result[0].data[i];+ }+ }+ }+ }++ size_t length = 0;+ for(unsigned int i=0; i<sizeof(strings)/sizeof(char*); i++) {+ if(strings[i]) {+ size_t partLength = strlen(strings[i]);+ if(partLength > 512) {+ goto done;+ }+ length += partLength;+ }+ }++ if(length == 0) {+ goto done;+ }++ length += 1;++ output = (char*)malloc(length);+ output[0] = 0;+ for(unsigned int i=0; i<sizeof(strings)/sizeof(char*); i++) {+ if(strings[i]) {+ strcat(output + strlen(output), strings[i]);+ }+ }++done:+ ZDFreeResults(result);+ return output;+}
+ csrc/zonedetect.h view
@@ -0,0 +1,91 @@+/*+ * Copyright (c) 2018, Bertold Van den Bergh (vandenbergh@bertold.org)+ * All rights reserved.+ *+ * Redistribution and use in source and binary forms, with or without+ * modification, are permitted provided that the following conditions are met:+ * * Redistributions of source code must retain the above copyright+ * notice, this list of conditions and the following disclaimer.+ * * Redistributions in binary form must reproduce the above copyright+ * notice, this list of conditions and the following disclaimer in the+ * documentation and/or other materials provided with the distribution.+ * * Neither the name of the author nor the+ * names of its contributors may be used to endorse or promote products+ * derived from this software without specific prior written permission.+ *+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTOR BE LIABLE FOR ANY+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+ */++#include <stdint.h>++#ifndef INCL_ZONEDETECT_H_+#define INCL_ZONEDETECT_H_++#if !defined(ZD_EXPORT)+#if defined(_MSC_VER)+#define ZD_EXPORT __declspec(dllimport)+#else+#define ZD_EXPORT+#endif+#endif++typedef enum {+ ZD_LOOKUP_IGNORE = -3,+ ZD_LOOKUP_END = -2,+ ZD_LOOKUP_PARSE_ERROR = -1,+ ZD_LOOKUP_NOT_IN_ZONE = 0,+ ZD_LOOKUP_IN_ZONE = 1,+ ZD_LOOKUP_IN_EXCLUDED_ZONE = 2,+ ZD_LOOKUP_ON_BORDER_VERTEX = 3,+ ZD_LOOKUP_ON_BORDER_SEGMENT = 4+} ZDLookupResult;++typedef struct {+ ZDLookupResult lookupResult;++ uint32_t polygonId;+ uint32_t metaId;+ uint8_t numFields;+ char **fieldNames;+ char **data;+} ZoneDetectResult;++struct ZoneDetectOpaque;+typedef struct ZoneDetectOpaque ZoneDetect;++#ifdef __cplusplus+extern "C" {+#endif++ZD_EXPORT ZoneDetect *ZDOpenDatabase(const char *path);+ZD_EXPORT ZoneDetect *ZDOpenDatabaseFromMemory(void* buffer, size_t length);+ZD_EXPORT void ZDCloseDatabase(ZoneDetect *library);++ZD_EXPORT ZoneDetectResult *ZDLookup(const ZoneDetect *library, float lat, float lon, float *safezone);+ZD_EXPORT void ZDFreeResults(ZoneDetectResult *results);++ZD_EXPORT const char *ZDGetNotice(const ZoneDetect *library);+ZD_EXPORT uint8_t ZDGetTableType(const ZoneDetect *library);+ZD_EXPORT const char *ZDLookupResultToString(ZDLookupResult result);++ZD_EXPORT int ZDSetErrorHandler(void (*handler)(int, int));+ZD_EXPORT const char *ZDGetErrorString(int errZD);++ZD_EXPORT float* ZDPolygonToList(const ZoneDetect *library, uint32_t polygonId, size_t* length);++ZD_EXPORT char* ZDHelperSimpleLookupString(const ZoneDetect* library, float lat, float lon);++#ifdef __cplusplus+}+#endif++#endif // INCL_ZONEDETECT_H_
+ src/Foreign/ZoneDetect.hsc view
@@ -0,0 +1,34 @@+{-# LANGUAGE CPP, ForeignFunctionInterface #-}++module Foreign.ZoneDetect where++import Foreign+import Foreign.C.Types+import Foreign.C.String++#include <zonedetect.h>++-- https://github.com/BertoldVdb/ZoneDetect/blob/05567e367576d7f3efa00083b7661a01e43dc8ca/library/zonedetect.c#L61+-- note that we define the non-Windows version. This library will not compile in Windows systems! (sorry, I just+-- don't know enough Haskell CPP directive-fu yet!)+data ZoneDetectInfo = ZoneDetectInfo+ { fd :: Int+ , length :: CInt -- as per: https://hackage.haskell.org/package/bindings-posix-1.2.4/docs/Bindings-Posix-Sys-Types.html+ , closeType :: Word8+ , mapping :: Ptr Word8+ , tableType :: Word8+ , version :: Word8+ , precision :: Word8+ , numFields :: Word8+ , notice :: CString+ , fieldNames :: Ptr CString+ , bboxOffset :: Word32+ , metadataOffset :: Word32+ , dataOffset :: Word32+ }++foreign import ccall unsafe "zonedetect.h ZDOpenDatabase"+ c_ZDOpenDatabase :: CString -> IO (Ptr ZoneDetectInfo)++foreign import ccall unsafe "zonedetect.h ZDHelperSimpleLookupString"+ c_ZDHelperSimpleLookupString :: Ptr ZoneDetectInfo -> CFloat -> CFloat -> IO CString
+ src/TimezoneDetect.hs view
@@ -0,0 +1,47 @@+{-|+Module: TimezoneDetect+Portability: POSIX++Exposes utilities derived from the excellent ZoneDetect library <https://github.com/BertoldVdb/ZoneDetect>.+To use this module, you need to obtain database files from the aforementioned library's server.++Currently, only one function for looking up the name of a Timezone is provided, but the underlying+library also has richer functions for opening timezone database files, finding applicable zones, etc.+-}++module TimezoneDetect where++import Foreign.ZoneDetect+import System.IO.Unsafe (unsafePerformIO)+import Foreign.C.String (peekCAString, withCAString)+import Foreign (nullPtr)++-- | Alias for clarity, timezones are short strings that follow the IANA conventions+-- documented here:+-- https://data.iana.org/time-zones/tz-link.html+type TimezoneName = String++-- | Given a timezone database, latitude and longitude, try to determine the+-- timezone name. Follow the instructions in the C library's repository+-- to obtain timezone database files (<https://github.com/BertoldVdb/ZoneDetect/tree/05567e367576d7f3efa00083b7661a01e43dc8ca/database>)+-- Once in possesion of said files, the lookup looks as follows:+-- +-- >>> lookupTimezone "./test/tz_db/timezone21.bin" 40.7831 (-73.9712)+-- Right "America/New_York"+-- +-- Failure conditions are: invalid database file, or invalid coordinates,+-- both are returned as `Left` values.+lookupTimezone :: FilePath -> Float -> Float -> Either String TimezoneName+lookupTimezone databaseLocation lat lng =+ unsafePerformIO $ do+ zdPtr <- withCAString databaseLocation $ \dbl -> c_ZDOpenDatabase dbl+ if zdPtr == nullPtr then+ pure $ Left (databaseLocation <> " is not a valid timezone database.")+ else do+ tzName <- c_ZDHelperSimpleLookupString zdPtr+ (realToFrac lat)+ (realToFrac lng)+ if tzName == nullPtr then+ pure $ Left "Invalid coordinates."+ else+ peekCAString tzName >>= (pure . Right)
+ test/Spec.hs view
@@ -0,0 +1,1 @@+{-# OPTIONS_GHC -F -pgmF hspec-discover #-}
+ test/TimezoneDetectSpec.hs view
@@ -0,0 +1,27 @@+module TimezoneDetectSpec (spec) where++import TimezoneDetect+import Test.Hspec++zoneFile :: FilePath+zoneFile = "./test/tz_db/timezone21.bin"++lookupTimezone' :: Float -> Float -> Either String TimezoneName+lookupTimezone' = lookupTimezone zoneFile++spec :: Spec+spec = do+ describe "lookupTimezone" $ do+ it "calculates coordinates for known locations" $ do+ let newYork = lookupTimezone' 40.7831 (-73.9712)+ let tegucigalpa = lookupTimezone' 14.0650 (-87.1715)+ newYork `shouldBe` (Right "America/New_York")+ tegucigalpa `shouldBe` (Right "America/Tegucigalpa")++ it "returns an error value when given an invalid timezone file path" $ do+ let wrong = lookupTimezone "bogus" 0.0 0.0+ wrong `shouldBe` (Left "bogus is not a valid timezone database.")++ it "returns an error value when given invalid coordinates" $ do+ let outOfThisWorld = lookupTimezone' 40000000.7 (-73.97)+ outOfThisWorld `shouldBe` (Left "Invalid coordinates.")
+ timezone-detect.cabal view
@@ -0,0 +1,64 @@+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.33.0.+--+-- see: https://github.com/sol/hpack+--+-- hash: 38d5e310ad4b828f71ddd087380182d12af2a28c1d0f6c071a85581c34f499fa++name: timezone-detect+version: 0.1.0.0+synopsis: Haskell bindings for the zone-detect C library+description: Please see the README on GitHub at <https://github.com/lfborjas/timezone-detect#readme>+category: Data, Foreign+homepage: https://github.com/lfborjas/timezone-detect#readme+bug-reports: https://github.com/lfborjas/timezone-detect/issues+author: Luis Borjas Reyes+maintainer: timezone-detect@lfborjas.com+license: GPL-2+license-file: LICENSE+build-type: Simple+extra-source-files:+ README.md+ ChangeLog.md++source-repository head+ type: git+ location: https://github.com/lfborjas/timezone-detect++library+ exposed-modules:+ Foreign.ZoneDetect+ TimezoneDetect+ other-modules:+ Paths_timezone_detect+ hs-source-dirs:+ src+ ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wpartial-fields -Wredundant-constraints+ include-dirs:+ csrc+ install-includes:+ csrc/zonedetect.h+ c-sources:+ csrc/zonedetect.c+ build-depends:+ base >=4.7 && <4.14+ default-language: Haskell2010++test-suite timezone-detect-test+ type: exitcode-stdio-1.0+ main-is: Spec.hs+ other-modules:+ TimezoneDetectSpec+ Paths_timezone_detect+ hs-source-dirs:+ test+ ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N+ build-tool-depends:+ hspec-discover:hspec-discover >=2.7 && <2.8+ build-depends:+ base >=4.7 && <4.14+ , directory >=1.3 && <1.4+ , hspec >=2.7 && <2.8+ , timezone-detect+ default-language: Haskell2010