[lmi-commits] [4830] Reimplement 'strata' (formerly 'tir') product files (VS)

[Greg Chicares]

Revision: 4830
          http://svn.sv.gnu.org/viewvc/?view=rev&root=lmi&revision=4830
Author:   chicares
Date:     2010-04-05 19:39:15 +0000 (Mon, 05 Apr 2010)
Log Message:
-----------
Reimplement 'strata' (formerly 'tir') product files (VS)

Modified Paths:
--------------
    lmi/trunk/main_wx.cpp
    lmi/trunk/my_prod.cpp
    lmi/trunk/product_data.cpp
    lmi/trunk/stratified_charges.cpp
    lmi/trunk/stratified_charges.hpp

Modified: lmi/trunk/main_wx.cpp
===================================================================
--- lmi/trunk/main_wx.cpp       2010-04-05 19:37:18 UTC (rev 4829)
+++ lmi/trunk/main_wx.cpp       2010-04-05 19:39:15 UTC (rev 4830)
@@ -371,6 +371,8 @@
         ,CLASSINFO(DatabaseView)
         );
 
+    // Apparently there's no way to edit a '.funds' file.
+
     new(wx) wxDocTemplate
         (doc_manager_
         ,"Policy"
@@ -397,10 +399,10 @@
 
     new(wx) wxDocTemplate
         (doc_manager_
-        ,"Tier"
-        ,"*.tir"
+        ,"Strata"
+        ,"*.strata"
         ,""
-        ,"tir"
+        ,"strata"
         ,"Tier document"
         ,"Tier view"
         ,CLASSINFO(TierDocument)

Modified: lmi/trunk/my_prod.cpp
===================================================================
--- lmi/trunk/my_prod.cpp       2010-04-05 19:37:18 UTC (rev 4829)
+++ lmi/trunk/my_prod.cpp       2010-04-05 19:39:15 UTC (rev 4830)
@@ -64,7 +64,7 @@
     z.DatabaseFilename               = "sample.db4";
     z.FundFilename                   = "sample.fnd";
     z.RoundingFilename               = "sample.rnd";
-    z.TierFilename                   = "sample.tir";
+    z.TierFilename                   = "sample.strata";
 
     z.CorridorFilename               = "sample";
     z.CurrCOIFilename                = "qx_cso";

Modified: lmi/trunk/product_data.cpp
===================================================================
--- lmi/trunk/product_data.cpp  2010-04-05 19:37:18 UTC (rev 4829)
+++ lmi/trunk/product_data.cpp  2010-04-05 19:39:15 UTC (rev 4830)
@@ -249,7 +249,7 @@
     z.DatabaseFilename               = "sample.db4";
     z.FundFilename                   = "sample.fnd";
     z.RoundingFilename               = "sample.rnd";
-    z.TierFilename                   = "sample.tir";
+    z.TierFilename                   = "sample.strata";
 
     z.CorridorFilename               = "sample";
     z.CurrCOIFilename                = "qx_cso";

Modified: lmi/trunk/stratified_charges.cpp
===================================================================
--- lmi/trunk/stratified_charges.cpp    2010-04-05 19:37:18 UTC (rev 4829)
+++ lmi/trunk/stratified_charges.cpp    2010-04-05 19:39:15 UTC (rev 4830)
@@ -34,7 +34,12 @@
 #include "miscellany.hpp"         // minmax<T>()
 #include "platform_dependent.hpp" // access()
 #include "stratified_algorithms.hpp"
+#include "xml_lmi.hpp"
+#include "xml_serialize.hpp"
 
+#include <boost/filesystem/convenience.hpp>
+#include <boost/static_assert.hpp>
+
 #include <algorithm>
 #include <cfloat>                 // DBL_MAX
 #include <istream>
@@ -114,70 +119,23 @@
 }
 
 //============================================================================
-void stratified_entity::read(std::istream& is)
+void stratified_entity::read(xml::element const& e)
 {
-    std::vector<double>::size_type vector_size;
-    std::vector<double>::value_type z;
+    xml_serialize::get_element(e, "values", values_);
+    xml_serialize::get_element(e, "limits", limits_);
 
-    values_.clear();
-    is >> vector_size;
-    values_.reserve(vector_size);
-    for(std::vector<double>::size_type j = 0; j < vector_size; ++j)
-        {
-        is >> z;
-        values_.push_back(z);
-        }
-    LMI_ASSERT(vector_size == values_.size());
-
-    limits_.clear();
-    is >> vector_size;
-    limits_.reserve(vector_size);
-    for(std::vector<double>::size_type j = 0; j < vector_size; ++j)
-        {
-        is >> z;
-        limits_.push_back(z);
-        }
-    LMI_ASSERT(vector_size == limits_.size());
-
     assert_validity();
 }
 
 //============================================================================
-void stratified_entity::write(std::ostream& os) const
+void stratified_entity::write(xml::element& e) const
 {
     assert_validity();
 
-    typedef std::vector<double>::const_iterator svdci;
-
-    os << values_.size() << " ";
-    for(svdci i = values_.begin(); i < values_.end(); ++i)
-        {
-        os << (*i) << " ";
-        }
-    os << '\n';
-
-    os << limits_.size() << " ";
-    for(svdci i = limits_.begin(); i < limits_.end(); ++i)
-        {
-        os << (*i) << " ";
-        }
-    os << '\n';
+    xml_serialize::set_element(e, "values", values_);
+    xml_serialize::set_element(e, "limits", limits_);
 }
 
-//============================================================================
-std::istream& operator>>(std::istream& is, stratified_entity& z)
-{
-    z.read(is);
-    return is;
-}
-
-//============================================================================
-std::ostream& operator<<(std::ostream& os, stratified_entity const& z)
-{
-    z.write(os);
-    return os;
-}
-
 // Class stratified_charges implementation.
 
 //============================================================================
@@ -459,6 +417,52 @@
 }
 
 //============================================================================
