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/Database.h>
#include <osmscout/Location.h>

#include <osmscout/TypeInfoSet.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:
    inline 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
    }

    inline ObjectFileRef GetRef() const
    {
      return ref;
    }

    inline std::string GetName() const
    {
      return name;
    }

    inline Distance GetDistance() const
    {
      return distance;
    }

    inline Bearing GetBearing() const
    {
      return bearing;
    }

    inline bool IsAtPlace() const
    {
      return atPlace;
    }

    inline 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);

    inline Place GetPlace() const
    {
      return place;
    }

    inline bool IsAtPlace() const
    {
      return atPlace;
    }

    inline Distance GetDistance() const
    {
      return distance;
    }

    inline 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);
    inline Place GetWay() const
    {
      return way;
    }

    inline 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);
    inline std::list<Place> GetWays() const
    {
      return ways;
    }

    inline bool IsAtPlace() const
    {
      return atPlace;
    }

    inline Distance GetDistance() const
    {
      return distance;
    }

    inline Bearing GetBearing() const
    {
      return bearing;
    }

    inline 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