Rewrote the way annotated commodities are managed

The new scheme should be much more efficient, and allows for future
growth of what annotations may appear on a commodity.

1 files changed, 79 insertions, 82 deletions

diff --git a/src/pool.cc b/src/pool.cc
index 2c094d47..ca50db2c 100644
--- a/src/pool.cc
+++ b/src/pool.cc
@@ -56,7 +56,7 @@ commodity_t * commodity_pool_t::create(const string& symbol)
 {
   shared_ptr<commodity_t::base_t>
     base_commodity(new commodity_t::base_t(symbol));
-  std::auto_ptr<commodity_t> commodity(new commodity_t(this, base_commodity));
+  shared_ptr<commodity_t> commodity(new commodity_t(this, base_commodity));
 
   DEBUG("pool.commodities", "Creating base commodity " << symbol);
 
@@ -71,13 +71,23 @@ commodity_t * commodity_pool_t::create(const string& symbol)
         "Creating commodity '" << commodity->symbol() << "'");
 
   std::pair<commodities_map::iterator, bool> result
-    = commodities.insert(commodities_map::value_type(commodity->mapping_key(),
-                                                     commodity.get()));
+    = commodities.insert(commodities_map::value_type
+                         (commodity->base_symbol(), commodity));
   assert(result.second);
 
   commodity_price_history.add_commodity(*commodity.get());
 
-  return commodity.release();
+  return commodity.get();
+}
+
+commodity_t * commodity_pool_t::find(const string& symbol)
+{
+  DEBUG("pool.commodities", "Find commodity " << symbol);
+
+  commodities_map::const_iterator i = commodities.find(symbol);
+  if (i != commodities.end())
+    return (*i).second.get();
+  return NULL;
 }
 
 commodity_t * commodity_pool_t::find_or_create(const string& symbol)
@@ -88,97 +98,103 @@ commodity_t * commodity_pool_t::find_or_create(const string& symbol)
   return create(symbol);
 }
 
-commodity_t * commodity_pool_t::find(const string& symbol)
+commodity_t * commodity_pool_t::alias(const string& name, commodity_t& referent)
 {
-  DEBUG("pool.commodities", "Find commodity " << symbol);
+  commodities_map::const_iterator i = commodities.find(referent.symbol());
+  assert(i != commodities.end());
 
-  commodities_map::const_iterator i = commodities.find(symbol);
-  if (i != commodities.end())
-    return (*i).second;
-  return NULL;
+  std::pair<commodities_map::iterator, bool> result
+    = commodities.insert(commodities_map::value_type(name, (*i).second));
+  assert(result.second);
+
+  return (*result.first).second.get();
 }
 
 commodity_t *
 commodity_pool_t::create(const string& symbol, const annotation_t& details)
 {
-  commodity_t * new_comm = create(symbol);
-  if (! new_comm)
-    return NULL;
+  DEBUG("pool.commodities", "commodity_pool_t::create[ann] "
+        << "symbol " << symbol << std::endl << details);
 
   if (details)
-    return find_or_create(*new_comm, details);
+    return create(*find_or_create(symbol), details);
   else
-    return new_comm;
+    return create(symbol);
 }
 
-string commodity_pool_t::make_qualified_name(const commodity_t&  comm,
-                                             const annotation_t& details)
+commodity_t *
+commodity_pool_t::find(const string& symbol, const annotation_t& details)
 {
-  assert(details);
-
-  if (details.price && details.price->sign() < 0)
-    throw_(amount_error, _("A commodity's price may not be negative"));
+  DEBUG("pool.commodities", "commodity_pool_t::find[ann] "
+        << "symbol " << symbol << std::endl << details);
 
-  std::ostringstream name;
-  comm.print(name);
-  details.print(name, comm.pool().keep_base);
-
-#if defined(DEBUG_ON)
-  if (comm.qualified_symbol)
-    DEBUG("pool.commodities", "make_qualified_name for "
-          << *comm.qualified_symbol << std::endl << details);
-#endif
-  DEBUG("pool.commodities", "qualified_name is " << name.str());
-
-  return name.str();
+  if (details) {
+    annotated_commodities_map::const_iterator i =
+      annotated_commodities.find
+      (annotated_commodities_map::key_type(symbol, details));
+    if (i != annotated_commodities.end()) {
+      DEBUG("pool.commodities", "commodity_pool_t::find[ann] found "
+            << "symbol " << (*i).second->symbol() << std::endl
+            << as_annotated_commodity(*(*i).second.get()).details);
+      return (*i).second.get();
+    } else {
+      return NULL;
+    }
+  } else {
+    return find(symbol);
+  }
 }
 
 commodity_t *
