Replace BOOST_STATIC_ASSERT with static_assert

Since we now require C++11, we can use the standard
static_assert, which should give better compiler
diagnostics than the Boost macro.

include/RMF/Vector.h

@@ -61,13 +61,13 @@ class Vector
   RMF_CXX11_DEFAULT_COPY_CONSTRUCTOR(Vector);
 
   Vector(float x, float y, float z) {
-    BOOST_STATIC_ASSERT(D == 3);
+    static_assert(D == 3);
     P::operator[](0) = x;
     P::operator[](1) = y;
     P::operator[](2) = z;
   }
   Vector(float x, float y, float z, float q) {
-    BOOST_STATIC_ASSERT(D == 4);
+    static_assert(D == 4);
     P::operator[](0) = x;
     P::operator[](1) = y;
     P::operator[](2) = z;

include/RMF/internal/swig_helpers.h

@@ -118,7 +118,7 @@ struct ValueOrObject {
 
 template <class T>
 struct ConvertAllBase {
-  BOOST_STATIC_ASSERT(!is_pointer<T>::value);
+  static_assert(!is_pointer<T>::value);
   template <class SwigData>
   static bool get_is_cpp_object(PyObject* o, SwigData st) {
     void* vp;
@@ -129,7 +129,7 @@ struct ConvertAllBase {
 
 template <class T>
 struct ConvertValueBase : public ConvertAllBase<T> {
-  BOOST_STATIC_ASSERT(!is_pointer<T>::value);
+  static_assert(!is_pointer<T>::value);
   template <class SwigData>
   static const T& get_cpp_object(PyObject* o, SwigData st) {
     void* vp;
@@ -175,7 +175,7 @@ struct Convert : public ConvertValueBase<T> {
 template <class T, class VT, class ConvertVT>
 struct ConvertSequenceHelper {
   typedef typename ValueOrObject<VT>::type V;
-  BOOST_STATIC_ASSERT(!is_pointer<T>::value);
+  static_assert(!is_pointer<T>::value);
   template <class SwigData>
   static bool get_is_cpp_object(PyObject* in, SwigData st) {
     if (!in || !PySequence_Check(in)) {

src/avrocpp/api/AvroParse.hh

@@ -48,12 +48,12 @@ void parse(ResolvingReader &p, T &val) {
 
 template <typename Reader, typename T>
 void parse(Reader &p, T &val, const boost::false_type &) {
-  BOOST_STATIC_ASSERT(sizeof(T) == 0);
+  static_assert(sizeof(T) == 0);
 }
 
 template <typename Reader, typename T>
 void translatingParse(Reader &p, T &val, const boost::false_type &) {
-  BOOST_STATIC_ASSERT(sizeof(T) == 0);
+  static_assert(sizeof(T) == 0);
 }
 
 // @{

src/avrocpp/api/AvroSerialize.hh

@@ -43,7 +43,7 @@ void serialize(Writer &s, const T &val) {
 
 template <typename Writer, typename T>
 void serialize(Writer &s, const T &val, const boost::false_type &) {
-  BOOST_STATIC_ASSERT(sizeof(T) == 0);
+  static_assert(sizeof(T) == 0);
 }
 
 /// The remainder of the file includes default implementations for serializable

src/avrocpp/api/buffer/BufferReader.hh

@@ -235,7 +235,7 @@ class AVRO_DECL BufferReader : private boost::noncopyable {
   /// An uninstantiable function, this is if boost::is_fundamental check fails
   template <typename T>
   bool read(T &val, const boost::false_type &) {
-    BOOST_STATIC_ASSERT(sizeof(T) == 0);
+    static_assert(sizeof(T) == 0);
     return false;
   }
 

src/avrocpp/api/buffer/detail/BufferDetail.hh

@@ -325,7 +325,7 @@ class BufferImpl : boost::noncopyable {
   /// and will compile-time assert.
   template <typename T>
   void writeTo(T val, const boost::false_type &) {
-    BOOST_STATIC_ASSERT(sizeof(T) == 0);
+    static_assert(sizeof(T) == 0);
   }
 
   /// Write a block of data to the buffer, adding new chunks if necessary.

src/avrocpp/impl/Resolver.cc

@@ -562,8 +562,8 @@ class ResolverFactory : private boost::noncopyable {
         &ResolverFactory::constructCompound<UnionParser, UnionSkipper>,
         &ResolverFactory::constructCompound<FixedParser, FixedSkipper>};
 
-    BOOST_STATIC_ASSERT((sizeof(funcs) / sizeof(BuilderFunc)) ==
-                        (AVRO_NUM_TYPES));
+    static_assert((sizeof(funcs) / sizeof(BuilderFunc)) ==
+                  (AVRO_NUM_TYPES));
 
     BuilderFunc func = funcs[currentWriter->type()];
     assert(func);
@@ -594,8 +594,8 @@ class ResolverFactory : private boost::noncopyable {
         &ResolverFactory::constructCompoundSkipper<UnionSkipper>,
         &ResolverFactory::constructCompoundSkipper<FixedSkipper>};
 
-    BOOST_STATIC_ASSERT((sizeof(funcs) / sizeof(BuilderFunc)) ==
-                        (AVRO_NUM_TYPES));
+    static_assert((sizeof(funcs) / sizeof(BuilderFunc)) ==
+                  (AVRO_NUM_TYPES));
 
     BuilderFunc func = funcs[currentWriter->type()];
     assert(func);

src/avrocpp/impl/Types.cc

@@ -28,16 +28,16 @@ const std::string typeToString[] = {
     "string", "bytes", "int",   "long", "float", "double", "boolean", "null",
     "record", "enum",  "array", "map",  "union", "fixed",  "symbolic"};
 
-BOOST_STATIC_ASSERT((sizeof(typeToString) / sizeof(std::string)) ==
-                    (AVRO_NUM_TYPES + 1));
+static_assert((sizeof(typeToString) / sizeof(std::string)) ==
+              (AVRO_NUM_TYPES + 1));
 
 }  // namespace strings
 
 // this static assert exists because a 32 bit integer is used as a bit-flag for
 // each type,
 // and it would be a problem for this flag if we ever supported more than 32
 // types
-BOOST_STATIC_ASSERT(AVRO_NUM_TYPES < 32);
+static_assert(AVRO_NUM_TYPES < 32);
 
 const std::string &toString(Type type) {
   static std::string undefinedType = "Undefined type";

src/avrocpp/impl/Validator.cc

@@ -141,8 +141,8 @@ void Validator::doAdvance() {
       &Validator::enumAdvance,     &Validator::countingAdvance,
       &Validator::countingAdvance, &Validator::unionAdvance,
       &Validator::fixedAdvance};
-  BOOST_STATIC_ASSERT((sizeof(funcs) / sizeof(AdvanceFunc)) ==
-                      (AVRO_NUM_TYPES));
+  static_assert((sizeof(funcs) / sizeof(AdvanceFunc)) ==
+                (AVRO_NUM_TYPES));
 
   expectedTypesFlag_ = 0;
   // loop until we encounter a next expected type, or we've exited all compound
@@ -199,7 +199,7 @@ void Validator::setupFlag(Type type) {
                                  typeToFlag(AVRO_ENUM), typeToFlag(AVRO_ARRAY),
                                  typeToFlag(AVRO_MAP), typeToFlag(AVRO_UNION),
                                  typeToFlag(AVRO_FIXED)};
-  BOOST_STATIC_ASSERT((sizeof(flags) / sizeof(flag_t)) == (AVRO_NUM_TYPES));
+  static_assert((sizeof(flags) / sizeof(flag_t)) == (AVRO_NUM_TYPES));
 
   expectedTypesFlag_ = flags[type];
 }