SerializeGeneratedRestrictionTypes.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: MIT
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include "ad/map/restriction/Types.hpp"
#include "ad/map/serialize/ISerializer.hpp"
#include "ad/map/serialize/SerializeGeneratedPhysicsTypes.hpp"
 
namespace ad {
namespace map {
namespace serialize {
 
inline bool doSerialize(ISerializer &serializer, restriction::PassengerCount &x)
{
  return serializer.serializeGeneratedType<restriction::PassengerCount, uint16_t, SerializeableMagic::PassengerCount>(
    x);
}
 
inline bool doSerialize(ISerializer &serializer, restriction::Restriction &x)
{
  return serializer.serialize(SerializeableMagic::Restriction) && serializer.serialize(x.negated)
    && doSerialize(serializer, x.passengersMin) && serializer.serializeVector(x.roadUserTypes);
}
 
inline bool doSerialize(ISerializer &serializer, restriction::Restrictions &x)
{
  return serializer.serialize(SerializeableMagic::Restrictions)
    //@todo: special serializable magic for backward compatibility
    && serializer.serializeObjectVector(x.conjunctions, SerializeableMagic::ObjectPtrVectorType)
    && serializer.serializeObjectVector(x.disjunctions, SerializeableMagic::ObjectPtrVectorType);
}
 
inline bool doSerialize(ISerializer &serializer, restriction::SpeedLimit &x)
{
  bool ok = serializer.serialize(SerializeableMagic::SpeedLimit) && doSerialize(serializer, x.speedLimit)
    && doSerialize(serializer, x.lanePiece);
 
  if (ok)
  {
    // speed limits have to be actually positive!
    if (x.speedLimit <= physics::Speed(0.))
    {
      x.speedLimit = std::numeric_limits<physics::Speed>::max();
    }
  }
  return ok;
}
 
} // namespace serialize
} // namespace map
} // namespace ad