orders.h

Go to the documentation of this file.

/*PGR-GNU*****************************************************************
 
FILE: orders.h
 
Copyright (c) 2015 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_PROBLEM_ORDERS_H_
#define INCLUDE_PROBLEM_ORDERS_H_
#pragma once
 
#include <vector>
#include <algorithm>
 
#include "problem/order.h"
#include "c_types/pickDeliveryOrders_t.h"
#include "cpp_common/pgr_assert.h"
#include "cpp_common/identifiers.hpp"
#include "problem/tw_node.h"
#include "problem/vehicle_node.h"
#include "problem/node_types.h"
 
 
 
namespace vrprouting {
namespace problem {
 
class Orders : public std::vector<Order> {
 public:
    using std::vector<Order>::size;
    Orders() = default;
    Orders(const Orders&) = default;
 
    // todo remove template its problem::PickDeliver
    template <typename PTR>
      Orders(PickDeliveryOrders_t* p_orders, size_t p_size_orders, const PTR problem_ptr) {
        Tw_node::m_time_matrix_ptr = &problem_ptr->time_matrix();
        build_orders(p_orders, p_size_orders, problem_ptr);
      }
 
    size_t find_best_I(const Identifiers<size_t> &within_this_set) const;
 
    size_t find_best_J(const Identifiers<size_t> &within_this_set) const;
 
    size_t find_best_I_J(const Identifiers<size_t> &within_this_set) const;
 
    void set_compatibles(Speed = 1.0);
 
    bool is_valid(Speed = 1.0) const;
 
    friend std::ostream& operator<<(std::ostream &log, const Orders &p_orders) {
      log << "Orders\n";
      for (const auto &o : p_orders) log << o << "\n";
      log << "end Orders\n";
      return log;
    }
 
 private:
    template <typename PTR>
      void build_orders(PickDeliveryOrders_t *, size_t, const PTR problem_ptr);
 
    void add_order(const PickDeliveryOrders_t &order,
        const Vehicle_node &pick,
        const Vehicle_node &drop) {
      push_back(Order(size(), order.id, pick, drop));
    }
};
 
template <typename PTR>
void
Orders::build_orders(PickDeliveryOrders_t *orders, size_t size_orders, const PTR problem_ptr) {
  std::sort(orders, orders + size_orders,
      [] (const PickDeliveryOrders_t &lhs, const PickDeliveryOrders_t &rhs) {
        if (lhs.pick_open_t == rhs.pick_open_t) {
          if (lhs.deliver_close_t == rhs.deliver_close_t) {
            return lhs.id < rhs.id;
          } else {
            return lhs.deliver_close_t < rhs.deliver_close_t;
          }
        } else {
          return lhs.pick_open_t < rhs.pick_open_t;
        }
      });
 
  for (size_t i = 0; i < size_orders; ++i) {
    auto order = orders[i];
    Vehicle_node pick({problem_ptr->node_id()++, order, NodeType::kPickup});
    Vehicle_node drop({problem_ptr->node_id()++, order, NodeType::kDelivery});
 
    problem_ptr->add_node(pick);
    problem_ptr->add_node(drop);
 
    this->emplace_back(Order{size(), order.id, pick, drop});
  }
}
 
}  //  namespace problem
}  //  namespace vrprouting
 
#endif  // INCLUDE_PROBLEM_ORDERS_H_