1 // boost/integer/cover_operators.hpp ----------------------------------------// 2 3 // Copyright Darin Adler 2000 4 // Copyright Beman Dawes 2008 5 6 // Distributed under the Boost Software License, Version 1.0. (See accompanying 7 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 8 9 //----------------------------------------------------------------------------// 10 11 // If the class being covered has a non-explicit conversion to an integer type 12 // then a smaller number of cover operations are needed. Define the macro 13 // BOOST_MINIMAL_INTEGER_COVER_OPERATORS to indicate this. 14 15 // Define BOOST_NO_IO_COVER_OPERATORS if I/O cover operations are not desired. 16 17 //----------------------------------------------------------------------------// 18 19 #ifndef BOOST_SPIRIT_INTEGER_COVER_OPERATORS_HPP 20 #define BOOST_SPIRIT_INTEGER_COVER_OPERATORS_HPP 21 22 #if defined(_MSC_VER) 23 #pragma once 24 #endif 25 26 # ifndef BOOST_MINIMAL_INTEGER_COVER_OPERATORS 27 # include <boost/operators.hpp> 28 # endif 29 30 #include <iosfwd> 31 32 namespace boost { namespace spirit 33 { 34 namespace endian 35 { 36 37 // A class that adds integer operators to an integer cover class 38 39 template <typename T, typename IntegerType> 40 class cover_operators 41 # ifndef BOOST_MINIMAL_INTEGER_COVER_OPERATORS 42 : boost::operators<T> 43 # endif 44 { 45 // The other operations take advantage of the type conversion that's 46 // built into unary +. 47 48 // Unary operations. operator +(const T & x)49 friend IntegerType operator+(const T& x) { return x; } 50 # ifndef BOOST_MINIMAL_INTEGER_COVER_OPERATORS operator -(const T & x)51 friend IntegerType operator-(const T& x) { return -+x; } operator ~(const T & x)52 friend IntegerType operator~(const T& x) { return ~+x; } operator !(const T & x)53 friend IntegerType operator!(const T& x) { return !+x; } 54 55 // The basic ordering operations. operator ==(const T & x,IntegerType y)56 friend bool operator==(const T& x, IntegerType y) { return +x == y; } operator <(const T & x,IntegerType y)57 friend bool operator<(const T& x, IntegerType y) { return +x < y; } 58 # endif 59 60 // The basic arithmetic operations. operator +=(T & x,IntegerType y)61 friend T& operator+=(T& x, IntegerType y) { return x = +x + y; } operator -=(T & x,IntegerType y)62 friend T& operator-=(T& x, IntegerType y) { return x = +x - y; } operator *=(T & x,IntegerType y)63 friend T& operator*=(T& x, IntegerType y) { return x = +x * y; } operator /=(T & x,IntegerType y)64 friend T& operator/=(T& x, IntegerType y) { return x = +x / y; } operator %=(T & x,IntegerType y)65 friend T& operator%=(T& x, IntegerType y) { return x = +x % y; } operator &=(T & x,IntegerType y)66 friend T& operator&=(T& x, IntegerType y) { return x = +x & y; } operator |=(T & x,IntegerType y)67 friend T& operator|=(T& x, IntegerType y) { return x = +x | y; } operator ^=(T & x,IntegerType y)68 friend T& operator^=(T& x, IntegerType y) { return x = +x ^ y; } operator <<=(T & x,IntegerType y)69 friend T& operator<<=(T& x, IntegerType y) { return x = +x << y; } operator >>=(T & x,IntegerType y)70 friend T& operator>>=(T& x, IntegerType y) { return x = +x >> y; } 71 72 // A few binary arithmetic operations not covered by operators base class. operator <<(const T & x,IntegerType y)73 friend IntegerType operator<<(const T& x, IntegerType y) { return +x << y; } operator >>(const T & x,IntegerType y)74 friend IntegerType operator>>(const T& x, IntegerType y) { return +x >> y; } 75 76 // Auto-increment and auto-decrement can be defined in terms of the 77 // arithmetic operations. operator ++(T & x)78 friend T& operator++(T& x) { return x += 1; } operator --(T & x)79 friend T& operator--(T& x) { return x -= 1; } 80 81 # ifdef BOOST_MINIMAL_INTEGER_COVER_OPERATORS operator ++(T & x,int)82 friend T operator++(T& x, int) 83 { 84 T tmp(x); 85 x += 1; 86 return tmp; 87 } operator --(T & x,int)88 friend T operator--(T& x, int) 89 { 90 T tmp(x); 91 x -= 1; 92 return tmp; 93 } 94 # endif 95 96 # ifndef BOOST_NO_IO_COVER_OPERATORS 97 // TODO: stream I/O needs to be templatized on the stream type, so will 98 // work with wide streams, etc. 99 100 // Stream input and output. operator <<(std::ostream & s,const T & x)101 friend std::ostream& operator<<(std::ostream& s, const T& x) 102 { return s << +x; } operator >>(std::istream & s,T & x)103 friend std::istream& operator>>(std::istream& s, T& x) 104 { 105 IntegerType i; 106 if (s >> i) 107 x = i; 108 return s; 109 } 110 # endif 111 }; 112 } // namespace endian 113 }} // namespace boost::spirit 114 115 #endif // BOOST_SPIRIT_INTEGER_COVER_OPERATORS_HPP 116