LocationDescriptionService.h

Go to the documentation of this file.

#ifndef OSMSCOUT_LOCATIONDESCRIPTIONSERVICE_H
#define OSMSCOUT_LOCATIONDESCRIPTIONSERVICE_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2017  Tim Teulings
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library 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
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/
 
#include <list>
#include <memory>
 
#include <osmscout/TypeInfoSet.h>
 
#include <osmscout/db/Database.h>
 
#include <osmscout/location/Location.h>
 
#include <osmscout/util/StringMatcher.h>
 
namespace osmscout {

  class OSMSCOUT_API LocationCoordDescription CLASS_FINAL
  {
  private:
    GeoCoord location;
 
  public:
    explicit LocationCoordDescription(const GeoCoord& location);
 
    GeoCoord GetLocation() const;
  };

  using LocationCoordDescriptionRef = std::shared_ptr<LocationCoordDescription>;
 
  class OSMSCOUT_API LocationDescriptionCandicate CLASS_FINAL
  {
  private:
    ObjectFileRef ref;      
    std::string   name;     
    Distance      distance; 
    Bearing       bearing;  
    bool          atPlace;  
    double        size;     
 
  public:
    LocationDescriptionCandicate(const ObjectFileRef& ref,
                                 const std::string& name,
                                 const Distance& distance,
                                 const Bearing& bearing,
                                 const bool atPlace,
                                 const double size)
    : ref(ref),
      name(name),
      distance(distance),
      bearing(bearing),
      atPlace(atPlace),
      size(size)
    {
      // no code
    }
 
    ObjectFileRef GetRef() const
    {
      return ref;
    }
 
    std::string GetName() const
    {
      return name;
    }
 
    Distance GetDistance() const
    {
      return distance;
    }
 
    Bearing GetBearing() const
    {
      return bearing;
    }
 
    bool IsAtPlace() const
    {
      return atPlace;
    }
 
    double GetSize() const
    {
      return size;
    }
  };

  class OSMSCOUT_API LocationAtPlaceDescription CLASS_FINAL
  {
  private:
    Place    place;     
    bool     atPlace;   
    Distance distance;  
    Bearing  bearing;   
 
  public:
    explicit LocationAtPlaceDescription(const Place& place);
    LocationAtPlaceDescription(const Place& place,
                               const Distance &distance,
                               const Bearing &bearing);

    Place GetPlace() const
    {
      return place;
    }

    bool IsAtPlace() const
    {
      return atPlace;
    }

    Distance GetDistance() const
    {
      return distance;
    }

    Bearing GetBearing() const
    {
      return bearing;
    }
  };

  using LocationAtPlaceDescriptionRef = std::shared_ptr<LocationAtPlaceDescription>;

  class OSMSCOUT_API LocationWayDescription CLASS_FINAL
  {
  private:
    Place    way;      
    Distance distance; 
 
  public:
    explicit LocationWayDescription(const Place& way);
 
    LocationWayDescription(const Place& way,
                           const Distance &distance);
    Place GetWay() const
    {
      return way;
    }

    Distance GetDistance() const
    {
      return distance;
    }
  };

  using LocationWayDescriptionRef = std::shared_ptr<LocationWayDescription>;

  class OSMSCOUT_API LocationCrossingDescription CLASS_FINAL
  {
  private:
    GeoCoord         crossing;  
    bool             atPlace;   
    std::list<Place> ways;      
    Distance         distance;  
    Bearing          bearing;   
 
  public:
    LocationCrossingDescription(const GeoCoord& crossing,
                                const std::list<Place>& ways);
 
    LocationCrossingDescription(const GeoCoord& crossing,
                                const std::list<Place>& ways,
                                const Distance &distance,
                                const Bearing &bearing);
    std::list<Place> GetWays() const
    {
      return ways;
    }

    bool IsAtPlace() const
    {
      return atPlace;
    }

    Distance GetDistance() const
    {
      return distance;
    }

    Bearing GetBearing() const
    {
      return bearing;
    }
 
    GeoCoord GetCrossing() const
    {
      return crossing;
    }
  };

  using LocationCrossingDescriptionRef = std::shared_ptr<LocationCrossingDescription>;

  class OSMSCOUT_API LocationDescription CLASS_FINAL
  {
  private:
    LocationCoordDescriptionRef    coordDescription;
    LocationAtPlaceDescriptionRef  atNameDescription;
    LocationAtPlaceDescriptionRef  atAddressDescription;
    LocationAtPlaceDescriptionRef  atPOIDescription;
    LocationWayDescriptionRef      wayDescription;
    LocationCrossingDescriptionRef crossingDescription;
 
