// file      : boost/common/smart-ptr/driver.cxx
// author    : Constantin Michael <constantin@codesynthesis.com>
// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
// license   : GNU GPL v2; see accompanying LICENSE file

// Test boost smart pointers.
//

#include <memory>   // std::auto_ptr
#include <cassert>
#include <iostream>

#include <odb/database.hxx>
#include <odb/transaction.hxx>

#include <common/common.hxx>

#include "test.hxx"
#include "test-odb.hxx"

using namespace std;

using namespace odb::boost;
using namespace odb::core;

int
main (int argc, char* argv[])
{
  using boost::shared_ptr;

  try
  {
    auto_ptr<database> db (create_database (argc, argv));

    shared_ptr<cont> c1 (new cont (1));
    {
      transaction t (db->begin ());
      db->persist (c1);
      t.commit ();
    }

    // Test comparison operators.
    //
    {
      assert (lazy_shared_ptr<cont> () == lazy_shared_ptr<cont> ());
      assert (lazy_shared_ptr<cont> () != lazy_shared_ptr<cont> (c1));
      assert (lazy_shared_ptr<cont> (c1) == lazy_shared_ptr<cont> (c1));

      lazy_shared_ptr<cont> lc1 (*db, 1);
      assert (lc1 != lazy_shared_ptr<cont> ());
      assert (lc1 == lazy_shared_ptr<cont> (*db, c1));

      shared_ptr<cont> c2 (new cont (2));
      assert (lc1 != lazy_shared_ptr<cont> (*db, c2));
    }

    // Test swap.
    //
    {
      lazy_shared_ptr<cont> lx (*db, 1), ly;
      assert (lx == lazy_shared_ptr<cont> (*db, c1));

      swap (lx, ly);
      assert (lx == lazy_shared_ptr<cont> ());
      assert (ly == lazy_shared_ptr<cont> (*db, c1));
    }

    // Test assignment from auto_ptr.
    //
    {
      cont* p = new cont (3);
      auto_ptr<cont> a (p);
      lazy_shared_ptr<cont> l;
      l = a;

      assert (l.get() == p);
      assert (!a.get ());
    }

    shared_ptr<obj> o1 (new obj (1));
    shared_ptr<obj> o2 (new obj (2));
    shared_ptr<obj> o3 (new obj (3));
    shared_ptr<obj> o4 (new obj (4));
    shared_ptr<cont> c2 (new cont (2));

    o1->c = c1;
    o2->c = c1;
    o3->c = c2;
    o4->c = c2;

    // Persist.
    //
    {
      transaction t (db->begin ());

      db->persist (o1);
      db->persist (o2);
      db->persist (o3);
      db->persist (o4);
      db->persist (c2);

      t.commit ();
    }

    // Load.
    //
    {
      session s;
      transaction t (db->begin ());

      shared_ptr<cont> c (db->load<cont> (1));
      shared_ptr<obj> o (db->load<obj> (1));

      // Ensure that lazy pointers are present but not loaded.
      //
      assert (c->o.size () == 2);
      assert (!c->o[0].loaded ());
      assert (!c->o[1].loaded ());
      assert (!o->c.loaded ());

      // Ensure that the correct object IDs were loaded.
      //
      assert (c->o[0].object_id<obj> () == 1);
      assert (c->o[1].object_id<obj> () == 2);
      assert (o->c.object_id<obj> () == 1);

      // Load the lazy pointer targets ensuring that the loaded
      // targets correspond to the cached session objects.
      //
      shared_ptr<cont> cl (o->c.load ());
      shared_ptr<obj> ol (c->o[0].load ());

      assert (c->o[0].loaded ());
      assert (o->c.loaded ());

      assert (cl == c);
      assert (ol == o);

      t.commit ();
    }

    // Test lazy weak locking and reloading.
    //
    {
      // No session.
      //
      transaction t (db->begin ());
      shared_ptr<cont> c (db->load<cont> (1));

      // Lock.
      //
      assert (!c->o[1].loaded ());
      lazy_shared_ptr<obj> l (c->o[1].lock ());
      assert (!l.loaded ());
      assert (l.object_id<obj> () == c->o[1].object_id<obj> ());

      // Reload.
      //
      assert (!c->o[1].loaded ());

      shared_ptr<obj> ol (c->o[1].load ());
      assert (c->o[1].loaded ());

      ol.reset ();
      assert (!c->o[1].loaded ());

      ol = c->o[1].load ();
      assert (c->o[1].loaded ());

      t.commit ();
    }
  }
  catch (const odb::exception& e)
  {
    cerr << e.what () << endl;
    return 1;
  }
}
