/* This is test code for SmarterP.  
 * Compile this with:  g++ -ggdb TestSmarterP.C
 * Do not add this to a production program.
 */


#include "SmarterP.h"

#include <iostream>
#include <memory>
#include <stdint.h>


SmarterCP< int > make(int a, int b)
{
  const SmarterP< int > result(NULL, a);
  (*result) += b;
  return result;
  //return SmarterP< int >(nullptr, a+b);
}

SmarterP< int > makeNonConst(int a)
{
  const SmarterP< int > result(NULL, a);
  (*result) *= a;
  return result;
}

std::shared_ptr< int16_t > sp;

int main(int, char **)
{
  std::cout<<sizeof(sp)<<std::endl;
  // 16 -- A std::shared_ptr contains two pointers.  One to the control block,
  // a piece of hidden dynamic memory than contains two counters, and the other to
  // the object itself.  This is a powerful setup.  It allows for weak references
  // and type casting.  We don't need that most of the time, but it's available when
  // you need it.
  
  SmarterP< int > i;
  std::cout<<sizeof(i)<<std::endl;
  // 8 -- A SmarterP only contains one pointer.  The control block and the value
  // are both allocated in a single piece of dynamic memory.  Most of the time we
  // don't need all that's offered by a std::shared_ptr, so why pay for it?

  SmarterCP< int > ic;
  //i = ic;
  ic = i;
  ic = make(6, 7);
  //ic.emplace(6+7);
  i.emplace(*ic);
  std::cout<<"ic = "<<(*ic)<<", i = "<<(*i)<<", i==ic = "<<((i==ic)?"yes":"no")<<std::endl;
  i.emplace(7);
  ic = i;
  std::cout<<"ic = "<<(*ic)<<", i = "<<(*i)<<", i==ic = "<<((i==ic)?"yes":"no")<<std::endl;
  ic.clear();
  ic.clear();
  i = makeNonConst(99);
  std::cout<<"i = "<<(*i)<<std::endl;
  ic = i;
  (*i)++;
  i.unshare();
  (*i)++;
  // We're expecting
  std::cout<<"ic = "<<(*ic)<<", i = "<<(*i)<<std::endl;

  /*
  class A
  {
  private:
    int _a;
  public:
    A(int a) : _a(a) { }
    virtual ~A() { std::cout<<" ~A("<<_a<<") "; }
  };
  class B
  {
  private:
    int _b;
  public:
    B(int b) : _b(b) { }
    ~B() { std::cout<<" ~B("<<_b<<") "; }
  };
  class AB : public A, public B
  {
  public:
    AB(int a, int b) : A(a), B(b) { }
  };
  class BA : public B, public A
  {
  public:
    BA(int b, int a) : B(b), A(a) { }
  };
  SmarterP< A > spa(NULL, 1);
  SmarterP< B > spb(NULL, 2);
  SmarterP< AB > spab(NULL, 3, 4);
  SmarterP< BA > spba(NULL, 5, 6);
  spa = spab;
  spb = spab;
  */

  std::string myString = "Hello world";
  SmarterP< std::string > ss1(nullptr, myString);
  SmarterP< std::string > ss2(nullptr, std::move(myString));
  SmarterP< std::string > ss3(nullptr, myString);
  // Expected result:  “Hello world”, “Hello world”, “”
  std::cout<<"“"<<*ss1<<"”, “"<<*ss2<<"”, “"<<*ss3<<"”"<<std::endl;

  class Trace
  {
  private:
    std::string _value;
  public:
    std::string get() const { return _value; }
    Trace(std::string const &value) : _value(value)
    { std::cout<<"Trace(const &"<<value<<") "<<std::endl; }
    Trace(std::string &&value) : _value(value)
    { std::cout<<"Trace(&&"<<value<<") "<<std::endl; value = "move&&" + value; }
    ~Trace() { std::cout<<" ~Trace("<<_value<<") "<<std::endl; }
  };

  Trace tr_a("tr_a");
  // Output:  Trace(&&tr_a)
  // Uses && as expected
  Trace tr_b(tr_a.get());
  // Output:  Trace(&&tr_a)
  // Uses && as expected.  get() returns a temporary string, not a const& string.
  myString = "tr_c";
  Trace tr_c(myString);
  // Output:  Trace(const &tr_c)
  // Uses const &, as expected.  It's referencing a variable.
  Trace tr_d(std::move(myString));
  // Output:  Trace(&&tr_c)
  // Uses && and destroys myString as expected.
  Trace tr_e(myString+"çÇ");
  // Output:  Trace(&&move&&tr_cçÇ)
  // Uses && as expected.  Note that "move&&" was added by the previous call to
  // Trace's move constructor.
  Trace tr_f(myString);
  // Output:  Trace(const &move&&tr_c)
  // Uses const & as expected.  Still using a variable that was destroyed by
  // a previous call to std::move().

  SmarterP< Trace > sp_tr;
  sp_tr.emplace("tr_a");
  // Output:  Trace(&&tr_a)
  // That is correct.  The char * was converted into an unnamed std::string, which
  // was passed to the Trace constructor.  C++ picked the && version of the
  // constructor the string was an "xvalue", a.k.a. an "expiring value."
  sp_tr.emplace(tr_a.get());
  // Output:   ~Trace(tr_a)
  // Output:  Trace(&&tr_a)
  // That is correct.  Delete the old value in the smart pointer.  The use the
  // move constructor for a fairly textbook example.  get() returns a std::string.
  myString = "tr_c";
  sp_tr.emplace(myString);
  // Output:   ~Trace(tr_a)
  // Output:  Trace(const &tr_c)
  // That is correct.  myString is a variable and other people can use it, so you
  // should transfer it as a const reference.
  sp_tr.emplace(std::move(myString));
  // Output:   ~Trace(tr_c) 
  // Output:  Trace(&&tr_c) 
  // That is correct.  Using the move constructor because I explicitly told it to.
  sp_tr.emplace(myString+"çÇ");
  // Output:   ~Trace(tr_c) 
  // Output:  Trace(&&move&&tr_cçÇ) 
  // That is correct.  The output of operator+ is a temporary string.  It's a
  // perfect example of an xvalue.  Notice how the value of myString was destroyed
  // by the previous call to std::move() combined with the move constructor.
  sp_tr.emplace(myString);
  // Output:   ~Trace(move&&tr_cçÇ) 
  // Output:  Trace(const &move&&tr_c) 
  // Copy constructor, as expected, when reading from a variable.  Again, the value
  // of the string was destroyed by calling std::move() too soon.
  
  // Output:  End of main().
  // Destructor for variable sp_tr
  // Output:   ~Trace(move&&tr_c)
  // Destructor for variable tr_f
  // Output:   ~Trace(move&&tr_c) 
  // Destructor for variable tr_e
  // Output:   ~Trace(move&&tr_cçÇ)  
  // Destructor for variable tr_d
  // Output:   ~Trace(tr_c) 
  // Destructor for variable tr_c
  // Output:   ~Trace(tr_c) 
  // Destructor for variable tr_b
  // Output:   ~Trace(tr_a) 
  // Destructor for variable tr_a
  // Output:   ~Trace(tr_a) 

  class Trace1
  {
  private:
    std::string _value;
    void show(bool constructor) const
    {
      if (!constructor)
	std::cout<<'~';
      std::cout<<"Trace1("<<_value<<')'<<std::endl;
    }
  public:
    Trace1(std::string const &input) :
      _value("(created from string:  " + input + ')') { show(true); }
    Trace1(Trace1 const &input) : _value("(copied:  " + input._value + ')')
    { show(true); }
    Trace1(Trace1 &&input) : _value("(moved:  " + input._value + ')')
    { input._value = "[destroyed:  " + input._value + ']'; show(true); }
    ~Trace1() { show(false); }
  };

  SmarterP< Trace1 > sp_tr1;
  Trace1 a("a");
  Trace1 b("b");
  Trace1 c("c");
  sp_tr1.emplace("d");
  sp_tr1.emplace(a);
  sp_tr1.emplace(b);
  sp_tr1.emplace(Trace1("unnamed object"));
  sp_tr1.emplace(c);
  sp_tr1.emplace(std::move(c));
  /* Output:
Trace1((created from string:  a))
Trace1((created from string:  b))
Trace1((created from string:  c))
Trace1((created from string:  d))
~Trace1((created from string:  d))
Trace1((copied:  (created from string:  a)))
~Trace1((copied:  (created from string:  a)))
Trace1((copied:  (created from string:  b)))
Trace1((created from string:  unnamed object))
~Trace1((copied:  (created from string:  b)))
Trace1((moved:  (created from string:  unnamed object)))
~Trace1([destroyed:  (created from string:  unnamed object)])
~Trace1((moved:  (created from string:  unnamed object)))
Trace1((copied:  (created from string:  c)))
~Trace1((copied:  (created from string:  c)))
Trace1((moved:  (created from string:  c)))
End of main().
~Trace1([destroyed:  (created from string:  c)])
~Trace1((created from string:  b))
~Trace1((created from string:  a))
~Trace1((moved:  (created from string:  c)))
   */
  
  std::cout<<"End of main()."<<std::endl;
  
  return 0;
}