*         Michele Polese <michele.polese@gmail.com> for the OutdoorPositionAllocator class

#include "ns3/string.h"

#include "ns3/pointer.h"

NS_OBJECT_ENSURE_REGISTERED (OutdoorPositionAllocator);

OutdoorPositionAllocator::OutdoorPositionAllocator ()

{

  m_maxAttempts = 1000;

}

TypeId

OutdoorPositionAllocator::GetTypeId (void)

{

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

    .SetParent<PositionAllocator> ()

    .SetGroupName ("Buildings")

    .AddConstructor<OutdoorPositionAllocator> ()

    .AddAttribute ("X",

                   "A random variable which represents the x coordinate of a position in a random box.",

                   StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"),

                   MakePointerAccessor (&OutdoorPositionAllocator::m_x),

                   MakePointerChecker<RandomVariableStream> ())

    .AddAttribute ("Y",

                   "A random variable which represents the y coordinate of a position in a random box.",

                   StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"),

                   MakePointerAccessor (&OutdoorPositionAllocator::m_y),

                   MakePointerChecker<RandomVariableStream> ())

    .AddAttribute ("Z",

                   "A random variable which represents the z coordinate of a position in a random box.",

                   StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"),

                   MakePointerAccessor (&OutdoorPositionAllocator::m_z),

                   MakePointerChecker<RandomVariableStream> ())

    .AddAttribute ("MaxNumAttempts",

                   "Maximum number of attempts before giving up",

                   UintegerValue (1000),

                   MakeUintegerAccessor (&OutdoorPositionAllocator::m_maxAttempts),

                   MakeUintegerChecker<uint32_t> ())

    ;

  return tid; 

}

void

OutdoorPositionAllocator::SetX (Ptr<RandomVariableStream> x)

{

  m_x = x;

}

void

OutdoorPositionAllocator::SetY (Ptr<RandomVariableStream> y)

{

  m_y = y;

}

void

OutdoorPositionAllocator::SetZ (Ptr<RandomVariableStream> z)

{

  m_z = z;

}

Vector 

OutdoorPositionAllocator::GetNext () const

{

  NS_ASSERT_MSG (BuildingList::GetNBuildings () > 0, "no building found");

  bool outdoor = false;

  uint32_t attempts = 0;

  Vector pos = Vector(0,0,0);

  while(!outdoor && attempts < m_maxAttempts)

  {

    // get a random position

    double x = m_x->GetValue ();

    double y = m_y->GetValue ();

    double z = m_z->GetValue ();

    pos = Vector (x, y, z);

    NS_LOG_INFO("pos " << pos);

    bool inside = false;

    for (BuildingList::Iterator bit = BuildingList::Begin (); bit != BuildingList::End (); ++bit)

    {

      if((*bit)->IsInside (pos))

      {

        NS_LOG_INFO("Pos " << pos << " inside building " << (*bit)->GetBoundaries().xMin << " " << (*bit)->GetBoundaries().xMax << " "

            << (*bit)->GetBoundaries().yMin << " " << (*bit)->GetBoundaries().yMax << " "

            << (*bit)->GetBoundaries().zMin << " " << (*bit)->GetBoundaries().zMax);

        inside = true;

        break;

      }

    }

    if(inside)

    {

      NS_LOG_INFO("Inside a building, attemp " << attempts << " out of " << m_maxAttempts);

      attempts++; 

    }

    else

    {

      NS_LOG_INFO("Outdoor position found " << pos);

      outdoor = true;

    }

  }

  NS_ASSERT_MSG(attempts < m_maxAttempts, "Too many attempts, give up");

  NS_ASSERT_MSG(outdoor, "Still indoor, give up");

  return pos;

}

int64_t

OutdoorPositionAllocator::AssignStreams (int64_t stream)

{

  m_x->SetStream (stream);

  m_y->SetStream (stream + 1);

  m_z->SetStream (stream + 2);

  return 3;

}

 *         Michele Polese <michele.polese@gmail.com> for the OutdoorPositionAllocator class

 * Allocate each position outside of existing buildings

 * 

 */

class OutdoorPositionAllocator : public PositionAllocator

{

public:

  OutdoorPositionAllocator ();

  // inherited from Object

  static TypeId GetTypeId (void);

  // inherited from PositionAllocator

  virtual Vector GetNext (void) const;

  /**

   * \brief Set the random variable stream object that generates x-positions

   * \param x pointer to a RandomVariableStream object

   */

  void SetX (Ptr<RandomVariableStream> x);

  /**

   * \brief Set the random variable stream object that generates y-positions

   * \param y pointer to a RandomVariableStream object

   */

  void SetY (Ptr<RandomVariableStream> y);

  /**

   * \brief Set the random variable stream object that generates z-positions

   * \param z pointer to a RandomVariableStream object

   */

  void SetZ (Ptr<RandomVariableStream> z);

  /**

   * Assign a fixed random variable stream number to the random variables

   * used by this model.  Return the number of streams (possibly zero) that

   * have been assigned.

   *

   * \param stream first stream index to use

   * \return the number of stream indices assigned by this model

   */

  int64_t AssignStreams (int64_t stream);

private:

  Ptr<RandomVariableStream> m_x; //!< pointer to x's random variable stream

  Ptr<RandomVariableStream> m_y; //!< pointer to y's random variable stream

  Ptr<RandomVariableStream> m_z; //!< pointer to z's random variable stream

  uint32_t m_maxAttempts; //!< maximum number of attempts before giving up

};

/**