--- a/src/routing/aodv/aodv-routing-protocol.cc	Mon Aug 03 14:09:24 2009 +0400
+++ b/src/routing/aodv/aodv-routing-protocol.cc	Mon Aug 03 15:07:02 2009 +0400
@@ -182,7 +182,8 @@
   TTL_START(1), TTL_INCREMENT(2), TTL_THRESHOLD(7), MAX_REPAIR_TTL(0.3* NET_DIAMETER), LOCAL_ADD_TTL(2),
   TIMEOUT_BUFFER (2),
   BLACKLIST_TIMEOUT( Scalar ( (((TTL_THRESHOLD - TTL_START)/TTL_INCREMENT) + 1 + RREQ_RETRIES) )*NET_TRAVERSAL_TIME ),
-  m_routingTable (DELETE_PERIOD),
+  MaxQueueLen (64), QueueTimeout (Seconds(30)),
+  m_routingTable (DELETE_PERIOD), m_queue (MaxQueueLen, QueueTimeout),
   m_requestId (0), m_seqNo (0), btimer (Timer::CANCEL_ON_DESTROY), htimer (Timer::CANCEL_ON_DESTROY), ntimer (Timer::CANCEL_ON_DESTROY),
   rtimer (Timer::CANCEL_ON_DESTROY), lrtimer (Timer::CANCEL_ON_DESTROY)
 

--- a/src/routing/aodv/aodv-routing-protocol.h	Mon Aug 03 14:09:24 2009 +0400
+++ b/src/routing/aodv/aodv-routing-protocol.h	Mon Aug 03 15:07:02 2009 +0400
@@ -98,7 +98,8 @@
   uint16_t LOCAL_ADD_TTL;
   uint16_t TIMEOUT_BUFFER;
   Time BLACKLIST_TIMEOUT;
-
+  uint32_t MaxQueueLen;
+  Time QueueTimeout;
   //\}
 
   /// \name Handle Broadcast sequence number cache
@@ -176,7 +177,7 @@
   /// Routing table
   RoutingTable m_routingTable;
   /// A "drop-front" queue used by the routing layer to buffer packets to which it does not have a route.
-  AodvQueue m_queue;
+  RequestQueue m_queue;
   /// Broadcast ID
   uint32_t m_requestId;
   /// Request sequence number

