# 
# 
# patch "ChangeLog"
#  from [96ac221310f1e203ab5a8cea88f2d86c42e9904e]
#    to [c85b6390e5e221f6e9203d2dee4e35c5e94ebae8]
# 
# patch "database.cc"
#  from [52ec48ff3274d5088e47b4a9ad74d846156cb678]
#    to [8a18b697ea6dfa42979560ef2023429615fec9d6]
# 
# patch "database.hh"
#  from [9bd0680ba679954f3dd24abe2f95245458c5c321]
#    to [da379322125c5ca6f8b1ab7e95e9b39d10bdf896]
# 
# patch "database_check.cc"
#  from [3433aba6cb013e6d03f28d45f5ce87db8ddb4c3c]
#    to [cc6c8ece1194a534ba856ef17bc56ebb31b8458a]
# 
# patch "transforms.cc"
#  from [079c3479e99dda5711ca148a67c93f756641b0d1]
#    to [3ccf0649c918465fe7169c823a2fc9e912488b9a]
# 
# patch "transforms.hh"
#  from [72398b1a08314a36352c7216fff9f6e2c00f74b3]
#    to [231599114d9ce5980f63ef0acb0605d836f4c0e6]
# 
# patch "vocab.cc"
#  from [b7870ee35e2b5b4054a732e344d9cb9fbbaa22c2]
#    to [ec4c04c67d063fa7beb7b7821411f56099588d9a]
# 
# patch "vocab.hh"
#  from [9a7c6c4699b65e563bc0fb7d8e557139283bbb5b]
#    to [9bc5a9930e2e19e73317788cd7f5142d99adb60f]
# 
# patch "vocab_terms.hh"
#  from [346786c6c93907481a5c0691b3d60811827df9a3]
#    to [fa88ad4f49972bed8d1e5f02bdeb23f5031f3de0]
# 
============================================================
--- ChangeLog	96ac221310f1e203ab5a8cea88f2d86c42e9904e
+++ ChangeLog	c85b6390e5e221f6e9203d2dee4e35c5e94ebae8
@@ -1,3 +1,17 @@
+2006-05-25  Derek Scherger  <address@hidden>
+
+	* database.{cc,hh} (exists): indentation fix
+	(roster_version_exists, roster_exists_for_revision,
+	get_roster_links, get_roster_ids, delete_existing_rev_and_certs,
+	get_roster_id_for_revision, get_roster, put_roster):
+	* database_check.cc (check_rosters_manifest,
+	check_rosters_marking, check_roster_links, check_revisions,
+	report_rosters, check_db): replace hexenc<id> with roster_id
+	* transforms.{cc,hh} (calculate_ident): new roster_id variant
+	* vocab.cc (dump): new roster_id variant
+	* vocab.hh: typedef roster_id
+	* vocab_terms.hh: roster_id template instantiations
+
 2006-05-24  Derek Scherger  <address@hidden>
 
 	* cmd_merging.cc (merge_into_dir): use the_null_node rather than 0
============================================================
--- database.cc	52ec48ff3274d5088e47b4a9ad74d846156cb678
+++ database.cc	8a18b697ea6dfa42979560ef2023429615fec9d6
@@ -865,7 +865,7 @@
 
 bool 
 database::exists(hexenc<id> const & ident,
-                      string const & table)
+                 string const & table)
 {
   if (have_pending_write(table, ident))
     return true;
@@ -1373,10 +1373,10 @@
 }
 
 bool 
-database::roster_version_exists(hexenc<id> const & id)
+database::roster_version_exists(roster_id const & id)
 {
-  return delta_exists(id(), "roster_deltas") 
-    || exists(id(), "rosters");
+  return delta_exists(id.inner(), "roster_deltas") 
+    || exists(id.inner(), "rosters");
 }
 
 bool 
@@ -1404,11 +1404,11 @@
         query("SELECT roster_id FROM revision_roster WHERE rev_id = ? ")
         % text(rev_id.inner()()));
   I((res.size() == 1) || (res.size() == 0));
-  return (res.size() == 1) && roster_version_exists(hexenc<id>(res[0][0]));
+  return (res.size() == 1) && roster_version_exists(roster_id(res[0][0]));
 }
 
 void 
