//To compile and run: c++ -std=c++11 unique_ptr.cc && ./a.out
//Small program showing ownership w/ unique_ptr.
//Class G4Class_cxx11 owns a pointer to an instance of G4Something via
//std::unique_ptr.
//The main function exercises owenership getting/setting pointer via old
//interface using raw-pointers and unique_ptr, pay attention to the address of the
//owned G4Something object. Note how the pointer becomes nullptr when ownership is
//moved around and only one pointer referencing the pointee is existing at any given
//time
#include <memory>
#include <iostream>
#include <initializer_list>

struct G4Something {
  G4Something(double _a,double _b,double _c): a(_a),b(_b),c(_c) {}
  G4Something() = default;
  G4Something(const G4Something& other ) : a(other.a),b(other.b),c(other.c) { std::cout<<"G4Something copy constructor called"<<std::endl; }
  G4Something(G4Something&& other ) : a(std::move(other.a)),b(std::move(other.b)),c(std::move(other.c)) { std::cout<<"G4Something move constructor called"<<std::endl; }
  G4Something& operator=(const G4Something& other) {
    std::cout<<"G4Something assignement operator called"<<std::endl;
    if ( this == &other ) return *this;
    a=other.a;
    b=other.b;
    c=other.c;
    return *this;
  }
  G4Something& operator=(G4Something&& other) {
    std::cout<<"G4Something move assignment operator called"<<std::endl;
    if (this == &other ) return *this;
    a = std::move(other.a);
    b = std::move(other.b);
    c = std::move(other.c);
    return *this;
  }
  ~G4Something() { std::cout<<"G4Something destructor called"<<std::endl; }
  double a;
  double b;
  double c;
};

std::ostream& operator<<(std::ostream& os , const G4Something& g4o)
{
  os <<"{"<<g4o.a<<","<<g4o.b<<","<<g4o.c<< "} @ "<<&g4o;
  return os;
}

struct G4Class_cxx11 {
  std::unique_ptr<G4Something> pointer;
  G4Class_cxx11() : pointer()
  {
    std::cout<<"G4Class_cxx11::Default constructor"<<std::endl;
  }
  ~G4Class_cxx11()
  {
    std::cout<<"G4Class_cxx11::Destructor"<<std::endl;
  }

  G4Class_cxx11(const G4Class_cxx11& other) : pointer() {
    if ( other.pointer != nullptr ) {
      pointer = std::move( std::unique_ptr<G4Something>(new G4Something(*other.pointer) ) );
    }
    std::cout<<"G4Class_cxx11::Copy constructor"<<std::endl;
  }
  
  G4Class_cxx11& operator=(const G4Class_cxx11& other) {
    if ( this == &other ) return *this;
    if ( other.pointer != nullptr ) {
      pointer = std::move( std::unique_ptr<G4Something>( new G4Something(*other.pointer) ) );
    } else {
      pointer = std::move( std::unique_ptr<G4Something>() );
    }
    std::cout<<"G4Class_cxx11::Assignment operator "<<std::endl;
    return *this;
  }
  G4Class_cxx11(G4Class_cxx11&& other) : pointer() {
    if ( this == &other) return;
    pointer = std::move( other.pointer );
    std::cout<<"G4Class_cxx11::Move constructor "<<std::endl;
  }
  
  G4Class_cxx11& operator=(G4Class_cxx11&& other) {
    if ( this != &other ) {
      pointer = std::move( other.pointer );
    }
    std::cout<<"G4Class_cxx11::Move assignement operator "<<std::endl;
    return *this;
  }

  //TODO: Understand exactly role of r-value reference here
  void set( std::unique_ptr<G4Something>&& p ) { //****************************
    std::cout<<"G4Class_cxx11::set w/ unique_ptr called"<<std::endl;
    pointer = std::move(p);
  }
  
  std::unique_ptr<G4Something> get() {   //****************************
    std::cout<<"G4Class_cxx11::get unique_ptr called "<<std::endl;
    return std::move(pointer); //The move is mandatory
  }

  //legacy interfaces
  //Ambigous, who owns p?
  void set( G4Something* p ) {
    std::cout<<"G4Class_cxx11:: set old style called"<<std::endl;
    pointer = std::unique_ptr<G4Something>(new G4Something(*p) );
  }

  //Ambigous, to remove
  G4Something* get_old() const {
    std::cout<<"G4Class_cxx11::get pointer old style called"<<std::endl;
    return pointer.get();
  }
  //Better: get lvalue reference 
  const G4Something& get_const() const { //****************************
    std::cout<<"G4Class_cxx11::get refernece old style called"<<std::endl;
    return *pointer.get();
  }

  
  friend std::ostream& operator<<(std::ostream&, const G4Class_cxx11&);
};

std::ostream& operator<<(std::ostream& os , const G4Class_cxx11& g4o ) {
  os<<"G4Class_cxx11 @ "<<&g4o<<" pointer="<<g4o.pointer.get();
  return os;
}

int main(int,char**) {
   G4Something* smt = new G4Something{ 1.,2.,3.};
   std::cout<<"G4Something created:"<<*smt<<std::endl;
   std::cout<<"Create a container object: ";
   G4Class_cxx11* cnew = new G4Class_cxx11;
   std::cout<<*cnew<<std::endl;
   
   std::cout<<"Let's use the \"old\" interface to set and get the pointer to G4Something, note the value of the pointers as seen from G4Class_cxx11..."<<std::endl;
   cnew->set( smt );
   std::cout<<"Set done: "<<*cnew<<std::endl;
   std::cout<<"Now test getters"<<std::endl;
   G4Something* temp = cnew->get_old();
   const G4Something& temp2 = cnew->get_const();
   std::cout<<"Old get pointer returns: "<<temp<<std::endl;
   std::cout<<"get2 returns: "<<&temp2<<std::endl;
   std::cout<<"Now container object is: "<<*cnew<<std::endl;
   std::cout<<"Delete container object"<<std::endl;
   delete cnew;
   std::cout<<"Note that G4Something is still valid: "<<*smt<<std::endl;

   std::cout<<"======================================"<<std::endl;
   std::cout<<"Now test new interfaces with ownership, first create anothe instance of G4Something: ";
   std::unique_ptr<G4Something> smt2(new G4Something{1,2,3} );
   std::cout<<*smt2<<std::endl;
   std::cout<<"Create G4Class_cxx11 instance"<<std::endl;
   G4Class_cxx11 cnew2;
   std::cout<<cnew2<<std::endl;
   cnew2.set( std::move(smt2) ); //The std::move is mandatory
   std::cout<<cnew2<<std::endl;
   //std::cout<<*smt2<<std::endl;//This is illegal and will cause segmentaiton fault, smt2 is not valid anymore
   std::cout<<"Now testing getters: "<<std::endl;
   const G4Something& temp3 = cnew2.get_const();
   std::cout<<"get2 returns : "<<temp3<<std::endl;
   std::unique_ptr<G4Something> pp = cnew2.get();
   std::cout<<"get ownership: "<<*pp<<std::endl;
   std::cout<<"And now container is: "<<cnew2<<std::endl;

   std::cout<<"Done exiting, G4class_cxx11 instance will be deleted"<<std::endl;
  

   return 0;
}