CircularInt.hpp

/**
*hidden file of class CircularInt
*Authors Alexey Titov and Shir Bentabou
*Version 2.0
**/
#pragma once
//libraries
#include <iostream>
using namespace std;
//our class
class CircularInt{
    private:
        int min; //always set to 1 - constructor wise too
        int max; //always set to 12 - constructor wise too
        int pos; //its current position
        // std::exception runtime_error;
    public:
        //constructor with minimal and maximal values
        CircularInt(int MIN,int MAX){
            if (MIN>MAX){
                cout << "MIN larger than MAX!" << endl;
                exit(1);
            }
            min=MIN;
            max=MAX;
            pos=MIN;
        }
        
        //plus function - a general function that will help us with all addition operators
        int plus(int min, int max, int pos, int x);
        //minus function - a general function that will help us with all subtraction operators
        int minus(int min, int max, int pos, int x);
        //multiply function - a general function that will help us with all multiplying operators
        int multiply(int min, int max, int pos, int by_x);
        //division function - a general function that will help us with all dividing operators
        int divide(int min, int max, int pos, int by_x);
        //modulo function - a general function that will help us with all modulo operators
        int modulo(int min, int max, int pos, int mod);
        //normaliztion function - this function normalizes a number to the relevant range
        //helpful especially for bitwise operations in our code
        int normalization(int min, int max, int num);
        
        //Overloading for bitwise not '~' operator for hour type. Note that we don't change the value of the original
        //object sent to the function.
        const CircularInt operator~();
        
        //Overloading for '&=' operator for hour type! (using & function)
        CircularInt& operator&=(const int& other);

        //Overloading for '&=' operator for hour type! (using & function) (CircularInt)
        CircularInt& operator&=(const CircularInt& other);

        //Overloading for '|=' operator for hour type! (using | function)
        CircularInt& operator|=(const int& other);

        //Overloading for '|=' operator for hour type! (using | function) (CircularInt)
        CircularInt& operator|=(const CircularInt& other);

        //Overloading for '^=' operator for hour type! (using ^ function)
        CircularInt& operator^=(const int& other);

        //Overloading for '^=' operator for hour type! (using ^ function) (CircularInt)
        CircularInt& operator^=(const CircularInt& other);

        //Overloading for '<<=' operator for hour type! (using << function)
        CircularInt& operator<<=(const int& other);

        //Overloading for '<<=' operator for hour type! (using << function) (CircularInt)
        CircularInt& operator<<=(const CircularInt& other);

        //Overloading for '>>=' operator for hour type! (using >> function)
        CircularInt& operator>>=(const int& other);

        //Overloading for '>>=' operator for hour type! (using >> function) (CircularInt)
        CircularInt& operator>>=(const CircularInt& other);

        //Overloading for '+=' operator for hour type!
        CircularInt& operator+=(const int& other);

        //Overloading for '+=' operator for hour type! (using plus/minus functions) (CircularInt)
        CircularInt& operator+=(const CircularInt& other);

        //Overloading for '-=' operator for hour type!
        CircularInt& operator-=(const int& other);
        
        //Overloading for '-=' operator for hour type! (using plus/minus functions) (CircularInt)
        CircularInt& operator-=(const CircularInt& other);

        //Overloading for '*=' operator for hour type!
        CircularInt& operator*=(const int& mult);

        //Overloading for '*=' operator for hour type!(CircularInt)
        CircularInt& operator*=(const CircularInt& mult);

        //Overloading for '/=' operator for hour type!
        CircularInt& operator/=(const int& div);

        //Overloading for '/=' operator for hour type! (CircularInt)
        CircularInt& operator/=(const CircularInt& div);

        //Overloading for '%=' operator for hour type!
        CircularInt& operator%=(const int& mod);

        //Overloading for '%=' operator for hour type! (CircularInt)
        CircularInt& operator%=(const CircularInt& mod);

        //Overloading for 'var++' operator for hour type!
        int operator++(int);

        //Overloading for '++var' operator for hour type!
        CircularInt& operator++();

        //Overloading for 'var--' operator for hour type!
        int operator--(int);

        //Overloading for '--var' operator for hour type!
        CircularInt& operator--();

        //Overloading - operator for complementary action
        int operator-();

        //Overloading for '=' operator for hour type!
        CircularInt& operator =(const CircularInt& other);

        //Overloading '=' operator between hour object and int.
        CircularInt& operator =(const int& other);
        
