vehicle.h

Go to the documentation of this file.

/*PGR-GNU*****************************************************************
 
FILE: vehicle.h
 
Copyright (c) 2016 pgRouting developers
Mail: [email protected]
 
------
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program 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 General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 ********************************************************************PGR-GNU*/
 
#ifndef INCLUDE_VRP_VEHICLE_H_
#define INCLUDE_VRP_VEHICLE_H_
#pragma once
 
#include <deque>
#include <iostream>
#include <algorithm>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
 
#include "cpp_common/identifier.h"
#include "vrp/vehicle_node.h"
#include "c_types/pickDeliver/general_vehicle_orders_t.h"
 
namespace pgrouting {
namespace vrp {
 
class Pgr_pickDeliver;
 
class Vehicle : public Identifier {
 protected:
     typedef size_t POS;
     using difference_type = std::deque<Vehicle_node>::difference_type;
     std::deque< Vehicle_node > m_path;
 
     friend class PD_problem;
 
 private:
     double m_capacity;
     double m_factor;
     double m_speed;
 
 public:
     /*
      * (twv, cv, fleet_size, wait_time, duration)
      */
     typedef std::tuple< int, int, size_t, double, double > Cost;
     std::vector<General_vehicle_orders_t>
           get_postgres_result(int vid) const;
 
     Vehicle(const Vehicle &) = default;
     Vehicle(
             size_t idx,
             int64_t id,
             const Vehicle_node &starting_site,
             const Vehicle_node &ending_site,
             double p_capacity,
             double p_speed,
             double p_factor);
 
 
     bool is_phony() const {return id() < 0;}
     double speed() const;
 
     void invariant() const;
 
 
 
     void insert(POS pos, Vehicle_node node);
 
 
     POS insert(std::pair<POS, POS> position_limits, const Vehicle_node &node);
 
 
 
 
 
 
     void erase(const Vehicle_node &node);
 
 
 
     void erase(POS pos);
 
     bool empty() const;
 
     size_t size() const;
 
 
     Cost cost() const;
     bool cost_compare(const Cost&, const Cost&) const;
 
     double duration() const {
         return m_path.back().departure_time();
     }
     double total_wait_time() const {
         return m_path.back().total_wait_time();
     }
     double total_travel_time() const {
         return m_path.back().total_travel_time();
     }
     double total_service_time() const {
         return m_path.back().total_service_time();
     }
     int twvTot() const {
         return m_path.back().twvTot();
     }
     int cvTot() const {
         return m_path.back().cvTot();
     }
     bool has_twv() const {
         return twvTot() != 0;
     }
     bool has_cv() const {
         return cvTot() != 0;
     }
 
     bool is_feasable() const {
         return !(has_twv() ||  has_cv());
     }
 
     bool is_ok() const;
 
     Vehicle_node start_site() const {
         return m_path.front();
     }
     Vehicle_node end_site() const {
         return m_path.back();
     }
     double capacity() const {return m_capacity;}
 
 
 
     void swap(POS i, POS j);
 
 
 
     void evaluate();
 
     void evaluate(POS from);
 
 
 
 
 
 
     std::deque< Vehicle_node > path() const;
 
 
 
 
     friend std::ostream& operator << (std::ostream &log, const Vehicle &v);
 
     std::string tau() const;
 
     friend bool operator<(const Vehicle &lhs, const Vehicle &rhs);
 
 
 
 
     std::pair<POS, POS> position_limits(const Vehicle_node node) const;
     std::pair<POS, POS> drop_position_limits(const Vehicle_node node) const;
 
     static Pgr_pickDeliver* problem;
 
     static Pgr_messages& msg();
 
 private:
     POS getDropPosLowLimit(const Vehicle_node &node) const;
     POS getPosLowLimit(const Vehicle_node &node) const;
     POS getPosHighLimit(const Vehicle_node &node) const;
};
 
}  // namespace vrp
}  // namespace pgrouting
 
#endif  // INCLUDE_VRP_VEHICLE_H_