order.cpp

Go to the documentation of this file.

/*PGR-GNU*****************************************************************
 
FILE: order.cpp
 
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*/
 
#include "problem/order.h"
 
namespace vrprouting {
namespace problem {
 
Identifiers<size_t>
Order::subsetI(const Identifiers<size_t> &I) const {
  return m_compatibleI * I;
}
 
Identifiers<size_t>
Order::subsetJ(const Identifiers<size_t> &J) const {
  return m_compatibleJ * J;
}
 
std::ostream&
operator<< (std::ostream &log, const Order &order) {
  log << "\n\nOrder "
    << static_cast<Identifier>(order) << ": \n"
    << "\tPickup: " << order.pickup() << "\n"
    << "\tDropoff: " << order.delivery() << "\n";
  log << "\nThere are | {I}| = "
    << order.m_compatibleI.size()
    << " -> order(" << order.idx()
    << ") -> | {J}| = " << order.m_compatibleJ.size()
    << "\n\n {";
  for (const auto o : order.m_compatibleI) {
    log << o << ", ";
  }
  log << "} -> " << order.idx() << " -> {";
  for (const auto o : order.m_compatibleJ) {
    log << o << ", ";
  }
  log << "}";
 
  return log;
}
 
bool
Order::is_valid(Speed speed) const {
  return
    pickup().is_pickup()
    && delivery().is_delivery()
    /* IS P -> D */
    && delivery().is_compatible_IJ(pickup(), speed);
}
 
void
Order::set_compatibles(const Order& J, Speed speed) {
  if (J.idx() == idx()) return;
  if (J.isCompatibleIJ(*this, speed)) {
    m_compatibleJ += J.idx();
  }
  if (this->isCompatibleIJ(J, speed)) {
    m_compatibleI += J.idx();
  }
}
 
bool
Order::isCompatibleIJ(const Order &I, Speed speed) const {
  /* this is true in all cases */
  auto all_cases(
      pickup().is_compatible_IJ(I.pickup(), speed)
      && delivery().is_compatible_IJ(I.pickup(), speed));
 
  /* case other(P) other(D) this(P) this(D) */
  auto case1(pickup().is_compatible_IJ(I.delivery(), speed)
      && delivery().is_compatible_IJ(I.delivery(), speed));
 
  /* case other(P) this(P) other(D) this(D) */
  auto case2(I.delivery().is_compatible_IJ(pickup(), speed)
      && delivery().is_compatible_IJ(I.delivery(), speed));
 
  /* case other(P) this(P) this(D) other(D) */
  auto case3(I.delivery().is_compatible_IJ(pickup(), speed)
      && I.delivery().is_compatible_IJ(delivery(), speed));
 
  return all_cases &&  (case1 ||  case2 ||  case3);
}
 
}  //  namespace problem
}  //  namespace vrprouting