--- a/src/routing/aodv/aodv-rqueue.cc	Mon Aug 03 14:09:24 2009 +0400
+++ b/src/routing/aodv/aodv-rqueue.cc	Mon Aug 03 15:07:02 2009 +0400
@@ -35,49 +35,46 @@
 namespace ns3 {
 namespace aodv {
 
-AodvQueue::AodvQueue() : m_maxSize(AODV_RTQ_MAX_LEN), m_timeout(Seconds(AODV_RTQ_TIMEOUT))
-{
-}
 
 uint32_t
-AodvQueue::GetSize ()
+RequestQueue::GetSize ()
 {
   Purge();
   return m_queue.size();
 }
 
 void
-AodvQueue::Enqueue(QueueEntry & entry)
+RequestQueue::Enqueue(QueueEntry & entry)
 {
   Purge();
-  entry.m_expire = Simulator::Now() + m_timeout;
+  entry.SetExpireTime (m_queueTimeout);
 
-  if (m_queue.size() == m_maxSize) Drop(RemoveHead()); // Drop the most aged packet
+  if (m_queue.size() == m_maxLen) Drop(RemoveHead()); // Drop the most aged packet
   m_queue.push_back(entry);
 }
 
 QueueEntry
-AodvQueue::Dequeue()
+RequestQueue::Dequeue()
 {
   Purge();
   return RemoveHead();
 }
 
 void
-AodvQueue::DropPacketWithDst (Ipv4Address dst)
+RequestQueue::DropPacketWithDst (Ipv4Address dst)
 {
   Purge();
   const Ipv4Address addr = dst;
-  std::vector<QueueEntry>::iterator i = std::remove_if (m_queue.begin(), m_queue.end(), std::bind2nd(std::ptr_fun( AodvQueue::IsEqual), dst) );
+  std::vector<QueueEntry>::iterator i = std::remove_if (m_queue.begin(), m_queue.end(), std::bind2nd(std::ptr_fun( RequestQueue::IsEqual), dst) );
   m_queue.erase (i, m_queue.end());
 }
 
 bool
-AodvQueue::Dequeue(Ipv4Address dst, QueueEntry & entry)
+RequestQueue::Dequeue(Ipv4Address dst, QueueEntry & entry)
 {
   Purge();
   for(std::vector<QueueEntry>::iterator i = m_queue.begin(); i != m_queue.end(); ++i)
-    if(i->m_header.GetDestination() == dst)
+    if(i->GetIpv4Header ().GetDestination() == dst)
       {
         entry = *i;
         m_queue.erase(i);
@@ -87,16 +84,16 @@
 }
 
 bool
-AodvQueue::Find(Ipv4Address dst)
+RequestQueue::Find(Ipv4Address dst)
 {
   for( std::vector<QueueEntry>::const_iterator i = m_queue.begin(); i != m_queue.end(); ++i)
-    if(i->m_header.GetDestination() == dst)
+    if(i->GetIpv4Header ().GetDestination() == dst)
       return true;
   return false;
 }
 
 QueueEntry
-AodvQueue::RemoveHead()
+RequestQueue::RemoveHead()
 {
   QueueEntry entry = m_queue.front();
   m_queue.erase(m_queue.begin());
@@ -107,12 +104,12 @@
 {
   bool operator() (QueueEntry const & e) const
   {
-    return (e.m_expire < Simulator::Now());
+    return (e.GetExpireTime () < Seconds(0));
   }
 };
 
 void
-AodvQueue::Purge()
+RequestQueue::Purge()
 {
   std::vector<QueueEntry>::iterator i = std::remove_if(m_queue.begin(), m_queue.end(), IsExpired());
   for (std::vector<QueueEntry>::iterator j = i ; j < m_queue.end(); ++j)
@@ -121,14 +118,14 @@
 }
 
 void
-AodvQueue::Drop(QueueEntry)
+RequestQueue::Drop(QueueEntry)
 {
   // TODO do nothing now.
 }
 
 #if 0
 #ifdef RUN_SELF_TESTS
-/// Unit test for AodvQueue
+/// Unit test for RequestQueue
 struct AodvRqueueTest : public Test
 {
   AodvRqueueTest () : Test ("AODV/Rqueue"), result(true) {}
@@ -137,7 +134,7 @@
   void CheckSizeLimit ();
   void CheckTimeout ();
 
-  AodvQueue q;
+  RequestQueue q;
   bool result;
 };
 

--- a/src/routing/aodv/aodv-rqueue.h	Mon Aug 03 14:09:24 2009 +0400
+++ b/src/routing/aodv/aodv-rqueue.h	Mon Aug 03 15:07:02 2009 +0400
@@ -33,35 +33,26 @@
 #include "ns3/packet.h"
 #include <vector>
 #include "ns3/ipv4-routing-protocol.h"
+#include "ns3/simulator.h"
+
 
 namespace ns3 {
 namespace aodv {
 
-/// The maximum number of packets that we allow a routing protocol to buffer.
-#define AODV_RTQ_MAX_LEN 64
-/// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds.
-#define AODV_RTQ_TIMEOUT 30
 /**
  * \ingroup aodv
  * \brief AODV Queue Entry
  */
-struct QueueEntry
+class QueueEntry
 {
+public:
   typedef Ipv4RoutingProtocol::UnicastForwardCallback UnicastForwardCallback;
   typedef Ipv4RoutingProtocol::ErrorCallback ErrorCallback;
+  /// c-tor
+  QueueEntry(Ptr<const Packet> pa = 0, Ipv4Header const & h = Ipv4Header(),
+             UnicastForwardCallback ucb = UnicastForwardCallback(),ErrorCallback ecb = ErrorCallback(),
+             Time exp = Simulator::Now()) : m_packet(pa), m_header(h), m_ucb(ucb), m_ecb(ecb), m_expire(exp + Simulator::Next()) {}
 
-  Ptr<const Packet> m_packet;
-  Ipv4Header m_header;
-  UnicastForwardCallback m_ucb;
-  ErrorCallback m_ecb;
-  /// Expire time for queue entry
-  Time m_expire;
-  /// c-tor
-  QueueEntry(Ptr<const Packet> pa = 0, Ipv4Header const & h = Ipv4Header(), 
-             UnicastForwardCallback ucb = UnicastForwardCallback(), 
-             ErrorCallback ecb = ErrorCallback(), 
-             Time exp = Seconds(0)) 
-    : m_packet(pa), m_header(h), m_ucb(ucb), m_ecb(ecb), m_expire(exp) {}
   /**
    * Compare queue entries
    * \return true if equal
@@ -71,12 +62,23 @@
     return ((m_packet == o.m_packet)/*&& header == o.header*/ && (m_expire == o.m_expire));
   }
 
-  UnicastForwardCallback GetUnicastForwardCallback() const { return m_ucb; }
-  void SetUnicastForwardCallback(UnicastForwardCallback ucb) { m_ucb = ucb; }
-  Ptr<const Packet> GetPacket() const { return m_packet; }
-  void SetPacket(Ptr<const Packet> p) { m_packet = p; }
+  UnicastForwardCallback GetUnicastForwardCallback () const { return m_ucb; }
+  void SetUnicastForwardCallback (UnicastForwardCallback ucb) { m_ucb = ucb; }
+  ErrorCallback GetErrorCallback () const { return m_ecb; }
+  void SetErrorCallback (ErrorCallback ecb) { m_ecb = ecb; }
+  Ptr<const Packet> GetPacket () const { return m_packet; }
+  void SetPacket (Ptr<const Packet> p) { m_packet = p; }
   Ipv4Header GetIpv4Header() const { return m_header; }
-  void SetIpv4Header(Ipv4Header h) { m_header = h; }
+  void SetIpv4Header (Ipv4Header h) { m_header = h; }
+  void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now(); }
+  Time GetExpireTime () const { return m_expire - Simulator::Now(); }
+private:
+  Ptr<const Packet> m_packet;
+  Ipv4Header m_header;
+  UnicastForwardCallback m_ucb;
+  ErrorCallback m_ecb;
+  /// Expire time for queue entry
+  Time m_expire;
 };
 /**
  * \ingroup aodv
@@ -84,11 +86,11 @@
  * 
  * Since AODV is an on demand routing we queue requests while looking for route.
  */
-class AodvQueue
+class RequestQueue
 {
 public:
   /// Default c-tor
-  AodvQueue ();
+  RequestQueue (uint32_t maxLen, Time routeToQueueTimeout) : m_maxLen (maxLen), m_queueTimeout (routeToQueueTimeout) {}
   /// Push entry in queue.
   void Enqueue (QueueEntry & entry);
   /// Returns a entry from the head of the queue.
@@ -101,6 +103,13 @@
   bool Find (Ipv4Address dst);
   /// Number of entries
   uint32_t GetSize ();
+  ///\name Fields
+  //\{
+  uint32_t GetMaxQueueLen () const { return m_maxLen; }
+  void SetMaxQueueLen (uint32_t len) { m_maxLen = len; }
+  void SetQueueTimeout (Time t) { m_queueTimeout = t; }
+  Time GetQueueTimeout () const { return m_queueTimeout; }
+  //\}
 
 private:
   std::vector<QueueEntry> m_queue;
@@ -110,11 +119,11 @@
   void Purge();
   /// Notify that packet is dropped from queue by timeout
   void Drop (QueueEntry e);
-  /// Maximum number of entries in queue
-  uint32_t m_maxSize;
-  /// Life time of queue entry in queue
-  Time m_timeout;
-  static bool IsEqual(QueueEntry  en, const Ipv4Address dst) { return (en.m_header.GetDestination() == dst);}
+  /// The maximum number of packets that we allow a routing protocol to buffer.
+  uint32_t m_maxLen;
+  /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds.
+  Time m_queueTimeout;
+  static bool IsEqual(QueueEntry  en, const Ipv4Address dst) { return (en.GetIpv4Header ().GetDestination () == dst);}
 };