/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2007 INRIA, Gustavo Carneiro

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Authors: Gustavo Carneiro <gjcarneiro@gmail.com>,

 *          Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 */

#include "test.h"

#include "object.h"

#include "object-factory.h"

#include "assert.h"

#include "singleton.h"

#include "attribute.h"

#include "log.h"

#include "string.h"

#include <vector>

#include <sstream>

NS_LOG_COMPONENT_DEFINE ("Object");

namespace ns3 {

/*********************************************************************

 *         The Object implementation

 *********************************************************************/

NS_OBJECT_ENSURE_REGISTERED (Object);

Object::AggregateIterator::AggregateIterator ()

    m_current (0)

{}

bool 

Object::AggregateIterator::HasNext (void) const

{

}

Ptr<const Object> 

Object::AggregateIterator::Next (void)

{

}

{}

TypeId 

Object::GetInstanceTypeId (void) const

{

  return m_tid;

}

TypeId 

Object::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::Object")

    .SetParent<ObjectBase> ()

    ;

  return tid;

}

Object::Object ()

  : m_count (1),

    m_tid (Object::GetTypeId ()),

    m_disposed (false),

Object::~Object () 

{

}

Object::Object (const Object &o)

  : m_count (1),

    m_tid (o.m_tid),

    m_disposed (false),

uint32_t

Object::GetReferenceCount (void) const

{

  return m_count;

}

void

Object::Construct (const AttributeList &attributes)

{

  ConstructSelf (attributes);

}

Ptr<Object>

Object::DoGetObject (TypeId tid) const

{

  NS_ASSERT (CheckLoose ());

  TypeId objectTid = Object::GetTypeId ();

  return 0;

}

void 

Object::Dispose (void)

{

}

void 

Object::AggregateObject (Ptr<Object> o)

{

  NS_ASSERT (!m_disposed);

  NS_ASSERT (!o->m_disposed);

  NS_ASSERT (CheckLoose ());

  NS_ASSERT (o->CheckLoose ());

  if (DoGetObject (o->GetInstanceTypeId ()))

    {

      NS_FATAL_ERROR ("Object::AggregateObject(): "

                      "Multiple aggregation of objects of type " << 

                      o->GetInstanceTypeId ().GetName ());

    }

  Object *other = PeekPointer (o);

    {

}

/**

 * This function must be implemented in the stack that needs to notify

 * other stacks connected to the node of their presence in the node.

 */

void

Object::NotifyNewAggregate ()

{

}

Object::AggregateIterator 

Object::GetAggregateIterator (void) const

{

  return AggregateIterator (this);

}

void 

Object::SetTypeId (TypeId tid)

{

  NS_ASSERT (Check ());

  m_tid = tid;

}

void

Object::DoDispose (void)

{

  NS_ASSERT (!m_disposed);

}

bool 

Object::Check (void) const

{

  return (m_count > 0);

}

/* In some cases, when an event is scheduled against a subclass of

 * Object, and if no one owns a reference directly to this object, the

 * object is alive, has a refcount of zero and the method ran when the

 * event expires runs against the raw pointer which means that we are

 * manipulating an object with a refcount of zero.  So, instead we

 * check the aggregate reference count.

 */

bool 

Object::CheckLoose (void) const

{

  uint32_t refcount = 0;

    {

      refcount += current->m_count;

    }

  return (refcount > 0);

}

void

Object::MaybeDelete (void) const

{

  // First, check if any of the attached

  // Object has a non-zero count.

  // Ensure we are disposed.

  // all attached objects have a zero count so, 

}

} // namespace ns3

namespace {

class BaseA : public ns3::Object

{

public:

  static ns3::TypeId GetTypeId (void) {

    static ns3::TypeId tid = ns3::TypeId ("BaseA")

      .SetParent (Object::GetTypeId ())

      .HideFromDocumentation ()

      .AddConstructor<BaseA> ();

    return tid;

  }

  BaseA ()

  {}

  virtual void Dispose (void) {}

};

class DerivedA : public BaseA

{

public:

  static ns3::TypeId GetTypeId (void) {

    static ns3::TypeId tid = ns3::TypeId ("DerivedA")

      .SetParent (BaseA::GetTypeId ())

      .HideFromDocumentation ()

      .AddConstructor<DerivedA> ();

    return tid;

  }

  DerivedA ()

  {}

