SerializeGeneratedPointTypes.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/point/Altitude.hpp"
#include "ad/map/point/BoundingSphere.hpp"
#include "ad/map/point/ECEFCoordinate.hpp"
#include "ad/map/point/ECEFPoint.hpp"
#include "ad/map/point/ENUCoordinate.hpp"
#include "ad/map/point/ENUPoint.hpp"
#include "ad/map/point/GeoPoint.hpp"
#include "ad/map/point/Geometry.hpp"
#include "ad/map/point/Latitude.hpp"
#include "ad/map/point/Longitude.hpp"
#include "ad/map/point/ParaPoint.hpp"
#include "ad/map/serialize/ISerializer.hpp"
#include "ad/map/serialize/SerializeGeneratedBasicTypes.hpp"
#include "ad/map/serialize/SerializeGeneratedPhysicsTypes.hpp"
 
namespace ad {
namespace map {
namespace serialize {
 
inline bool doSerialize(ISerializer &serializer, point::ECEFCoordinate &x)
{
  return serializer.serializeGeneratedType<point::ECEFCoordinate, double, SerializeableMagic::ECEFCoordinate>(x);
}
 
inline bool doSerialize(ISerializer &serializer, point::ENUCoordinate &x)
{
  return serializer.serializeGeneratedType<point::ENUCoordinate, double, SerializeableMagic::ENUCoordinate>(x);
}
 
inline bool doSerialize(ISerializer &serializer, point::Longitude &x)
{
  return serializer.serializeGeneratedType<point::Longitude, double, SerializeableMagic::Longitude>(x);
}
 
inline bool doSerialize(ISerializer &serializer, point::Latitude &x)
{
  return serializer.serializeGeneratedType<point::Latitude, double, SerializeableMagic::Latitude>(x);
}
 
inline bool doSerialize(ISerializer &serializer, point::Altitude &x)
{
  return serializer.serializeGeneratedType<point::Altitude, double, SerializeableMagic::Altitude>(x);
}
 
inline bool doSerialize(ISerializer &serializer, point::ParaPoint &paraPoint)
{
  return serializer.serialize(SerializeableMagic::ParaPoint) && doSerialize(serializer, paraPoint.laneId)
    && doSerialize(serializer, paraPoint.parametricOffset);
}
 
inline bool doSerialize(ISerializer &serializer, point::ENUPoint &enuPoint)
{
  //@todo: fix ENUCoordinate -> ENUPoint: currently here for backward compat
  return serializer.serialize(SerializeableMagic::ENUCoordinate) && doSerialize(serializer, enuPoint.x)
    && doSerialize(serializer, enuPoint.y) && doSerialize(serializer, enuPoint.z);
}
 
inline bool doSerialize(ISerializer &serializer, point::ECEFPoint &ecefPoint)
{
  //@todo: fix ECEFCoordinate -> ECEFPoint: currently here for backward compat
  return serializer.serialize(SerializeableMagic::ECEFCoordinate) && doSerialize(serializer, ecefPoint.x)
    && doSerialize(serializer, ecefPoint.y) && doSerialize(serializer, ecefPoint.z);
}
 
inline bool doSerialize(ISerializer &serializer, point::GeoPoint &geoPoint)
{
  return serializer.serialize(SerializeableMagic::GeoPoint) && doSerialize(serializer, geoPoint.longitude)
    && doSerialize(serializer, geoPoint.latitude) && doSerialize(serializer, geoPoint.altitude);
}
 
inline bool doSerialize(ISerializer &serializer, point::BoundingSphere &boundingSphere)
{
  // @todo: keep original format, so no magic for bounding sphere for now
  return doSerialize(serializer, boundingSphere.center) && doSerialize(serializer, boundingSphere.radius);
}
 
inline bool doSerialize(ISerializer &serializer, point::Geometry &geometry)
{
  if (!serializer.isStoring())
  {
    // clear cache when reading
    geometry.private_enuEdgeCache.enuVersion = 0;
    geometry.private_enuEdgeCache.enuEdge.clear();
  }
  bool ok = serializer.serialize(SerializeableMagic::Geometry) && serializer.serialize(geometry.isValid)
    && serializer.serialize(geometry.isClosed) && serialize::doSerialize(serializer, geometry.length);
 
  if (serializer.isStoring())
  {
    if (serializer.useEmbeddedPoints())
    {
      ok = ok && serializer.serializeObjectVector(geometry.ecefEdge);
    }
    else
    {
      static point::ECEFEdge empty;
      ok = ok && serializer.serializeObjectVector(empty);
    }
  }
  else
  {
    ok = ok && serializer.serializeObjectVector(geometry.ecefEdge);
  }
  return ok;
}
 
} // namespace serialize
} // namespace map
} // namespace ad