#
#
# patch "restrictions.cc"
#  from [2fcb9351d2b307fb087a27844e216be2c45df2bc]
#    to [0ab22cab0d432eb6e2cff34db3db6bac7a1ff6ab]
#
============================================================
--- restrictions.cc	2fcb9351d2b307fb087a27844e216be2c45df2bc
+++ restrictions.cc	0ab22cab0d432eb6e2cff34db3db6bac7a1ff6ab
@@ -28,6 +28,14 @@ using std::vector;
 // old roster. at this point log should stop because no earlier roster will
 // include these nodes.
 
+typedef map<node_id, restricted_path::status>::const_iterator
+        node_status_iterator;
+
+typedef map<file_path, restricted_path::status>::const_iterator
+        path_status_iterator;
+
+typedef set<file_path>::const_iterator path_iterator;
+
 static void
 map_nodes(map<node_id, restricted_path::status> & node_map,
           roster_t const & roster,
@@ -35,15 +43,14 @@ map_nodes(map<node_id, restricted_path::
           set<file_path> & known_paths,
           restricted_path::status const status)
 {
-  for (set<file_path>::const_iterator i = paths.begin(); i != paths.end(); ++i)
+  for (path_iterator i = paths.begin(); i != paths.end(); ++i)
     {
       if (roster.has_node(*i))
         {
           known_paths.insert(*i);
           node_id nid = roster.get_node(*i)->self;
 
-          map<node_id, restricted_path::status>::iterator n
-            = node_map.find(nid);
+          node_status_iterator n = node_map.find(nid);
           if (n != node_map.end())
             E(n->second == status, origin::user,
               F("conflicting include/exclude on path '%s'") % *i);
@@ -71,9 +78,9 @@ map_paths(map<file_path, restricted_path
           set<file_path> const & paths,
           restricted_path::status const status)
 {
-  for (set<file_path>::const_iterator i = paths.begin(); i != paths.end(); ++i)
+  for (path_iterator i = paths.begin(); i != paths.end(); ++i)
     {
-      map<file_path, restricted_path::status>::iterator p = path_map.find(*i);
+      path_status_iterator p = path_map.find(*i);
       if (p != path_map.end())
         E(p->second == status, origin::user,
           F("conflicting include/exclude on path '%s'") % *i);
@@ -123,16 +130,14 @@ validate_paths(set<file_path> const & in
 {
   int bad = 0;
 
-  for (set<file_path>::const_iterator i = included_paths.begin();
-       i != included_paths.end(); ++i)
+  for (path_iterator i = included_paths.begin(); i != included_paths.end(); ++i)
     if (is_unknown(*i))
       {
         bad++;
         W(F("restriction includes unknown path '%s'") % *i);
       }
 
-  for (set<file_path>::const_iterator i = excluded_paths.begin();
-       i != excluded_paths.end(); ++i)
+  for (path_iterator i = excluded_paths.begin(); i != excluded_paths.end(); ++i)
     if (is_unknown(*i))
       {
         bad++;
@@ -143,16 +148,16 @@ validate_paths(set<file_path> const & in
     FP("%d unknown path", "%d unknown paths", bad) % bad);
 }
 
-restriction::restriction(std::vector<file_path> const & includes,
-                         std::vector<file_path> const & excludes,
+restriction::restriction(vector<file_path> const & includes,
+                         vector<file_path> const & excludes,
                          long depth)
   : included_paths(includes.begin(), includes.end()),
     excluded_paths(excludes.begin(), excludes.end()),
     depth(depth)
 {}
 
-node_restriction::node_restriction(std::vector<file_path> const & includes,
-                                   std::vector<file_path> const & excludes,
+node_restriction::node_restriction(vector<file_path> const & includes,
+                                   vector<file_path> const & excludes,
                                    long depth,
                                    roster_t const & roster,
                                    path_predicate<file_path> const & ignore)
@@ -163,8 +168,8 @@ node_restriction::node_restriction(std::
                  unknown_unignored_node(known_paths, ignore));
 }
 
-node_restriction::node_restriction(std::vector<file_path> const & includes,
-                                   std::vector<file_path> const & excludes,
+node_restriction::node_restriction(vector<file_path> const & includes,
+                                   vector<file_path> const & excludes,
                                    long depth,
                                    roster_t const & roster1,
                                    roster_t const & roster2,
@@ -178,8 +183,8 @@ node_restriction::node_restriction(std::
                  unknown_unignored_node(known_paths, ignore));
 }
 
-node_restriction::node_restriction(std::vector<file_path> const & includes,
-                                   std::vector<file_path> const & excludes,
+node_restriction::node_restriction(vector<file_path> const & includes,
+                                   vector<file_path> const & excludes,
                                    long depth,
                                    parent_map const & rosters1,
                                    roster_t const & roster2,
@@ -195,8 +200,8 @@ node_restriction::node_restriction(std::
                  unknown_unignored_node(known_paths, ignore));
 }
 
-path_restriction::path_restriction(std::vector<file_path> const & includes,
-                                   std::vector<file_path> const & excludes,
+path_restriction::path_restriction(vector<file_path> const & includes,
+                                   vector<file_path> const & excludes,
                                    long depth,
                                    path_predicate<file_path> const & ignore)
   : restriction(includes, excludes, depth)
@@ -208,8 +213,8 @@ path_restriction::path_restriction(std::
                  unknown_unignored_path(ignore));
 }
 
-path_restriction::path_restriction(std::vector<file_path> const & includes,
-                                   std::vector<file_path> const & excludes,
+path_restriction::path_restriction(vector<file_path> const & includes,
+                                   vector<file_path> const & excludes,
                                    long depth,
                                    path_restriction::skip_check_t)
   : restriction(includes, excludes, depth)
@@ -256,8 +261,7 @@ node_restriction::includes(roster_t cons
 
   while (!null_node(current) && (depth == -1 || path_depth <= depth))
     {
-      map<node_id, restricted_path::status>::const_iterator
-        r = node_map.find(current);
+      node_status_iterator r = node_map.find(current);
 
       if (r != node_map.end())
         {
@@ -324,8 +328,7 @@ path_restriction::includes(file_path con
   file_path fp = pth;
   while (depth == -1 || path_depth <= depth)
     {
-      map<file_path, restricted_path::status>::const_iterator
-        r = path_map.find(fp);
+      path_status_iterator r = path_map.find(fp);
 
       if (r != path_map.end())
         {