  public:
    void SetCoordDescription(const LocationCoordDescriptionRef& description);
    void SetAtNameDescription(const LocationAtPlaceDescriptionRef& description);
    void SetAtAddressDescription(const LocationAtPlaceDescriptionRef& description);
    void SetAtPOIDescription(const LocationAtPlaceDescriptionRef& description);
    void SetWayDescription(const LocationWayDescriptionRef& description);
    void SetCrossingDescription(const LocationCrossingDescriptionRef& description);

    LocationCoordDescriptionRef GetCoordDescription() const;

    LocationAtPlaceDescriptionRef GetAtNameDescription() const;

    LocationAtPlaceDescriptionRef GetAtAddressDescription() const;

    LocationAtPlaceDescriptionRef GetAtPOIDescription() const;

    LocationWayDescriptionRef GetWayDescription() const;

    LocationCrossingDescriptionRef GetCrossingDescription() const;
  };

  class OSMSCOUT_API LocationDescriptionService
  {
  public:
    struct OSMSCOUT_API ReverseLookupResult
    {
      ObjectFileRef  object;      
      AdminRegionRef adminRegion; 
      PostalAreaRef  postalArea;  
      POIRef         poi;         
      LocationRef    location;    
      AddressRef     address;     
    };
 
    using ReverseLookupRef = std::shared_ptr<ReverseLookupResult>;
 
  private:
    DatabaseRef database;
 
  private:
    static bool DistanceComparator(const LocationDescriptionCandicate &a,
                                   const LocationDescriptionCandicate &b);
 
    const FeatureValueBufferRef GetObjectFeatureBuffer(const ObjectFileRef &object);
 
    Place GetPlace(const std::list<ReverseLookupResult>& lookupResult);
 
    bool VisitAdminRegions(AdminRegionVisitor& visitor) const;
 
    void AddToCandidates(std::vector<LocationDescriptionCandicate>& candidates,
                         const GeoCoord& location,
                         const NodeRegionSearchResult& results,
                         bool requireAddress,
                         bool requireName);
    void AddToCandidates(std::vector<LocationDescriptionCandicate>& candidates,
                         const GeoCoord& location,
                         const WayRegionSearchResult& results);
    void AddToCandidates(std::vector<LocationDescriptionCandicate>& candidates,
                         const GeoCoord& location,
                         const AreaRegionSearchResult& results,
                         bool requireAddress,
                         bool requireName);
 
  public:
    explicit LocationDescriptionService(const DatabaseRef& database);
 
    bool ReverseLookupRegion(const GeoCoord &coord,
                             std::list<ReverseLookupResult>& result) const;
 
    bool ReverseLookupObjects(const std::list<ObjectFileRef>& objects,
                              std::list<ReverseLookupResult>& result) const;
    bool ReverseLookupObject(const ObjectFileRef& object,
                              std::list<ReverseLookupResult>& result) const;
 
    bool DescribeLocation(const GeoCoord& location,
                          LocationDescription& description,
                          const Distance& lookupDistance=Distance::Of<Meter>(100),
                          double sizeFilter=1.0);
 
    bool DescribeLocationByName(const GeoCoord& location,
                                LocationDescription& description,
                                const Distance& lookupDistance=Distance::Of<Meter>(100),
                                double sizeFilter=1.0);
 
    bool DescribeLocationByAddress(const GeoCoord& location,
                                   LocationDescription& description,
                                   const Distance& lookupDistance=Distance::Of<Meter>(100),
                                   double sizeFilter=1.0);
 
    bool DescribeLocationByPOI(const GeoCoord& location,
                               LocationDescription& description,
                               const Distance& lookupDistance=Distance::Of<Meter>(100),
                               double sizeFilter=1.0);
 
    bool DescribeLocationByCrossing(const GeoCoord& location,
                                    LocationDescription& description,
                                    const Distance& lookupDistance=Distance::Of<Meter>(100));
 
    bool DescribeLocationByWay(const GeoCoord& location,
                               LocationDescription& description,
                               const Distance& lookupDistance=Distance::Of<Meter>(100));
  };

  using LocationDescriptionServiceRef = std::shared_ptr<LocationDescriptionService>;
}
 
 
#endif