-database::get_roster_links(std::map<revision_id, hexenc<id> > & links)
+database::get_roster_links(std::map<revision_id, roster_id> & links)
 {
   links.clear();
   results res;
@@ -1416,7 +1416,7 @@
   for (size_t i = 0; i < res.size(); ++i)
     {
       links.insert(make_pair(revision_id(res[i][0]), 
-                             hexenc<id>(res[i][1])));
+                             roster_id(res[i][1])));
     }
 }
 
@@ -1440,7 +1440,7 @@
 }
 
 void 
-database::get_roster_ids(set< hexenc<id> > & ids) 
+database::get_roster_ids(set<roster_id> & ids) 
 {
   ids.clear();
   set< hexenc<id> > tmp;
@@ -1767,14 +1767,14 @@
           % text(rid.inner()()));
   
   // Find the associated roster and count the number of links to it
-  hexenc<id> roster_id;
+  roster_id ros_id;
   size_t link_count = 0;  
-  get_roster_id_for_revision(rid, roster_id);
+  get_roster_id_for_revision(rid, ros_id);
   {  
     results res;
     fetch(res, 2, any_rows,
           query("SELECT rev_id, roster_id FROM revision_roster "
-                "WHERE roster_id = ?") % text(roster_id()));
+                "WHERE roster_id = ?") % text(ros_id.inner()()));
     I(res.size() > 0);
     link_count = res.size();
   }
@@ -1785,7 +1785,7 @@
 
   // If that was the last link to the roster, kill the roster too.
   if (link_count == 1)
-    remove_version(roster_id, "rosters", "roster_deltas");
+    remove_version(ros_id.inner(), "rosters", "roster_deltas");
 
   guard.commit();
 }
@@ -2724,11 +2724,11 @@
 
 void
 database::get_roster_id_for_revision(revision_id const & rev_id,
-                                     hexenc<id> & roster_id)
+                                     roster_id & ros_id)
 {
   if (rev_id.inner()().empty())
     {
-      roster_id = hexenc<id>();
+      ros_id = roster_id();
       return;
     }
 
@@ -2736,7 +2736,7 @@
   query q("SELECT roster_id FROM revision_roster WHERE rev_id = ? ");  
   fetch(res, one_col, any_rows, q % text(rev_id.inner()()));
   I(res.size() == 1);
-  roster_id = hexenc<id>(res[0][0]);
+  ros_id = roster_id(res[0][0]);
 }
 
 void 
@@ -2748,13 +2748,13 @@
 }
 
 void 
-database::get_roster(hexenc<id> const & ros_id, 
+database::get_roster(roster_id const & ros_id, 
                      data & dat)
 {
   string data_table = "rosters";
   string delta_table = "roster_deltas";
 
-  get_version(ros_id, dat, data_table, delta_table);
+  get_version(ros_id.inner(), dat, data_table, delta_table);
 }
 
 
@@ -2783,7 +2783,7 @@
     }
 
   data dat;
-  hexenc<id> ident;
+  roster_id ident;
 
   get_roster_id_for_revision(rev_id, ident);
   get_roster(ident, dat);
@@ -2802,7 +2802,7 @@
   MM(rev_id);
   data old_data, new_data;
   delta reverse_delta;
-  hexenc<id> old_id, new_id;
+  roster_id old_id, new_id;
 
   if (!rcache.exists(rev_id))
     {
@@ -2825,10 +2825,10 @@
 
   execute(query("INSERT into revision_roster VALUES (?, ?)")
           % text(rev_id.inner()())
-          % text(new_id()));
+          % text(new_id.inner()()));
 