+namespace
+{
+    char const* s_stratified_nodes[] =
+        {"stratified_first"
+
+        ,"topic_premium_banded"
+        ,"curr_sepacct_load_banded_by_premium"
+        ,"guar_sepacct_load_banded_by_premium"
+
+        ,"topic_asset_tiered"
+        ,"curr_m_and_e_tiered_by_assets"
+        ,"guar_m_and_e_tiered_by_assets"
+        ,"asset_based_comp_tiered_by_assets"
+        ,"investment_mgmt_fee_tiered_by_assets"
+        ,"curr_sepacct_load_tiered_by_assets"
+        ,"guar_sepacct_load_tiered_by_assets"
+
+        ,"topic_tiered_premium_tax"
+        ,"tiered_ak_premium_tax"
+        ,"tiered_de_premium_tax"
+        ,"tiered_sd_premium_tax"
+
+        ,"stratified_last"
+        };
+
+    BOOST_STATIC_ASSERT(sizeof s_stratified_nodes / sizeof(char const*) == 1 + 
e_stratified_last);
+} // anonymous namespace
+
+namespace xml_serialize
+{
+    template<>
+    struct xml_io<stratified_entity>
+    {
+        static void to_xml(xml::element& e, stratified_entity const& t)
+        {
+            t.write(e);
+        }
+
+        static void from_xml(xml::element const& t, stratified_entity& e)
+        {
+            e.read(t);
+        }
+    };
+} // namespace xml_serialize
+
+//============================================================================
 void stratified_charges::read(std::string const& filename)
 {
     if(access(filename.c_str(), R_OK))
@@ -471,69 +475,55 @@
             ;
         }
 
-    std::ifstream is(filename.c_str());
+    xml_lmi::dom_parser parser(filename);
+    xml::element const& root = parser.root_node("tier");
 
-    is >> raw_entity(e_curr_sepacct_load_banded_by_premium  );
-    is >> raw_entity(e_guar_sepacct_load_banded_by_premium  );
-    is >> raw_entity(e_curr_m_and_e_tiered_by_assets        );
-    is >> raw_entity(e_guar_m_and_e_tiered_by_assets        );
-    is >> raw_entity(e_asset_based_comp_tiered_by_assets    );
-    is >> raw_entity(e_investment_mgmt_fee_tiered_by_assets );
-    is >> raw_entity(e_curr_sepacct_load_tiered_by_assets   );
-    is >> raw_entity(e_guar_sepacct_load_tiered_by_assets   );
-    is >> raw_entity(e_tiered_ak_premium_tax                );
-    is >> raw_entity(e_tiered_de_premium_tax                );
-    is >> raw_entity(e_tiered_sd_premium_tax                );
+#define READ(ELEMENT,ENTITY) xml_serialize::get_element(ELEMENT, 
s_stratified_nodes[ENTITY], raw_entity(ENTITY))
 
-    if(!is.good())
-        {
-        fatal_error()
-            << "Unexpected end of stratified-data file '"
-            << filename
-            << "'. Try reinstalling."
-            << LMI_FLUSH
-            ;
-        }
+    READ(root, e_curr_sepacct_load_banded_by_premium  );
+    READ(root, e_guar_sepacct_load_banded_by_premium  );
+    READ(root, e_curr_m_and_e_tiered_by_assets        );
+    READ(root, e_guar_m_and_e_tiered_by_assets        );
+    READ(root, e_asset_based_comp_tiered_by_assets    );
+    READ(root, e_investment_mgmt_fee_tiered_by_assets );
+    READ(root, e_curr_sepacct_load_tiered_by_assets   );
+    READ(root, e_guar_sepacct_load_tiered_by_assets   );
+    READ(root, e_tiered_ak_premium_tax                );
+    READ(root, e_tiered_de_premium_tax                );
+    READ(root, e_tiered_sd_premium_tax                );
 