-commodity_pool_t::find(const string& symbol, const annotation_t& details)
+commodity_pool_t::find_or_create(const string& symbol,
+                                 const annotation_t& details)
 {
-  commodity_t * comm = find(symbol);
-  if (! comm)
-    return NULL;
+  DEBUG("pool.commodities", "commodity_pool_t::find_or_create[ann] "
+        << "symbol " << symbol << std::endl << details);
 
   if (details) {
-    string name = make_qualified_name(*comm, details);
-
-    if (commodity_t * ann_comm = find(name)) {
+    if (commodity_t * ann_comm = find(symbol, details)) {
       assert(ann_comm->annotated && as_annotated_commodity(*ann_comm).details);
       return ann_comm;
+    } else {
+      return create(symbol, details);
     }
-    return NULL;
   } else {
-    return comm;
+    return find_or_create(symbol);
   }
 }
 
 commodity_t *
-commodity_pool_t::find_or_create(const string& symbol,
-                                 const annotation_t& details)
+commodity_pool_t::find_or_create(commodity_t& comm, const annotation_t& details)
 {
-  commodity_t * comm = find_or_create(symbol);
-  if (! comm)
-    return NULL;
+  DEBUG("pool.commodities", "commodity_pool_t::find_or_create[ann:comm] "
+        << "symbol " << comm.symbol() << std::endl << details);
 
-  if (details)
-    return find_or_create(*comm, details);
-  else
-    return comm;
+  if (details) {
+    if (commodity_t * ann_comm = find(comm.symbol(), details)) {
+      assert(ann_comm->annotated && as_annotated_commodity(*ann_comm).details);
+      return ann_comm;
+    } else {
+      return create(comm, details);
+    }
+  } else {
+    return &comm;
+  }
 }
 
-commodity_t *
+annotated_commodity_t *
 commodity_pool_t::create(commodity_t&        comm,
-                         const annotation_t& details,
-                         const string&       mapping_key)
+                         const annotation_t& details)
 {
+  DEBUG("pool.commodities", "commodity_pool_t::create[ann:comm] "
+        << "symbol " << comm.symbol() << std::endl << details);
+
   assert(comm);
   assert(! comm.has_annotation());
   assert(details);
-  assert(! mapping_key.empty());
 
-  unique_ptr<commodity_t> commodity
-    (new annotated_commodity_t(&comm, details));
+  shared_ptr<annotated_commodity_t>
+    commodity(new annotated_commodity_t(&comm, details));
 
   comm.add_flags(COMMODITY_SAW_ANNOTATED);
   if (details.price) {
@@ -193,34 +209,15 @@ commodity_pool_t::create(commodity_t&        comm,
 
   DEBUG("pool.commodities", "Creating annotated commodity "
         << "symbol " << commodity->symbol()
-        << " key "   << mapping_key << std::endl << details);
-
-  // Add the fully annotated name to the map, so that this symbol may
-  // quickly be found again.
-  commodity->mapping_key_ = mapping_key;
+        << std::endl << details);
 
-  std::pair<commodities_map::iterator, bool> result
-    = commodities.insert(commodities_map::value_type(mapping_key,
-                                                     commodity.get()));
+  std::pair<annotated_commodities_map::iterator, bool> result
+    = annotated_commodities.insert(annotated_commodities_map::value_type
+                                   (annotated_commodities_map::key_type
+                                    (comm.symbol(), details), commodity));
   assert(result.second);
 
-  return commodity.release();
-}
-
-commodity_t * commodity_pool_t::find_or_create(commodity_t&        comm,
-                                               const annotation_t& details)
-{
-  assert(comm);
-  assert(details);
-
-  string name = make_qualified_name(comm, details);
-  assert(! name.empty());
-
-  if (commodity_t * ann_comm = find(name)) {
-    assert(ann_comm->annotated && as_annotated_commodity(*ann_comm).details);
-    return ann_comm;
-  }
-  return create(comm, details, name);
+  return commodity.get();
 }
 
 void commodity_pool_t::exchange(commodity_t&      commodity,