-  if (exists(new_id, data_table) 
-      || delta_exists(new_id, delta_table))
+  if (exists(new_id.inner(), data_table) 
+      || delta_exists(new_id.inner(), delta_table))
     {
       guard.commit();
       return;
@@ -2837,7 +2837,7 @@
   // Else we have a new roster the database hasn't seen yet; our task is to
   // add it, and deltify all the incoming edges (if they aren't already).
 
-  schedule_write(data_table, new_id, new_data);
+  schedule_write(data_table, new_id.inner(), new_data);
 
   std::set<revision_id> parents;
   get_revision_parents(rev_id, parents);
@@ -2851,15 +2851,15 @@
         continue;      
       revision_id old_rev = *i;
       get_roster_id_for_revision(old_rev, old_id);
-      if (exists(new_id, data_table))
+      if (exists(new_id.inner(), data_table))
         {
-          get_version(old_id, old_data, data_table, delta_table);
+          get_version(old_id.inner(), old_data, data_table, delta_table);
           diff(new_data, old_data, reverse_delta);
-          if (have_pending_write(data_table, old_id))
-            cancel_pending_write(data_table, old_id);
+          if (have_pending_write(data_table, old_id.inner()))
+            cancel_pending_write(data_table, old_id.inner());
           else
-            drop(old_id, data_table);
-          put_delta(old_id, new_id, reverse_delta, delta_table);
+            drop(old_id.inner(), data_table);
+          put_delta(old_id.inner(), new_id.inner(), reverse_delta, delta_table);
         }
     }
   guard.commit();
============================================================
--- database.hh	9bd0680ba679954f3dd24abe2f95245458c5c321
+++ database.hh	da379322125c5ca6f8b1ab7e95e9b39d10bdf896
@@ -227,15 +227,15 @@
   bool database_specified();
   
   bool file_version_exists(file_id const & id);
-  bool roster_version_exists(hexenc<id> const & id);
+  bool roster_version_exists(roster_id const & id);
   bool revision_exists(revision_id const & id);
   bool roster_link_exists_for_revision(revision_id const & id);
   bool roster_exists_for_revision(revision_id const & id);
 
-  void get_roster_links(std::map<revision_id, hexenc<id> > & links);
+  void get_roster_links(std::map<revision_id, roster_id> & links);
   void get_file_ids(std::set<file_id> & ids);
   void get_revision_ids(std::set<revision_id> & ids);
-  void get_roster_ids(std::set< hexenc<id> > & ids) ;
+  void get_roster_ids(std::set<roster_id> & ids) ;
 
 
   bool check_integrity();
@@ -396,7 +396,7 @@
 
   // roster and node_id stuff
   void get_roster_id_for_revision(revision_id const & rev_id,
-                                  hexenc<id> & roster_id);
+                                  roster_id & ros_id);
 
   void get_roster(revision_id const & rid, 
                   roster_t & roster);
@@ -405,7 +405,7 @@
                   roster_t & roster,
                   marking_map & marks);
 