-    std::string dummy;
-    is >> dummy;
-    if(!is.eof())
-        {
-        fatal_error()
-            << "Data past expected end of stratified-data file '"
-            << filename
-            << "'. Try reinstalling."
-            << LMI_FLUSH
-            ;
-        }
+#undef READ
 }
 
 //============================================================================
 void stratified_charges::write(std::string const& filename) const
 {
-    std::ofstream os(filename.c_str());
+    xml_lmi::xml_document document("tier");
+    xml::element& root = document.root_node();
 
-    os << raw_entity(e_curr_sepacct_load_banded_by_premium  );
-    os << raw_entity(e_guar_sepacct_load_banded_by_premium  );
-    os << raw_entity(e_curr_m_and_e_tiered_by_assets        );
-    os << raw_entity(e_guar_m_and_e_tiered_by_assets        );
-    os << raw_entity(e_asset_based_comp_tiered_by_assets    );
-    os << raw_entity(e_investment_mgmt_fee_tiered_by_assets );
-    os << raw_entity(e_curr_sepacct_load_tiered_by_assets   );
-    os << raw_entity(e_guar_sepacct_load_tiered_by_assets   );
-    os << raw_entity(e_tiered_ak_premium_tax                );
-    os << raw_entity(e_tiered_de_premium_tax                );
-    os << raw_entity(e_tiered_sd_premium_tax                );
+#define WRITE(ELEMENT,ENTITY) xml_serialize::set_element(ELEMENT, 
s_stratified_nodes[ENTITY], raw_entity(ENTITY));
 
-    if(!os.good())
-        {
-        fatal_error()
-            << "Unable to write stratified-data file '"
-            << filename
-            << "'."
-            << LMI_FLUSH
-            ;
-        }
+    WRITE(root, e_curr_sepacct_load_banded_by_premium  );
+    WRITE(root, e_guar_sepacct_load_banded_by_premium  );
+    WRITE(root, e_curr_m_and_e_tiered_by_assets        );
+    WRITE(root, e_guar_m_and_e_tiered_by_assets        );
+    WRITE(root, e_asset_based_comp_tiered_by_assets    );
+    WRITE(root, e_investment_mgmt_fee_tiered_by_assets );
+    WRITE(root, e_curr_sepacct_load_tiered_by_assets   );
+    WRITE(root, e_guar_sepacct_load_tiered_by_assets   );
+    WRITE(root, e_tiered_ak_premium_tax                );
+    WRITE(root, e_tiered_de_premium_tax                );
+    WRITE(root, e_tiered_sd_premium_tax                );
+
+#undef WRITE
+
+    // Instead of this:
+//    document.save_to_file(filename.c_str());
+    // for the nonce, explicitly change the extension, in order to
+    // force external product-file code to use the new extension.
+    fs::path path(filename, fs::native);
+    path = fs::change_extension(path, ".strata");
+    document.save(path.string());
 }
 
 //============================================================================
@@ -581,7 +571,7 @@
     foo.raw_entity(e_tiered_sd_premium_tax                
).limits_.push_back(100000.0);
     foo.raw_entity(e_tiered_sd_premium_tax                
).limits_.push_back(DBL_MAX);
 
-    foo.write(AddDataDir("sample.tir"));
+    foo.write(AddDataDir("sample.strata"));
 }
 
 /// Determine whether a double is in effect the highest representable.

Modified: lmi/trunk/stratified_charges.hpp
===================================================================
--- lmi/trunk/stratified_charges.hpp    2010-04-05 19:37:18 UTC (rev 4829)
+++ lmi/trunk/stratified_charges.hpp    2010-04-05 19:39:15 UTC (rev 4830)
@@ -29,6 +29,7 @@
 #include "mc_enum_type_enums.hpp"
 #include "obstruct_slicing.hpp"
 #include "so_attributes.hpp"
+#include "xml_lmi_fwd.hpp"
 
 #include <iosfwd>
 #include <map>
@@ -74,8 +75,8 @@
         );
     ~stratified_entity();
 
-    void read (std::istream&);
-    void write(std::ostream&) const;
+    void read (xml::element const& node);
+    void write(xml::element&) const;
 
   private:
     void assert_validity() const;