LCOV - code coverage report
Current view: top level - geospatial - latlongcoord.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 7028d852e609 Lines: 57 64 89.1 %
Date: 2019-02-17 14:59:59 Functions: 8 8 100.0 %
Branches: 38 86 44.2 %

           Branch data     Line data    Source code
       1                 :            : /** @file latlongcoord.cc
       2                 :            :  * @brief Latitude and longitude representations.
       3                 :            :  */
       4                 :            : /* Copyright 2008 Lemur Consulting Ltd
       5                 :            :  * Copyright 2011 Richard Boulton
       6                 :            :  *
       7                 :            :  * This program is free software; you can redistribute it and/or
       8                 :            :  * modify it under the terms of the GNU General Public License as
       9                 :            :  * published by the Free Software Foundation; either version 2 of the
      10                 :            :  * License, or (at your option) any later version.
      11                 :            :  *
      12                 :            :  * This program is distributed in the hope that it will be useful,
      13                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            :  * GNU General Public License for more details.
      16                 :            :  *
      17                 :            :  * You should have received a copy of the GNU General Public License
      18                 :            :  * along with this program; if not, write to the Free Software
      19                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
      20                 :            :  * USA
      21                 :            :  */
      22                 :            : 
      23                 :            : #include <config.h>
      24                 :            : 
      25                 :            : #include "xapian/geospatial.h"
      26                 :            : #include "xapian/error.h"
      27                 :            : 
      28                 :            : #include "geoencode.h"
      29                 :            : #include "str.h"
      30                 :            : 
      31                 :            : #include <cmath>
      32                 :            : 
      33                 :            : using namespace Xapian;
      34                 :            : using namespace std;
      35                 :            : 
      36                 :         25 : LatLongCoord::LatLongCoord(double latitude_, double longitude_)
      37                 :            :         : latitude(latitude_),
      38                 :         25 :           longitude(longitude_)
      39                 :            : {
      40 [ +  - ][ -  + ]:         25 :     if (latitude < -90.0 || latitude > 90.0)
      41 [ #  # ][ #  # ]:          0 :         throw InvalidArgumentError("Latitude out-of-range");
                 [ #  # ]
      42                 :         25 :     longitude = fmod(longitude_, 360);
      43         [ -  + ]:         25 :     if (longitude < 0) longitude += 360;
      44                 :         25 : }
      45                 :            : 
      46                 :            : void
      47                 :          2 : LatLongCoord::unserialise(const string & serialised)
      48                 :            : {
      49                 :          2 :     const char * ptr = serialised.data();
      50                 :          2 :     const char * end = ptr + serialised.size();
      51         [ +  - ]:          2 :     unserialise(&ptr, end);
      52         [ -  + ]:          2 :     if (ptr != end)
      53                 :            :         throw SerialisationError(
      54 [ #  # ][ #  # ]:          0 :                 "Junk found at end of serialised LatLongCoord");
                 [ #  # ]
      55                 :          2 : }
      56                 :            : 
      57                 :            : void
      58                 :         69 : LatLongCoord::unserialise(const char ** ptr, const char * end)
      59                 :            : {
      60                 :         69 :     size_t len = end - *ptr;
      61         [ -  + ]:         69 :     if (len < 2) {
      62                 :          0 :         latitude = 0;
      63                 :          0 :         longitude = 0;
      64                 :          0 :         return;
      65                 :            :     }
      66                 :         69 :     GeoEncode::decode(*ptr, end - *ptr, latitude, longitude);
      67         [ -  + ]:         69 :     if (len < 6) {
      68                 :          0 :         *ptr = end;
      69                 :            :     } else {
      70                 :         69 :         *ptr += 6;
      71                 :            :     }
      72                 :            : }
      73                 :            : 
      74                 :            : string
      75                 :         18 : LatLongCoord::serialise() const
      76                 :            : {
      77                 :         18 :     string result;
      78         [ +  - ]:         18 :     GeoEncode::encode(latitude, longitude, result);
      79                 :         18 :     return result;
      80                 :            : }
      81                 :            : 
      82                 :            : string
      83                 :          9 : LatLongCoord::get_description() const
      84                 :            : {
      85         [ +  - ]:          9 :     string res("Xapian::LatLongCoord(");
      86 [ +  - ][ +  - ]:          9 :     res += str(latitude);
      87         [ +  - ]:          9 :     res += ", ";
      88 [ +  - ][ +  - ]:          9 :     res += str(longitude);
      89         [ +  - ]:          9 :     res += ")";
      90                 :          9 :     return res;
      91                 :            : }
      92                 :            : 
      93                 :            : void
      94                 :          4 : LatLongCoords::unserialise(const string & serialised)
      95                 :            : {
      96                 :          4 :     const char * ptr = serialised.data();
      97                 :          4 :     const char * end_ptr = ptr + serialised.size();
      98                 :          4 :     coords.clear();
      99         [ +  + ]:          9 :     while (ptr != end_ptr) {
     100         [ +  - ]:          5 :         coords.push_back(LatLongCoord());
     101         [ +  - ]:          5 :         coords.back().unserialise(&ptr, end_ptr);
     102                 :            :     }
     103         [ -  + ]:          4 :     if (ptr != end_ptr) {
     104                 :            :         throw SerialisationError("Junk found at end of serialised "
     105 [ #  # ][ #  # ]:          0 :                                  "LatLongCoords");
                 [ #  # ]
     106                 :            :     }
     107                 :          4 : }
     108                 :            : 
     109                 :            : string
     110                 :          2 : LatLongCoords::serialise() const
     111                 :            : {
     112         [ +  - ]:          2 :     string result;
     113                 :          2 :     vector<LatLongCoord>::const_iterator coord;
     114         [ +  + ]:          5 :     for (coord = coords.begin(); coord != coords.end(); ++coord)
     115                 :            :     {
     116         [ +  - ]:          3 :         GeoEncode::encode(coord->latitude, coord->longitude, result);
     117                 :            :     }
     118                 :          2 :     return result;
     119                 :            : }
     120                 :            : 
     121                 :            : string
     122                 :          4 : LatLongCoords::get_description() const
     123                 :            : {
     124         [ +  - ]:          4 :     string res("Xapian::LatLongCoords(");
     125                 :          4 :     vector<LatLongCoord>::const_iterator coord;
     126         [ +  + ]:         10 :     for (coord = coords.begin(); coord != coords.end(); ++coord) {
     127         [ +  + ]:          6 :         if (coord != coords.begin()) {
     128         [ +  - ]:          3 :             res += ", ";
     129                 :            :         }
     130         [ +  - ]:          6 :         res += "(";
     131 [ +  - ][ +  - ]:          6 :         res += str(coord->latitude);
     132         [ +  - ]:          6 :         res += ", ";
     133 [ +  - ][ +  - ]:          6 :         res += str(coord->longitude);
     134         [ +  - ]:          6 :         res += ")";
     135                 :            :     }
     136         [ +  - ]:          4 :     res += ")";
     137                 :          4 :     return res;
     138                 :            : }

Generated by: LCOV version 1.11