-  void get_roster(hexenc<id> const & roster_id,
+  void get_roster(roster_id const & ros_id,
                   data & dat);
 
   void get_uncommon_ancestors(revision_id const & a,
============================================================
--- database_check.cc	3433aba6cb013e6d03f28d45f5ce87db8ddb4c3c
+++ database_check.cc	cc6c8ece1194a534ba856ef17bc56ebb31b8458a
@@ -153,19 +153,19 @@
 // roster, and general parsability/normalisation
 static void
 check_rosters_manifest(app_state & app,
-              std::map<hexenc<id>, checked_roster> & checked_rosters,
+              std::map<roster_id, checked_roster> & checked_rosters,
               std::map<revision_id, checked_revision> & checked_revisions,
               std::set<manifest_id> & found_manifests,
               std::map<file_id, checked_file> & checked_files)
 {
-  set< hexenc<id> > rosters;
+  set<roster_id> rosters;
 
   app.db.get_roster_ids(rosters);
   L(FL("checking %d rosters, manifest pass\n") % rosters.size());
 
   ticker ticks(_("rosters"), "r", rosters.size()/70+1);
 
-  for (set<hexenc<id> >::const_iterator i = rosters.begin();
+  for (set<roster_id>::const_iterator i = rosters.begin();
        i != rosters.end(); ++i) 
     {
 
@@ -190,7 +190,7 @@
       
       // normalisation check
       {
-        hexenc<id> norm_ident;
+        roster_id norm_ident;
         data norm_data;
         write_roster_and_marking(ros, mm, norm_data);
         calculate_ident(norm_data, norm_ident);
@@ -225,17 +225,17 @@
 // that the referenced revisions exist.
 static void
 check_rosters_marking(app_state & app,
-              std::map<hexenc<id>, checked_roster> & checked_rosters,
+              std::map<roster_id, checked_roster> & checked_rosters,
               std::map<revision_id, checked_revision> & checked_revisions)
 {
   L(FL("checking %d rosters, marking pass\n") % checked_rosters.size());
 
   ticker ticks(_("markings"), "m", checked_rosters.size()/70+1);
 
-  for (std::map<hexenc<id>, checked_roster>::const_iterator i 
+  for (std::map<roster_id, checked_roster>::const_iterator i 
        = checked_rosters.begin(); i != checked_rosters.end(); i++)
     {
-      hexenc<id> ros_id = i->first;
+      roster_id ros_id = i->first;
       L(FL("checking roster %s\n") % i->first);
       if (!i->second.parseable)
           continue;
@@ -289,27 +289,27 @@
 static void 
 check_roster_links(app_state & app, 
                    std::map<revision_id, checked_revision> & checked_revisions,
-                   std::map<hexenc<id>, checked_roster> & checked_rosters,
+                   std::map<roster_id, checked_roster> & checked_rosters,
                    size_t & unreferenced_roster_links,
                    size_t & missing_rosters)
 {
   unreferenced_roster_links = 0;
 
-  std::map<revision_id, hexenc<id> > links;
+  std::map<revision_id, roster_id> links;
   app.db.get_roster_links(links);
 
-  for (std::map<revision_id, hexenc<id> >::const_iterator i = links.begin();
+  for (std::map<revision_id, roster_id>::const_iterator i = links.begin();
        i != links.end(); ++i)
     {
       revision_id rev(i->first);
-      hexenc<id> ros(i->second);
+      roster_id ros(i->second);
 
       std::map<revision_id, checked_revision>::const_iterator j 
         = checked_revisions.find(rev);
       if (j == checked_revisions.end() || (!j->second.found))
         ++unreferenced_roster_links;
 
-      std::map<hexenc<id>, checked_roster>::const_iterator k 
+      std::map<roster_id, checked_roster>::const_iterator k 
         = checked_rosters.find(ros);
       if (k == checked_rosters.end() || (!k->second.found))
         ++missing_rosters;
@@ -320,7 +320,7 @@
 static void
 check_revisions(app_state & app, 
                 std::map<revision_id, checked_revision> & checked_revisions,
-                std::map<hexenc<id>, checked_roster> & checked_rosters,
+                std::map<roster_id, checked_roster> & checked_rosters,
                 std::set<manifest_id> const & found_manifests)
 {
   std::set<revision_id> revisions;
@@ -362,17 +362,17 @@
       // roster checks
       if (app.db.roster_link_exists_for_revision(*i))
         {
-          hexenc<id> roster_id;
+          roster_id ros_id;
           checked_revisions[*i].found_roster_link = true;
-          app.db.get_roster_id_for_revision(*i, roster_id);
+          app.db.get_roster_id_for_revision(*i, ros_id);
           if (app.db.roster_exists_for_revision(*i))
             {
               checked_revisions[*i].found_roster = true;
-              I(checked_rosters[roster_id].found);
-              checked_rosters[roster_id].revision_refs++;
-              if (!(rev.new_manifest == checked_rosters[roster_id].man_id))
+              I(checked_rosters[ros_id].found);
+              checked_rosters[ros_id].revision_refs++;
+              if (!(rev.new_manifest == checked_rosters[ros_id].man_id))
                 checked_revisions[*i].manifest_mismatch = true;
-              if (checked_rosters[roster_id].missing_files > 0)
+              if (checked_rosters[ros_id].missing_files > 0)
                 checked_revisions[*i].incomplete_roster = true;
             }
         }
@@ -537,13 +537,13 @@
 }
 
 static void
-report_rosters(std::map<hexenc<id>, checked_roster> const & checked_rosters, 
+report_rosters(std::map<roster_id, checked_roster> const & checked_rosters, 
                  size_t & unreferenced_rosters,
                  size_t & incomplete_rosters,
                  size_t & non_parseable_rosters,
                  size_t & non_normalized_rosters)
 {
-  for (std::map<hexenc<id>, checked_roster>::const_iterator 
+  for (std::map<roster_id, checked_roster>::const_iterator 
          i = checked_rosters.begin(); i != checked_rosters.end(); ++i)
     {
       checked_roster roster = i->second;
@@ -788,7 +788,7 @@
 {
   std::map<file_id, checked_file> checked_files;
   std::set<manifest_id> found_manifests;
-  std::map<hexenc<id>, checked_roster> checked_rosters;
+  std::map<roster_id, checked_roster> checked_rosters;
   std::map<revision_id, checked_revision> checked_revisions;
   std::map<rsa_keypair_id, checked_key> checked_keys;
 
============================================================
--- transforms.cc	079c3479e99dda5711ca148a67c93f756641b0d1
+++ transforms.cc	3ccf0649c918465fe7169c823a2fc9e912488b9a
@@ -235,14 +235,24 @@
   ident = tmp;
 }
 
-void calculate_ident(revision_data const & dat,
-                     revision_id & ident)
+void
+calculate_ident(revision_data const & dat,
+                revision_id & ident)
 {
   hexenc<id> tmp;
   calculate_ident(dat.inner(), tmp);
   ident = tmp;
 }
 
+void
+calculate_ident(data const & dat,
+                roster_id & ident)
+{
+  hexenc<id> tmp;
+  calculate_ident(dat, tmp);
+  ident = tmp;
+}
+
 string 
 canonical_base64(string const & s)
 {
============================================================
--- transforms.hh	72398b1a08314a36352c7216fff9f6e2c00f74b3
+++ transforms.hh	231599114d9ce5980f63ef0acb0605d836f4c0e6
@@ -119,6 +119,9 @@
 void calculate_ident(revision_data const & dat,
                      revision_id & ident);
 
+void calculate_ident(data const & dat,
+                     roster_id & ident);
+
 // canonicalize base64 encoding
 std::string canonical_base64(std::string const & s);
 
============================================================
--- vocab.cc	b7870ee35e2b5b4054a732e344d9cb9fbbaa22c2
+++ vocab.cc	ec4c04c67d063fa7beb7b7821411f56099588d9a
@@ -208,6 +208,9 @@
 void dump(revision_id const & r, std::string &);
 
 template
+void dump(roster_id const & r, std::string &);
+
+template
 void dump(manifest_id const & r, std::string &);
 
 template
============================================================
--- vocab.hh	9a7c6c4699b65e563bc0fb7d8e557139283bbb5b
+++ vocab.hh	9bc5a9930e2e19e73317788cd7f5142d99adb60f
@@ -74,6 +74,7 @@
 // about the stuff in vocab_terms.hh
 
 typedef revision< hexenc<id> >  revision_id;
+typedef   roster< hexenc<id> >    roster_id;
 typedef manifest< hexenc<id> >  manifest_id;
 typedef     file< hexenc<id> >      file_id;
 typedef      key< hexenc<id> >       key_id;
============================================================
--- vocab_terms.hh	346786c6c93907481a5c0691b3d60811827df9a3
+++ vocab_terms.hh	fa88ad4f49972bed8d1e5f02bdeb23f5031f3de0
@@ -43,6 +43,7 @@
 ATOMIC_NOVERIFY(attr_value);
 
 DECORATE(revision);           // thing associated with a revision
+DECORATE(roster);             // thing associated with a roster
 DECORATE(manifest);           // thing associated with a manifest
 DECORATE(file);               // thing associated with a file
 DECORATE(key);                // thing associated with a key
@@ -60,6 +61,7 @@
 
 EXTERN template class           hexenc<id>;
 EXTERN template class revision< hexenc<id> >;
+EXTERN template class   roster< hexenc<id> >;
 EXTERN template class manifest< hexenc<id> >;
 EXTERN template class     file< hexenc<id> >;
 EXTERN template class      key< hexenc<id> >;
@@ -103,6 +105,7 @@
 
 EXTERN template std::ostream & operator<< <>(std::ostream &,           hexenc<id>   const &);
 EXTERN template std::ostream & operator<< <>(std::ostream &, revision< hexenc<id> > const &);
+EXTERN template std::ostream & operator<< <>(std::ostream &,   roster< hexenc<id> > const &);
 EXTERN template std::ostream & operator<< <>(std::ostream &, manifest< hexenc<id> > const &);
 EXTERN template std::ostream & operator<< <>(std::ostream &,     file< hexenc<id> > const &);
 EXTERN template std::ostream & operator<< <>(std::ostream &,    epoch< hexenc<id> > const &);