ACE/tests/Lazy_Map_Manager_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Lazy_Map_Manager_Test.cpp
   5  *
   6  *   This is a simple test of the <ACE_Map_Manager> and
   7  *   <ACE_Active_Map_Manager> that illustrates how lazy map managers
   8  *   allow the deletion of entries while iterating over the map.
   9  *
  10  *  @author Irfan Pyarali <irfan@cs.wustl.edu>
  11  */
  12 //=============================================================================
  13
  14
  15 #include "test_config.h"
  16 #include "ace/Map_Manager.h"
  17 #include "ace/Active_Map_Manager.h"
  18
  19
  20 // Simple map manager.
  21 using LAZY_MAP = ACE_Map_Manager<int, int, ACE_Null_Mutex>;
  22
  23 // Displaying the contents of a map manager.
  24
  25 void
  26 display_map (LAZY_MAP &map)
  27 {
  28   {
  29     // Simple iteration printing the entries.
  30     for (LAZY_MAP::iterator iter = map.begin ();
  31          iter != map.end ();
  32          ++iter)
  33       {
  34         LAZY_MAP::ENTRY &entry = *iter;
  35         ACE_DEBUG ((LM_DEBUG,
  36                     ACE_TEXT ("%d "),
  37                     entry.int_id_));
  38       }
  39
  40     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
  41   }
  42
  43   {
  44     // Simple reverse iteration printing the entries.
  45     for (LAZY_MAP::reverse_iterator iter = map.rbegin ();
  46          iter != map.rend ();
  47          ++iter)
  48       {
  49         LAZY_MAP::ENTRY &entry = *iter;
  50         ACE_DEBUG ((LM_DEBUG,
  51                     ACE_TEXT ("%d "),
  52                     entry.int_id_));
  53       }
  54
  55     ACE_DEBUG ((LM_DEBUG,
  56                 ACE_TEXT ("\n")));
  57   }
  58
  59   ACE_DEBUG ((LM_DEBUG,
  60               ACE_TEXT ("\n")));
  61 }
  62
  63 // Test for map manager.
  64
  65 void
  66 map_test ()
  67 {
  68   // Map of size 3.
  69   LAZY_MAP map (3);
  70   int i = 0;
  71
  72   // Insert a few entries.
  73   for (i = 0; i < 3; ++i)
  74     map.bind (i, i);
  75
  76   display_map (map);
  77
  78   // Remove middle one.
  79   map.unbind (1);
  80
  81   display_map (map);
  82
  83   // Remove the entry on one end.
  84   map.unbind (0);
  85
  86   display_map (map);
  87
  88   // Remove the entry on the other end.
  89   map.unbind (2);
  90
  91   display_map (map);
  92
  93   // If we have lazy map managers, we can delete entries while
  94   // iterating over the map.
  95
  96 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
  97
  98   // Insert a few entries.
  99   for (i = 0; i < 3; ++i)
 100     map.bind (i, i);
 101
 102   display_map (map);
 103
 104   // Remove middle one.
 105   {
 106     // Deletion while iterating.
 107     for (LAZY_MAP::iterator iter = map.begin ();
 108          iter != map.end ();
 109          ++iter)
 110     {
 111       LAZY_MAP::ENTRY &entry = *iter;
 112       if (entry.int_id_ == 1)
 113         map.unbind (1);
 114     }
 115
 116     display_map (map);
 117   }
 118
 119   // Remove the entry on one end.
 120   {
 121     // Deletion while iterating.
 122     for (LAZY_MAP::iterator iter = map.begin ();
 123          iter != map.end ();
 124          ++iter)
 125       {
 126         LAZY_MAP::ENTRY &entry = *iter;
 127         if (entry.int_id_ == 0)
 128           map.unbind (0);
 129       }
 130
 131     display_map (map);
 132   }
 133
 134   // Remove the entry on the other end.
 135   {
 136     // Deletion while iterating.
 137     for (LAZY_MAP::iterator iter = map.begin ();
 138          iter != map.end ();
 139          ++iter)
 140       {
 141         LAZY_MAP::ENTRY &entry = *iter;
 142         if (entry.int_id_ == 2)
 143           map.unbind (2);
 144       }
 145
 146     display_map (map);
 147   }
 148
 149 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 150
 151   // Insert a few entries.  This will force an increase in map size.
 152   for (i = 0; i < 4; ++i)
 153     map.bind (i, i);
 154
 155   display_map (map);
 156
 157   // Remove a few entries (in reverse order).
 158   for (i = 3; i >= 0; --i)
 159     map.unbind (i);
 160
 161   display_map (map);
 162 }
 163
 164 // Simple active map manager.
 165 using ACTIVE_MAP = ACE_Active_Map_Manager<int>;
 166
 167 // Displaying the contents of an active map manager.
 168
 169 void
 170 display_map (ACTIVE_MAP &map)
 171 {
 172   {
 173     // Simple iteration printing the entries.
 174     for (ACTIVE_MAP::iterator iter = map.begin ();
 175          iter != map.end ();
 176          ++iter)
 177       {
 178         ACTIVE_MAP::ENTRY &entry = *iter;
 179         ACE_DEBUG ((LM_DEBUG,
 180                     ACE_TEXT ("%d "),
 181                     entry.int_id_));
 182       }
 183
 184     ACE_DEBUG ((LM_DEBUG,
 185                 ACE_TEXT ("\n")));
 186   }
 187
 188   {
 189     // Simple reverse iteration printing the entries.
 190     for (ACTIVE_MAP::reverse_iterator iter = map.rbegin ();
 191          iter != map.rend ();
 192          ++iter)
 193       {
 194         ACTIVE_MAP::ENTRY &entry = *iter;
 195         ACE_DEBUG ((LM_DEBUG,
 196                     ACE_TEXT ("%d "),
 197                     entry.int_id_));
 198       }
 199
 200     ACE_DEBUG ((LM_DEBUG,
 201                 ACE_TEXT ("\n")));
 202   }
 203
 204   ACE_DEBUG ((LM_DEBUG,
 205               ACE_TEXT ("\n")));
 206 }
 207
 208 // Test for active map manager.
 209
 210 void
 211 active_map_test ()
 212 {
 213   // Map of size 3.
 214   ACTIVE_MAP map (3);
 215   ACE_Active_Map_Manager_Key keys[4];
 216   int i = 0;
 217
 218   // Insert a few entries.
 219   for (i = 0; i < 3; ++i)
 220     map.bind (i, keys[i]);
 221
 222   display_map (map);
 223
 224   // Remove middle one.
 225   map.unbind (keys[1]);
 226
 227   display_map (map);
 228
 229   // Remove the entry on one end.
 230   map.unbind (keys[0]);
 231
 232   display_map (map);
 233
 234   // Remove the entry on the other end.
 235   map.unbind (keys[2]);
 236
 237   display_map (map);
 238
 239   // If we have lazy map managers, we can delete entries while
 240   // iterating over the map.
 241
 242 #if defined (ACE_HAS_LAZY_MAP_MANAGER)
 243
 244   // Insert a few entries.
 245   for (i = 0; i < 3; ++i)
 246     map.bind (i, keys[i]);
 247
 248   display_map (map);
 249
 250   // Remove middle one.
 251   {
 252     // Deletion while iterating.
 253     for (ACTIVE_MAP::iterator iter = map.begin ();
 254          iter != map.end ();
 255          ++iter)
 256     {
 257       ACTIVE_MAP::ENTRY &entry = *iter;
 258       if (entry.int_id_ == 1)
 259         map.unbind (keys[1]);
 260     }
 261
 262     display_map (map);
 263   }
 264
 265   // Remove the entry on one end.
 266   {
 267     // Deletion while iterating.
 268     for (ACTIVE_MAP::iterator iter = map.begin ();
 269          iter != map.end ();
 270          ++iter)
 271       {
 272         ACTIVE_MAP::ENTRY &entry = *iter;
 273         if (entry.int_id_ == 0)
 274           map.unbind (keys[0]);
 275       }
 276
 277     display_map (map);
 278   }
 279
 280   // Remove the entry on the other end.
 281   {
 282     // Deletion while iterating.
 283     for (ACTIVE_MAP::iterator iter = map.begin ();
 284          iter != map.end ();
 285          ++iter)
 286       {
 287         ACTIVE_MAP::ENTRY &entry = *iter;
 288         if (entry.int_id_ == 2)
 289           map.unbind (keys[2]);
 290       }
 291
 292     display_map (map);
 293   }
 294
 295 #endif /* ACE_HAS_LAZY_MAP_MANAGER */
 296
 297   // Insert a few entries.  This will force an increase in map size.
 298   for (i = 0; i < 4; ++i)
 299     map.bind (i, keys[i]);
 300
 301   display_map (map);
 302
 303   // Remove a few entries (in reverse order).
 304   for (i = 3; i >= 0; --i)
 305     map.unbind (keys[i]);
 306
 307   display_map (map);
 308 }
 309
 310 int
 311 run_main (int, ACE_TCHAR *[])
 312 {
 313   ACE_START_TEST (ACE_TEXT ("Lazy_Map_Manager_Test"));
 314   ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE);
 315
 316   ACE_DEBUG ((LM_DEBUG,
 317               ACE_TEXT ("\nMap Manager...\n\n")));
 318   map_test ();
 319
 320   ACE_DEBUG ((LM_DEBUG,
 321               ACE_TEXT ("\nActive Map Manager...\n\n")));
 322   active_map_test ();
 323
 324   ACE_LOG_MSG->set_flags (ACE_Log_Msg::VERBOSE_LITE);
 325   ACE_END_TEST;
 326   return 0;
 327 }
 328