        //----------------------------------
        // friend global IO operators
        //----------------------------------
        friend ostream& operator<< (ostream& os, const CircularInt& c);
        friend istream& operator>> (istream& is,CircularInt& c);
        //-------------------------------------
        // friend global binary operators
        //-------------------------------------
        friend const CircularInt operator - (const int a,const CircularInt& other);
        friend const CircularInt operator + (const int a,const CircularInt& other);
        friend const CircularInt operator - (const CircularInt& other,const int a);
        friend const CircularInt operator + (const CircularInt& other,const int a);
        friend const CircularInt operator + (const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator - (const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator * (const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator * (const int& a, const CircularInt& b);
        friend const CircularInt operator * (const CircularInt& b, const int& a);
        friend const CircularInt operator / (const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator / (const int& div, const CircularInt& b);
        friend const CircularInt operator / (const CircularInt& a,const int& div);
        friend bool operator == (const CircularInt& a, const CircularInt& b);
        friend bool operator == (const int& b, const CircularInt& a);
        friend bool operator == (const CircularInt& a, const int& b);
        friend bool operator != (const CircularInt& a, const CircularInt& b);
        friend bool operator != (const CircularInt& a, const int& b);
        friend bool operator != (const int& a, const CircularInt& b);
        friend bool operator > (const CircularInt& a, const CircularInt& b);
        friend bool operator > (const CircularInt& a, const int& b);
        friend bool operator > (const int& b, const CircularInt& a);
        friend bool operator < (const CircularInt& a, const CircularInt& b);
        friend bool operator < (const CircularInt& a, const int& b);
        friend bool operator < (const int& b, const CircularInt& a);
        friend bool operator >= (const CircularInt& a, const CircularInt& b);
        friend bool operator >= (const CircularInt& a, const int& b);
        friend bool operator >= (const int& b, const CircularInt& a);
        friend bool operator <= (const CircularInt& a, const CircularInt& b);
        friend bool operator <= (const CircularInt& a, const int& b);
        friend bool operator <= (const int& b, const CircularInt& a);
        friend const CircularInt operator%(const CircularInt& a, const int& mod);
        friend const CircularInt operator%(const int& mod, const CircularInt& a);
        friend const CircularInt operator%(const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator&(const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator&(const int& a, const CircularInt& b);
        friend const CircularInt operator&(const CircularInt& a, const int& b);
        friend const CircularInt operator|(const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator|(const int& a, const CircularInt& b);
        friend const CircularInt operator|(const CircularInt& a, const int& b);
        friend const CircularInt operator^(const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator^(const int& a, const CircularInt& b);
        friend const CircularInt operator^(const CircularInt& a, const int& b);
        friend const CircularInt operator<<(const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator<<(const int& a, const CircularInt& b);
        friend const CircularInt operator<<(const CircularInt& a, const int& b);
        friend const CircularInt operator>>(const CircularInt& a, const CircularInt& b);
        friend const CircularInt operator>>(const int& a, const CircularInt& b);
        friend const CircularInt operator>>(const CircularInt& a, const int& b);


        
};
//----------------------------------------
// friend global IO operators
//----------------------------------------
ostream& operator<< (ostream& os, const CircularInt& c);
istream& operator>> (istream& is,CircularInt& c);
//-------------------------------------
// friend global binary operators
//-------------------------------------
//Overloading for '-' operator for hour type! (int and CircularInt)
const CircularInt operator - (const int a,const CircularInt& other);

//Overloading for '-' operator for hour type! (CircularInt and int)
const CircularInt operator - (const CircularInt& other,const int a);

//Overloading for '+' operator for hour type! (int and CircularInt)
const CircularInt operator+(const int a,const CircularInt& other);

//Overloading for '+' operator for hour type! (CircularInt and int)
const CircularInt operator+(const CircularInt& other,const int a);

//Overloading for '+' operator for hour type! (CircularInt and CircularInt)
const CircularInt operator + (const CircularInt& a, const CircularInt& b);

//Overloading for '-' operator for hour type! (CircularInt and CircularInt)
const CircularInt operator - (const CircularInt& a, const CircularInt& b);

//Overloading for '*' operator for hour type! (CircularInt and CircularInt)
const CircularInt operator*(const CircularInt& a, const CircularInt& b);

//Overloading for '*' operator for hour type! (int and CircularInt)
const CircularInt operator*(const int& a, const CircularInt& b);

//Overloading for '*' operator for hour type! (CircularInt and int)
const CircularInt operator*(const CircularInt& b, const int& a);

//Overloading for '/' operator for hour type! (CircularInt and CircularInt)
const CircularInt operator/(const CircularInt& a, const CircularInt& b);

//Overloading for '/' operator for hour type! (int and CircularInt)
const CircularInt operator/(const int& div, const CircularInt& b);

//Overloading for '/' operator for hour type! (CircularInt and int)
const CircularInt operator / (const CircularInt& a,const int& div);

//Overloading for '==' operator for hour type! (Two CircularInt types)
bool operator == (const CircularInt& a, const CircularInt& b);

//Overloading for '==' operator for hour type! (CircularInt and int)
bool operator == (const CircularInt& a, const int& b);

//Overloading for '==' operator for hour type! (int and CircularInt)
bool operator == (const int& b, const CircularInt& a);

//Overloading for '!=' operator for hour type! (Two CircularInt types)
bool operator != (const CircularInt& a, const CircularInt& b);

//Overloading for '!=' operator for hour type! (CircularInt and int)
bool operator != (const CircularInt& a, const int& b);

//Overloading for '!=' operator for hour type! (Int and CircularInt )
bool operator != (const int& a, const CircularInt& b);

//Overloading for '>' operator for hour type! (Two CircularInt types)
bool operator > (const CircularInt& a, const CircularInt& b);

//Overloading for '>' operator for hour type! (CircularInt and int)
bool operator > (const CircularInt& a, const int& b);

//Overloading for '>' operator for hour type! (int and CircularInt)
bool operator > (const int& b, const CircularInt& a);

//Overloading for '<' operator for hour type! (Two CircularInt types)
bool operator < (const CircularInt& a, const CircularInt& b);

//Overloading for '<' operator for hour type! (CircularInt and int)
bool operator < (const CircularInt& a, const int& b);

//Overloading for '<' operator for hour type! (Int and CircularInt)
bool operator < (const int& b, const CircularInt& a);

//Overloading for '>=' operator for hour type! (Two CircularInt types)
bool operator >= (const CircularInt& a, const CircularInt& b);

//Overloading for '>=' operator for hour type! (CircularInt and int)
bool operator >= (const CircularInt& a, const int& b);

//Overloading for '>=' operator for hour type! (Int and CircularInt)
bool operator >= (const int& b, const CircularInt& a);


//Overloading for '<=' operator for hour type! (Two CircularInt types)
bool operator <= (const CircularInt& a, const CircularInt& b);

//Overloading for '<=' operator for hour type! (CircularInt and int)
bool operator <= (const CircularInt& a, const int& b);

//Overloading for '<=' operator for hour type! (Int and CircularInt)
bool operator <= (const int& b, const CircularInt& a);

//Overloading for '%' operator for hour type!
const CircularInt operator%(const CircularInt& a, const int& mod);

//Overloading for '%' operator for hour type! (int and CircularInt)
const CircularInt operator%(const int& mod, const CircularInt& a);

//Overloading for '%' operator for hour type! (Two CircularInts)
const CircularInt operator%(const CircularInt& a, const CircularInt& b);

//Overloading for bitwise '&' operator for hour type! (Two CircularInts)
const CircularInt operator&(const CircularInt& a, const CircularInt& b);

//Overloading for bitwise '&' operator for hour type! (int and CircularInt)
const CircularInt operator&(const int& a, const CircularInt& b);

//Overloading for bitwise '&' operator for hour type! (CircularInt and int)
const CircularInt operator&(const CircularInt& a, const int& b);

//Overloading for bitwise '|' operator for hour type! (Two CircularInts)
const CircularInt operator|(const CircularInt& a, const CircularInt& b);

//Overloading for bitwise '|' operator for hour type! (int and CircularInt)
const CircularInt operator|(const int& a, const CircularInt& b);

//Overloading for bitwise '|' operator for hour type! (CircularInt and int)
const CircularInt operator|(const CircularInt& a, const int& b);

//Overloading for bitwise '^' operator for hour type! (Two CircularInts)
const CircularInt operator^(const CircularInt& a, const CircularInt& b);

//Overloading for bitwise '^' operator for hour type! (int and CircularInt)
const CircularInt operator^(const int& a, const CircularInt& b);

//Overloading for bitwise '^' operator for hour type! (CircularInt and int)
const CircularInt operator^(const CircularInt& a, const int& b);

//Overloading for bitwise '<<' operator for hour type! (Two CircularInts)
const CircularInt operator<<(const CircularInt& a, const CircularInt& b);

//Overloading for bitwise '<<' operator for hour type! (int and CircularInt)
const CircularInt operator<<(const int& a, const CircularInt& b);

//Overloading for bitwise '<<' operator for hour type! (CircularInt and int)
const CircularInt operator<<(const CircularInt& a, const int& b);

//Overloading for bitwise '>>' operator for hour type! (Two CircularInts)
const CircularInt operator>>(const CircularInt& a, const CircularInt& b);

//Overloading for bitwise '>>' operator for hour type! (int and CircularInt)
const CircularInt operator>>(const int& a, const CircularInt& b);

//Overloading for bitwise '>>' operator for hour type! (CircularInt and int)
const CircularInt operator>>(const CircularInt& a, const int& b);