/* --------------------------------------------------------------------------
operator.cpp

Tekijä: 	Miika Nurminen
Pvm:		8.2.2001, laajennettu 28.11.2007
Tarkoitus:	Demonstroida Template-operaattorien käyttöä.
-------------------------------------------------------------------------- */
#include <iostream>
#include <cstdio>
#include <sstream>
#include <exception>
#include <stdexcept>
using namespace std;

class B;

class A {
private:
    int value; 
public:
    A(int a) {value=a;}

    bool operator==(const A& m) const {
    	return (value==m.value);
    }
    bool operator<(const A& m) const {
    	return (value<m.value);
    }
    
    /**
     * muunnosoperaatio B:ksi 
     */
    operator B() const;
};


/** 
 * Jos A ja B-luokilla ei ole mitään muuta erottavaa 
 * toiminnallisuutta, myös niiden generointiin voisi 
 * käyttää luokkamallia
 */
class B {
private:
    string value; 
public:
    B(string a) {value=a;}

    bool operator==(const B& m) const {
        if (value==m.value) return true;
        return false;
    }
    bool operator<(const B& m) const {
        if (value<m.value) return true;
        return false;
    }
    
    /**
     * heittää logic_errorin jos muunnos merkkijonosta 
     * luvuksi ei onnistu
     */
    operator A()  const  throw (logic_error) {
    	int i=0;
    	if (sscanf(value.c_str(),"%d",&i)==0) throw logic_error(string("ei voi muuttaa "+value+" -> int")); 
    	return A(i);
    }
};

    A::operator B() const {
    	stringstream a;
    	a << value; // int -> string-muunnos stringstreamilla
    	return B(a.str());
    }


// yleisten vertailuoperaattorien generointi edellyttää,
// että ==/!= ja jokin vertailuoperaattori on määritelty

template <class T> bool operator<=(const T &a, const T &b) {
	return ( (a<b) || (a==b) );
}

template <class T> bool operator>(const T &a, const T &b) {
	return ( (!(a<b)) && (!(a==b)) );
}

template <class T> bool operator>=(const T &a, const T &b) {
	return (!(a<b));
}

template <class T> bool operator!=(const T &a, const T &b) {
    return (!(a==b));
}

int main(int argc, char* argv[]) {
	try {
	    A a(2);
	    A b(2);
	    A c(3);
	    if (a<=b) cout << "<= toimii" << endl;
	    if (a==b) cout << "== toimii" << endl;
	    if (c>b) cout << "> toimii" << endl;
	    if (c<=b) cout << "ei toimi" << endl;
	    if (c!=b) cout << "!= toimii" << endl;
	    
	    B d("testi");
	    B e("toinen");
	    if (d<e) cout << "<= toimii" << endl;
	  
	//    eri tyyppien vertailu ei onnistu, ellei ole
	//    määritelty muunnosoperaattoria tai eksplisiittistä muunnosta    
	    if (static_cast<B>(a)<d) cout << "eri tyypit (a<d)" << endl;
	    if (d<static_cast<B>(a)) cout << "eri tyypit (d<a)" << endl;
	    
	    A f(2);
	    B g = f; // implisiittinen tyypinmuunnos A -> B
	    if (g==a) cout << "toimii (\"2\"==2)" << endl;
	    
	    B h("3");
	    // implisiittinen muunnos A -> B
	    if (h==c) cout << "toimii (3==\"3\")" << endl; 
	
	    // jos B-luokalla ei ole muunnosoperaattoria A:han,
	    // toisin päin verrattaessa tarvitaan eksplisiittinen muunnos
	    if (c==h) cout << "toimii (3==\"3\") (B:n muunnosoperaattori)" << endl;
	    if (static_cast<B>(c)==h) cout << "toimii (3==\"3\") (A:n muunnosoperaattori)" << endl;
	    
	    a = d; // poikkeus! "testi"-merkkijonon muuntaminen numeroksi 
	           // ei onnistu
	}
	catch (exception& e) {
		cout << e.what();
	}

    return 0;
}