/* * This file is part of the Owl Positioning System (OwlPS). * OwlPS is a project of the University of Franche-Comte * (Université de Franche-Comté), France. * * Copyright © Université de Franche-Comté 2007-2012. * * Corresponding author: Matteo Cypriani * *********************************************************************** * * This software is governed by the CeCILL license under French law and * abiding by the rules of distribution of free software. You can use, * modify and/or redistribute the software under the terms of the CeCILL * license as circulated by CEA, CNRS and INRIA at the following URL: * http://www.cecill.info * * As a counterpart to the access to the source code and rights to copy, * modify and redistribute granted by the license, users are provided * only with a limited warranty and the software's authors, the holder * of the economic rights, and the successive licensors have only * limited liability. * * In this respect, the user's attention is drawn to the risks * associated with loading, using, modifying and/or developing or * reproducing the software by the user in light of its specific status * of free software, that may mean that it is complicated to manipulate, * and that also therefore means that it is reserved for developers and * experienced professionals having in-depth computer knowledge. Users * are therefore encouraged to load and test the software's suitability * as regards their requirements in conditions enabling the security of * their systems and/or data to be ensured and, more generally, to use * and operate it in the same conditions as regards security. * * The fact that you are presently reading this means that you have had * knowledge of the CeCILL license and that you accept its terms. * *********************************************************************** */ #ifndef _OWLPS_POSITIONING_STOCK_HH_ #define _OWLPS_POSITIONING_STOCK_HH_ #include "autocalibration.hh" #include "building.hh" #include "waypoint.hh" #include "mobile.hh" #include "accesspoint.hh" #include "referencepoint.hh" #include "calibrationrequest.hh" #include #include /// Storage class class Stock { friend class Autocalibration ; private: /// List of known Building /** The string key of the map is the Building name. */ static std::tr1::unordered_map buildings ; /// List of known Waypoint static std::tr1::unordered_map waypoints ; /// List of known Mobile /** The string key of the map is the Mobile MAC address. */ static std::tr1::unordered_map mobiles ; /// List of known AccessPoint /** The string key of the map is the AccessPoint MAC address. */ static std::tr1::unordered_map aps ; /// List of known ReferencePoint static std::tr1::unordered_set , reference_point_equal_to> reference_points ; /// List of known CalibrationRequest static std::tr1::unordered_set calibration_requests ; /** @name CalibrationRequest operations */ //@{ /// Delete calibration requests that do not come from the APs static void delete_non_ap_calibration_requests(void) ; //@} /** @name ReferencePoint operations */ //@{ /// Generates reference points according to a meshing static void generate_reference_points_mesh(void) ; /// Generates reference points according to a list static void generate_reference_points_list(void) ; /// Generates a single reference point static void generate_reference_point(const Point3D &coord) ; //@} public: /** @name Building operations */ //@{ /// Returns the number of buildings static unsigned int nb_buildings(void) ; /// Reads the Building corresponding to a given name static const Building& get_building(const std::string &name) ; /// Searches for a Building and creates it if it does not exist static const Building& find_create_building(const std::string &name) ; /// Searches the Area in which \em point is static const Area* in_which_area_is(const Point3D &point) ; //@} /** @name Waypoint operations */ //@{ /// Returns the number of waypoints static unsigned int nb_waypoints(void) ; /// Searches for a Waypoint and adds it if it does not exist static const Waypoint& find_create_waypoint(const Waypoint &point) ; /// \brief Searches for a Waypoint from its coordinates and adds it /// if it does not exist static const Waypoint& find_create_waypoint(const Point3D &point) ; /// \brief Deletes a Building from the building list of a Waypoint; /// deletes the Waypoint if it is not linked to any Building any more static void waypoint_remove_building(const Waypoint &point, const Building *building) ; //@} /** @name Mobile operations */ //@{ /// Returns the number of mobiles static unsigned int nb_mobiles(void) ; /// Verify the existence of a mobile static bool mobile_exists(const std::string &mac) ; /// Reads the Mobile corresponding to a given MAC address static const Mobile& get_mobile(const std::string &mac) ; /// \brief Searches for a Mobile given its MAC address and creates /// it if it does not exist static const Mobile& find_create_mobile(const std::string &mac) ; /// Searches for a Mobile and create it if it does not exist static const Mobile& find_create_mobile(const Mobile &source) ; /// \brief Returns a reference to the Mobile corresponding to a /// given MAC address static Mobile& getw_mobile(const std::string &mac) ; //@} /** @name AccessPoint operations */ //@{ /// Returns the number of access points static unsigned int nb_aps(void) ; /// Returns a reference to the AP list static std::tr1::unordered_map& get_aps(void) ; /// Verify the existence of an AP static bool ap_exists(const std::string &mac) ; /// Reads the AccessPoint corresponding to a given MAC address static const AccessPoint& get_ap(const std::string &mac) ; /// \brief Searches for an AccessPoint given its MAC address and /// creates it if it does not exist static const AccessPoint& find_create_ap(const std::string &mac) ; /// Searches for an AccessPoint and create it if it does not exist static const AccessPoint& find_create_ap(const AccessPoint &source) ; /// \brief Returns a reference to the AccessPoint corresponding to a /// given MAC address static AccessPoint& getw_ap(const std::string &mac) ; /// Updates the friis indexes of all the APs static void update_all_friis_indexes(void) ; /// \brief Returns the signal strenth received by an AP mac_receiver /// from an AP mac_transmitter static double ap_matrix_get_ss(const std::string &mac_transmitter, const std::string &mac_receiver) ; /// Checks if a Point3D is the coordinate of an existing AP static bool is_ap_coordinate(const Point3D &coord) ; //@} /** @name ReferencePoint operations */ //@{ /// Returns the number of reference points static unsigned int nb_reference_points(void) ; /// Verify the existence of a reference point at the given coordinates static bool reference_point_exists(const ReferencePoint &point) ; /// Reads the ReferencePoint at the given coordinates static const ReferencePoint& get_reference_point(const ReferencePoint &point) ; /// Searches for a ReferencePoint and adds it if it does not exist static const ReferencePoint& find_create_reference_point(const ReferencePoint &point) ; /// \brief Searches for the closest ReferencePoint (in the signal /// strength space) to a given Request static const ReferencePoint& closest_reference_point(const Request &request) ; /// \brief Generates reference points from the reference points /// corresponding to APs static void regenerate_reference_points(void) ; //@} /** @name CalibrationRequest operations */ //@{ /// Returns the number of calibration requests static unsigned int nb_calibration_requests(void) ; /// \brief Searches for a CalibrationRequest, adds it if it does /// not exist, and links it to its reference point static const CalibrationRequest& store_calibration_request( const CalibrationRequest &request) ; /// Deletes a CalibrationRequest static void delete_calibration_request( const CalibrationRequest &request) ; /// \brief Deletes the calibration requests that are older than /// \em timeout seconds static void delete_calibration_requests_older_than(int timeout) ; /// Searches for a CalibrationRequest and adds it if it does not exist static const CalibrationRequest& find_create_calibration_request(const CalibrationRequest &request) ; /// \brief Searches for the closest CalibrationRequest (in the signal /// strength space) to a given Request static const CalibrationRequest& closest_calibration_request(const Request &request) ; //@} /// Deletes all elements in all attributes static void clear(void) ; } ; /* *** Building operations *** */ inline unsigned int Stock::nb_buildings() { return buildings.size() ; } /* *** Waypoint operations *** */ inline unsigned int Stock::nb_waypoints() { return waypoints.size() ; } inline const Waypoint& Stock:: find_create_waypoint(const Waypoint &point) { Waypoint& found = const_cast( find_create_waypoint(static_cast(point))) ; found.add_buildings(point) ; return found ; } /* *** Mobile operations *** */ inline unsigned int Stock::nb_mobiles() { return mobiles.size() ; } /** * If the Mobile corresponding to \em mac does not exist, it is created. * @param mac The MAC address of the Mobile to search for. It must be a * valid MAC address, as no check is performed. * @return A modifiable reference to the Mobile. */ inline Mobile& Stock::getw_mobile(const std::string &mac) { return mobiles[mac] ; } /* *** AccessPoint operations *** */ inline unsigned int Stock::nb_aps() { return aps.size() ; } inline std::tr1::unordered_map& Stock::get_aps() { return aps ; } /** * If the AccessPoint corresponding to \em mac does not exist, it is * created. * @param mac The MAC address of the AccessPoint to search for. * It must be a valid MAC address, as no check is performed. * @return A modifiable reference to the AccessPoint. */ inline AccessPoint& Stock::getw_ap(const std::string &mac) { return aps[mac] ; } /* *** ReferencePoint operations *** */ inline unsigned int Stock::nb_reference_points() { return reference_points.size() ; } /* *** CalibrationRequest operations *** */ inline unsigned int Stock::nb_calibration_requests() { return calibration_requests.size() ; } #endif // _OWLPS_POSITIONING_STOCK_HH_