//: C12:Integer.cpp {O}
// From Thinking in C++, 2nd Edition
// Available at http://www.BruceEckel.com
// (c) Bruce Eckel 2000
// Copyright notice in Copyright.txt
// Implementation of overloaded operators

#include "Integer.h"
#include "../require.h"

/* Gli operatori definiti di seguito sono tutti operatori binari, in quanto ricevono 2 parametri in ingresso. Ad esempio, nel caso dell'operatore "+", il parametro di sinistra è il primo, mentre quello di destra è il secondo. (Similmente per tutti gli altri.)*/

const Integer operator+(const Integer& left,const Integer& right)
{

return Integer(left.i + right.i);

}

const Integer operator-(const Integer& left,const Integer& right)
{

return Integer(left.i - right.i);

}

const Integer operator*(const Integer& left, const Integer& right)
{

return Integer(left.i * right.i);

}

const Integer operator/(const Integer& left, const Integer& right)
{

require(right.i != 0, "divide by zero");
return Integer(left.i / right.i);

}

const Integer operator%(const Integer& left, const Integer& right)
{

require(right.i != 0, "modulo by zero");
return Integer(left.i % right.i);

}

const Integer operator^(const Integer& left, const Integer& right)
{

return Integer(left.i ^ right.i);

}

const Integer operator&(const Integer& left, const Integer& right)
{

return Integer(left.i & right.i);

}

const Integer operator|(const Integer& left, const Integer& right)
{

return Integer(left.i | right.i);

}

const Integer operator<<(const Integer& left, const Integer& right)
{

return Integer(left.i << right.i);

}

const Integer operator>>(const Integer& left, const Integer& right)
{

return Integer(left.i >> right.i);

}

/* Assignments modify & return lvalue: */
Integer& operator+=(Integer& left, const Integer& right)
{

if(&left == &right) {/* self-assignment */}
left.i += right.i;
return left;

}

Integer& operator-=(Integer& left, const Integer& right)
{

if(&left == &right) {/* self-assignment */}
left.i -= right.i;
return left;

}

Integer& operator*=(Integer& left, const Integer& right)
{

if(&left == &right) {/* self-assignment */}
left.i *= right.i;
return left;

}

Integer& operator/=(Integer& left, const Integer& right)
{

require(right.i != 0, "divide by zero");
if(&left == &right) {/* self-assignment */}
left.i /= right.i;
return left;

}

Integer& operator%=(Integer& left, const Integer& right)
{

require(right.i != 0, "modulo by zero");
if(&left == &right) {/* self-assignment */}
left.i %= right.i;
return left;

}

Integer& operator^=(Integer& left, const Integer& right)
{

if(&left == &right) {/* self-assignment */}
left.i ^= right.i;
return left;

}

Integer& operator&=(Integer& left, const Integer& right)
{

if(&left == &right) {/* self-assignment */}
left.i &= right.i;
return left;

}

Integer& operator|=(Integer& left, const Integer& right)
{

if(&left == &right) {/* self-assignment */}
left.i |= right.i;
return left;

}

Integer& operator>>=(Integer& left, const Integer& right)
{

if(&left == &right) {/* self-assignment */}
left.i >>= right.i;
return left;

}

Integer& operator<<=(Integer& left, const Integer& right)
{

if(&left == &right) {/* self-assignment */}
left.i <<= right.i;
return left;

}

/* Conditional operators return true/false: */
int operator==(const Integer& left,const Integer& right)
{

return left.i == right.i;

}

int operator!=(const Integer& left, const Integer& right)
{

return left.i != right.i;

}

int operator<(const Integer& left, const Integer& right)
{

return left.i < right.i;

}

int operator>(const Integer& left, const Integer& right)
{

return left.i > right.i;

}

int operator<=(const Integer& left,const Integer& right)
{

return left.i <= right.i;

}

int operator>=(const Integer& left, const Integer& right)
{

return left.i >= right.i;

}

int operator&&(const Integer& left, const Integer& right)
{

return left.i && right.i;

}

int operator||(const Integer& left, const Integer& right)
{

return left.i || right.i;

} ///:~