#include <Core/Core.h>

using namespace Upp;

class Foo: Moveable<Foo> {
    int a;
    Foo *foo;
    int *ptr;
public:
    void Set(Foo * f) {
        foo = f;
    }
  
void Bad1() {
        foo = this;
    // member variable foo exists outside method
    // -> makes Foo non-moveable
    }       
    ~Foo() {
     
    }
};

template <typename T> class Metallica
{
   T * t;
   public:
   
   Metallica (){};
   
   void Set(T * t1) {
        t = t1;
    
    
   }
   
    ~Metallica() {
    AssertMoveable<T>();  
    }
};

CONSOLE_APP_MAIN
{
	
	Metallica<Foo> lu;
	
}

	Foo f, f2;
	
	f.Set(&f2);
   
    //Foo && r2 = std::move(f) ;
    
    // int b = r2.Get();
    
    //  Cout() << b;
    
    Vector<Foo> v1;
    
    v1.Add(f);
    
    Vector<int> n;
    n.Add(3);
  

class Foo:Moveable<Foo>  {
    
    char * buffer;
public:
    
    Foo(){
    buffer = NULL;
    }
    
    Foo(const char * c) {
        if( c!=NULL)
        {
            buffer= new char [strlen(c) + 1];
            strcpy(buffer, c);
        } else
             buffer = NULL;
    }
    
  Foo(Foo&& foosrc) {
      if(foosrc.buffer !=NULL) {
          buffer=foosrc.buffer;
         foosrc.buffer = NULL;
      }
}

CONSOLE_APP_MAIN
{
    Foo f("foo");
    Foo && r2 = std::move(f) ;
    
    Vector<Foo> v1;
     
     v1.Add(r2);
  	
}

class Foo: Moveable<Foo>  {
    
    char * buffer;
    
public:
	Foo()=default;
    Foo(const char * c);
    Foo( const Foo&) =default;
   
    Foo(Foo&&) = default;
    Foo& operator=(Foo&&) = default;
    String Get(){
        return buffer;
    }
    ~Foo() {
     AssertMoveable<Foo>();   
     delete buffer;
    }
};

Foo::Foo(const char * c) {
        if( c!=NULL)
        {
            buffer= new char [strlen(c) + 1];
            strcpy(buffer, c);
        } else
             buffer = NULL;
    }
   
  

CONSOLE_APP_MAIN
{
    Foo f("foo");
	Foo && r2 = std::move(f); 
    Foo &  j = r2 ;
    
    Vector<Foo> a, b;
    b.Add(r2);
    
    Foo & myval = b.At(0);
    Cout() << myval.Get();
  
  	
}