IntegerConverter.h

 
#pragma once

 
#if defined(IntegerConverter_RECURSES)
#error Recursive header files inclusion detected in IntegerConverter.h
#else // defined(IntegerConverter_RECURSES)
#define IntegerConverter_RECURSES
 
#if !defined IntegerConverter_h
#define IntegerConverter_h

// Inclusions
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/kernel/PointVector.h"
 
namespace DGtal
{

  template < DGtal::Dimension dim,
             typename TInteger >
  struct IntegerConverter {
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ));
    typedef TInteger Integer;

    static Integer cast( Integer i )
    {
      return i;
    }

    static
    PointVector< dim, Integer >
    cast( PointVector< dim, Integer > p )
    {
      return p;
    }
  };

  template < DGtal::Dimension dim >
  struct IntegerConverter< dim, DGtal::int32_t > {
    typedef DGtal::int32_t Integer;

    static DGtal::int32_t cast( DGtal::int32_t i )
    {
      return i;
    }

    static
    PointVector< dim, DGtal::int32_t >
    cast( PointVector< dim, DGtal::int32_t > p )
    {
      return p;
    }

    static DGtal::int32_t cast( DGtal::int64_t i )
    {
      DGtal::int32_t r = DGtal::int32_t( i );
      if ( DGtal::int64_t( r ) != i )
        trace.warning() << "Bad integer conversion: " << i << " -> " << r
                        << std::endl;
      return r;
    }

    static
    PointVector< dim, DGtal::int32_t >
    cast( PointVector< dim, DGtal::int64_t > p )
    {
      PointVector< dim, DGtal::int32_t > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }

    static DGtal::int32_t cast( DGtal::BigInteger i )
    {
      auto r = NumberTraits<DGtal::BigInteger>::castToInt64_t(i);
      if ( DGtal::BigInteger( r ) != i )
        trace.warning() << "Bad integer conversion: " << i << " -> " << r
                        << std::endl;
      return (DGtal::int32_t)r;
    }

    static
    PointVector< dim, DGtal::int32_t >
    cast( PointVector< dim, DGtal::BigInteger > p )
    {
      PointVector< dim, DGtal::int32_t > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }
  };
 

  template < DGtal::Dimension dim >
  struct IntegerConverter< dim, DGtal::int64_t > {
    typedef DGtal::int64_t Integer;

    static DGtal::int64_t cast( DGtal::int32_t i )
    {
      return i;
    }

    static
    PointVector< dim, DGtal::int64_t >
    cast( PointVector< dim, DGtal::int32_t > p )
    {
      PointVector< dim, DGtal::int64_t > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }

    static DGtal::int64_t cast( DGtal::int64_t i )
    {
      return i;
    }

    static
    PointVector< dim, DGtal::int64_t >
    cast( PointVector< dim, DGtal::int64_t > p )
    {
      return p;
    }

    static DGtal::int64_t cast( DGtal::BigInteger i )
    {
      DGtal::int64_t r = NumberTraits<DGtal::BigInteger>::castToInt64_t(i);
      DGtal::BigInteger tmp(r);
      if ( tmp != i )
        trace.warning() << "Bad integer conversion: " << i << " -> " << r
                        << std::endl;
      return r;
    }

    static
    PointVector< dim, DGtal::int64_t >
    cast( PointVector< dim, DGtal::BigInteger > p )
    {
      PointVector< dim, DGtal::int64_t > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }
  };

  template < DGtal::Dimension dim >
  struct IntegerConverter< dim, DGtal::BigInteger > {
    typedef DGtal::BigInteger Integer;

    static DGtal::BigInteger cast( DGtal::int32_t i )
    {
      return DGtal::BigInteger( i );
    }

    static
    PointVector< dim, DGtal::BigInteger >
    cast( PointVector< dim, DGtal::int32_t > p )
    {
      PointVector< dim, DGtal::BigInteger > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }

    static DGtal::BigInteger cast( DGtal::int64_t i )
    {
      DGtal::BigInteger tmp = i;
      return tmp;
    }

    static
    PointVector< dim, DGtal::BigInteger >
    cast( PointVector< dim, DGtal::int64_t > p )
    {
      PointVector< dim, DGtal::BigInteger > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }

    static DGtal::BigInteger cast( DGtal::BigInteger i )
    {
      return i;
    }

    static
    PointVector< dim, DGtal::BigInteger >
    cast( PointVector< dim, DGtal::BigInteger > p )
    {
      return p;
    }
 
  };
 
} // namespace DGtal {
 
#endif // !defined IntegerConverter_h
 
#undef IntegerConverter_RECURSES
#endif // else defined(IntegerConverter_RECURSES)