Store.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: MIT
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include <map>
#include <memory>
 
#include "ad/map/access/Types.hpp"
#include "ad/map/landmark/Types.hpp"
#include "ad/map/lane/Types.hpp"
#include "ad/map/serialize/ISerializer.hpp"
 
namespace ad {
namespace map {
 
namespace match {
class AdMapMatching;
}
 
namespace access {
 
class GeometryStore;
 
class Store
{
  friend class Factory;
  friend class match::AdMapMatching;
 
public:                               // Derived types
  typedef std::shared_ptr<Store> Ptr; 
 
  Store();
 
  Store(Store const &other) = delete;
 
  Store(Store &&other) = delete;
 
  Store &operator=(Store const &other) = delete;
 
  Store &operator=(Store &&other) = delete;
 
  virtual ~Store();
 
public: // Main Operations
  bool save(serialize::ISerializer &serializer,
            bool use_magic = true,
            bool use_embedded_geometry = true,
            bool use_geometry_store = false);
 
  bool load(serialize::ISerializer &serializer);
 
  bool empty() const;
 
public: // Access Operations
  MapMetaData const &getMetaData() const;
 
  PartitionIdList getPartitions() const;
 
  lane::Lane::ConstPtr getLanePtr(lane::LaneId const &id) const;
 
  lane::LaneIdList getLanes() const;
 
  lane::LaneIdList getLanes(PartitionId const &partition_id) const;
 
  lane::LaneIdList getLanes(std::string const &type_filter, bool is_hov) const;
 
  lane::LaneIdList getLanes(PartitionId partition_id, std::string const &type_filter, bool is_hov) const;
 
  landmark::LandmarkIdList getLandmarks(PartitionId partition_id) const;
 
  landmark::Landmark::ConstPtr getLandmarkPtr(landmark::LandmarkId id) const;
 
  landmark::LandmarkIdList getLandmarks() const;
 
  void removePartition(PartitionId partition_id);
 
  physics::Distance getCumulativeLaneLength() const;
 
  bool isValid() const;
 
  point::BoundingSphere getBoundingSphere() const;
 
private:
  bool serialize(serialize::ISerializer &serializer);
  bool storeGeometry(GeometryStore &gs);
 
  bool restoreGeometry(const GeometryStore &gs);
 
  bool checkGeometry(const GeometryStore &gs);
 
private:                       // Constructor
  bool use_magic_;             
  bool use_embedded_geometry_; 
  bool use_geometry_store_;    
 
  typedef std::map<lane::LaneId, lane::Lane::Ptr> LaneMap;                     
  typedef std::map<landmark::LandmarkId, landmark::Landmark::Ptr> LandmarkMap; 
  typedef std::map<PartitionId, lane::LaneIdList> PartLaneMap;                 
  typedef std::map<PartitionId, landmark::LandmarkIdList> PartLandmarkMap;     
 
  MapMetaData meta_data_;             
  LaneMap lane_map_;                  
  LandmarkMap landmark_map_;          
  PartLaneMap part_lane_map_;         
  PartLandmarkMap part_landmark_map_; 
};
 
} // namespace access
} // namespace map
} // namespace ad