333 lines
11 KiB
C++
333 lines
11 KiB
C++
/*
|
|
* 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 <mcy@lm7.fr>
|
|
*
|
|
***********************************************************************
|
|
*
|
|
* 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 <boost/tr1/unordered_map.hpp>
|
|
#include <boost/tr1/unordered_set.hpp>
|
|
|
|
/// 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<std::string, Building> buildings ;
|
|
|
|
/// List of known Waypoint
|
|
static std::tr1::unordered_map<Point3D, Waypoint> waypoints ;
|
|
|
|
/// List of known Mobile
|
|
/** The string key of the map is the Mobile MAC address. */
|
|
static std::tr1::unordered_map<std::string, Mobile> mobiles ;
|
|
|
|
/// List of known AccessPoint
|
|
/** The string key of the map is the AccessPoint MAC address. */
|
|
static std::tr1::unordered_map<std::string, AccessPoint> aps ;
|
|
|
|
/// List of known ReferencePoint
|
|
static std::tr1::unordered_set
|
|
<ReferencePoint, boost::hash<ReferencePoint>, reference_point_equal_to>
|
|
reference_points ;
|
|
|
|
/// List of known CalibrationRequest
|
|
static std::tr1::unordered_set<CalibrationRequest> 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<std::string, AccessPoint>& 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<Waypoint&>(
|
|
find_create_waypoint(static_cast<Point3D>(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<std::string, AccessPoint>& 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_
|