  virtual void Dispose (void) {

    BaseA::Dispose ();

  }

};

class BaseB : public ns3::Object

{

public:

  static ns3::TypeId GetTypeId (void) {

    static ns3::TypeId tid = ns3::TypeId ("BaseB")

      .SetParent (Object::GetTypeId ())

      .HideFromDocumentation ()

      .AddConstructor<BaseB> ();

    return tid;

  }

  BaseB ()

  {}

  virtual void Dispose (void) {}

};

class DerivedB : public BaseB

{

public:

  static ns3::TypeId GetTypeId (void) {

    static ns3::TypeId tid = ns3::TypeId ("DerivedB")

      .SetParent (BaseB::GetTypeId ())

      .HideFromDocumentation ()

      .AddConstructor<DerivedB> ();

    return tid;

  }

  DerivedB ()

  {}

  virtual void Dispose (void) {

    BaseB::Dispose ();

  }

};

NS_OBJECT_ENSURE_REGISTERED (BaseA);

NS_OBJECT_ENSURE_REGISTERED (DerivedA);

NS_OBJECT_ENSURE_REGISTERED (BaseB);

NS_OBJECT_ENSURE_REGISTERED (DerivedB);

} // namespace anonymous

namespace ns3 {

// ===========================================================================

// Test case to make sure that we can make Objects using CreateObject.

// ===========================================================================

class CreateObjectTestCase : public TestCase

{

public:

  CreateObjectTestCase ();

  virtual ~CreateObjectTestCase ();

private:

  virtual bool DoRun (void);

};

CreateObjectTestCase::CreateObjectTestCase ()

  : TestCase ("Check CreateObject<Type> template function")

{

}

CreateObjectTestCase::~CreateObjectTestCase ()

{

}

bool

CreateObjectTestCase::DoRun (void)

{

  Ptr<BaseA> baseA = CreateObject<BaseA> ();

  NS_TEST_ASSERT_MSG_NE (baseA, 0, "Unable to CreateObject<BaseA>");

  //

  // Since baseA is a BaseA, we must be able to successfully ask for a BaseA.

  //

  NS_TEST_ASSERT_MSG_EQ (baseA->GetObject<BaseA> (), baseA, "GetObject() of same type returns different Ptr");

  //

  // Since BaseA is a BaseA and not a DerivedA, we must not find a DerivedA if we look.

  //

  NS_TEST_ASSERT_MSG_EQ (baseA->GetObject<DerivedA> (), 0, "GetObject() of unrelated type returns nonzero pointer");

  //

  // Since baseA is not a BaseA, we must not be able to ask for a DerivedA even if we

  // try an implied cast back to a BaseA.

  //

  NS_TEST_ASSERT_MSG_EQ (baseA->GetObject<BaseA> (DerivedA::GetTypeId ()), 0, "GetObject() of unrelated returns nonzero Ptr");

  baseA = CreateObject<DerivedA> ();

  NS_TEST_ASSERT_MSG_NE (baseA, 0, "Unable to CreateObject<DerivedA> with implicit cast to BaseA");

  //

  // If we create a DerivedA and cast it to a BaseA, then if we do a GetObject for

  // that BaseA we should get the same address (same Object).

  //

  NS_TEST_ASSERT_MSG_EQ (baseA->GetObject<BaseA> (), baseA, "Unable to GetObject<BaseA> on BaseA");

  //

  // Since we created a DerivedA and cast it to a BaseA, we should be able to 

  // get back a DerivedA and it should be the original Ptr.

  //

  NS_TEST_ASSERT_MSG_EQ (baseA->GetObject<DerivedA> (), baseA, "GetObject() of the original type returns different Ptr");

  // If we created a DerivedA and cast it to a BaseA, then we GetObject for the 

  // same DerivedA and cast it back to the same BaseA, we should get the same 

  // object.

  //

  NS_TEST_ASSERT_MSG_EQ (baseA->GetObject<BaseA> (DerivedA::GetTypeId ()), baseA, "GetObject returns different Ptr");

  return GetErrorStatus ();

}

// ===========================================================================

// Test case to make sure that we can aggregate Objects.

// ===========================================================================

class AggregateObjectTestCase : public TestCase

{

public:

  AggregateObjectTestCase ();

  virtual ~AggregateObjectTestCase ();

private:

  virtual bool DoRun (void);