#ifndef Int_H
#define Int_H

//#include "Integer.H"
#include <boost/mpl/if.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
#include <stdint.h>
//#include "Complex.H"
#include <boost/utility.hpp>	// enable_if
#include <boost/bind.hpp>

namespace Integer {
  //! Choose int32_t or int64_t given # of bits
  template<int bits>
  struct integer {
    BOOST_STATIC_ASSERT (bits < sizeof(int64_t)*8);
    typedef typename boost::mpl::if_c< (bits > sizeof(int)*8),
      int64_t,
      int32_t
      >::type type;
    static const type max = ~(type(-1) << (bits-1));
    static const type min = (type(-1) << (bits-1));
  };

  //! Choose uint32_t or uint64_t given # of bits
  template<int bits>
  struct uinteger {
    BOOST_STATIC_ASSERT (bits < sizeof(uint64_t)*8);
    typedef typename boost::mpl::if_c< (bits > sizeof(int)*8),
					 uint64_t,
					 uint32_t
					>::type type;
  };
}

template<int bits, typename int_t>
struct noop {
  int_t static Apply (int_t x) {
    return x;
  }
};

template<int bits, typename int_t>
struct sat {
  int_t static Apply (int_t x) {
    if (x > Integer::integer<bits>::max)
      return Integer::integer<bits>::max;
  else if (x < Integer::integer<bits>::min)
    return Integer::integer<bits>::min;
  else
    return x;
  }
    
};

template<int bits, template<int b, typename int_t> class policy, typename int_t=typename Integer::integer<bits>::type>
class SInt {
public:
  explicit SInt (int_t x) :
    val (Check (x)) {}


//   template<int otherbits, template<int b, typename c> class otherpolicy>
//   explicit SInt (SInt<otherbits,otherpolicy> x) :
//     val (Check (int_t(x))) {}

  static int_t Check (int_t x) {
    return policy<bits, int_t>::Apply (x);
  }

  int_t operator= (int_t x) {
    val = Check (x);
  }

  operator int_t() {
    return val;
  }
private:
  int_t val;
};

#endif