[lmi-commits] [lmi] master fe84a276 2/4: Rename class datum_sequence --> sequence_base

[Greg Chicares]

branch: master
commit fe84a276580130783070952989359823077c5b68
Author: Gregory W. Chicares <gchicares@sbcglobal.net>
Commit: Gregory W. Chicares <gchicares@sbcglobal.net>

    Rename class datum_sequence --> sequence_base
    
    It's desirable to emphasize that this is an abstract base class. Adding
    '_base' to the original name would produce "datum_sequence_base", which
    is excessively long; it would preserve consistency with the name of the
    file, but that's less important than the other concerns.
---
 census_view.cpp          |  2 +-
 datum_sequence.cpp       | 36 ++++++++++++++++-----------------
 datum_sequence.hpp       | 52 ++++++++++++++++++++++++------------------------
 gpt_input.cpp            |  2 +-
 input.hpp                | 10 +++++-----
 input_realization.cpp    |  6 +++---
 input_sequence_entry.cpp |  2 +-
 mec_input.cpp            |  2 +-
 8 files changed, 56 insertions(+), 56 deletions(-)

diff --git a/census_view.cpp b/census_view.cpp
index 4259bada..66635eab 100644
--- a/census_view.cpp
+++ b/census_view.cpp
@@ -516,7 +516,7 @@ table_type_converter::get(any_member<Input> const& value)
         {
         return get_impl<table_string_converter>();
         }
-    else if(is_reconstitutable_as<datum_sequence>(value))
+    else if(is_reconstitutable_as<sequence_base>(value))
         {
         return get_impl<table_sequence_converter>();
         }
diff --git a/datum_sequence.cpp b/datum_sequence.cpp
index cd469978..76506b52 100644
--- a/datum_sequence.cpp
+++ b/datum_sequence.cpp
@@ -29,7 +29,7 @@
 ///
 /// Throws if insane.
 
-datum_sequence::datum_sequence()
+sequence_base::sequence_base()
     :keyword_values_are_blocked_ {false}
 {
     assert_sanity();
@@ -39,14 +39,14 @@ datum_sequence::datum_sequence()
 ///
 /// Throws if insane.
 
-datum_sequence::datum_sequence(std::string const& s)
+sequence_base::sequence_base(std::string const& s)
     :datum_string                {s}
     ,keyword_values_are_blocked_ {false}
 {
     assert_sanity();
 }
 
-datum_sequence& datum_sequence::operator=(std::string const& s)
+sequence_base& sequence_base::operator=(std::string const& s)
 {
     datum_string::operator=(s);
     return *this;
@@ -58,7 +58,7 @@ datum_sequence& datum_sequence::operator=(std::string const& 
s)
 ///
 /// Throws if insane.
 
-void datum_sequence::block_keyword_values(bool z)
+void sequence_base::block_keyword_values(bool z)
 {
     keyword_values_are_blocked_ = z;
     assert_sanity();
@@ -66,7 +66,7 @@ void datum_sequence::block_keyword_values(bool z)
 
 /// Declare whether numeric values are allowable.
 
-bool datum_sequence::numeric_values_are_allowable() const
+bool sequence_base::numeric_values_are_allowable() const
 {
     return true;
 }
@@ -75,7 +75,7 @@ bool datum_sequence::numeric_values_are_allowable() const
 ///
 /// Even if they are allowable, they may be blocked.
 
-bool datum_sequence::keyword_values_are_allowable() const
+bool sequence_base::keyword_values_are_allowable() const
 {
     return false;
 }
@@ -84,7 +84,7 @@ bool datum_sequence::keyword_values_are_allowable() const
 ///
 /// Return empty string if there's no default keyword.
 
-std::string const datum_sequence::default_keyword() const
+std::string const sequence_base::default_keyword() const
 {
     return std::string();
 }
@@ -104,7 +104,7 @@ std::string const datum_sequence::default_keyword() const
 /// map makes it possible to change internal names without affecting
 /// the user interface.
 
-std::map<std::string,std::string> const datum_sequence::allowed_keywords() 
const
+std::map<std::string,std::string> const sequence_base::allowed_keywords() const
 {
     return std::map<std::string,std::string>();
 }
@@ -117,7 +117,7 @@ std::map<std::string,std::string> const 
datum_sequence::allowed_keywords() const
 /// datum, but maintaining strong encapsulation reduces the temptation
 /// for one component of MVC to inspect another's internals.
 
-bool datum_sequence::equals(datum_sequence const& z) const
+bool sequence_base::equals(sequence_base const& z) const
 {
     return
            z.value()                     == value()
@@ -133,7 +133,7 @@ bool datum_sequence::equals(datum_sequence const& z) const
 /// datum, but maintaining strong encapsulation reduces the temptation
 /// for one component of MVC to inspect another's internals.
 
-bool datum_sequence::keyword_values_are_blocked() const
+bool sequence_base::keyword_values_are_blocked() const
 {
     return keyword_values_are_blocked_;
 }
@@ -147,7 +147,7 @@ bool datum_sequence::keyword_values_are_blocked() const
 /// allowed_keywords() to return a non-empty map; that can be
 /// considered as experience emerges with derived classes.
 
-void datum_sequence::assert_sanity() const
+void sequence_base::assert_sanity() const
 {
     LMI_ASSERT
         (  (keyword_values_are_allowable() && !keyword_values_are_blocked_)
@@ -155,7 +155,7 @@ void datum_sequence::assert_sanity() const
         );
 }
 
-bool operator==(datum_sequence const& lhs, datum_sequence const& rhs)
+bool operator==(sequence_base const& lhs, sequence_base const& rhs)
 {
     return lhs.equals(rhs);
 }
@@ -164,13 +164,13 @@ bool operator==(datum_sequence const& lhs, datum_sequence 
const& rhs)
 
 numeric_sequence& numeric_sequence::operator=(std::string const& s)
 {
-    datum_sequence::operator=(s);
+    sequence_base::operator=(s);
     return *this;
 }
 
 std::map<std::string,std::string> const numeric_sequence::allowed_keywords() 
const
 {
-    return datum_sequence::allowed_keywords();
+    return sequence_base::allowed_keywords();
 }
 
 bool operator==(numeric_sequence const& lhs, numeric_sequence const& rhs)
@@ -182,7 +182,7 @@ bool operator==(numeric_sequence const& lhs, 
numeric_sequence const& rhs)
 
 payment_sequence& payment_sequence::operator=(std::string const& s)
 {
-    datum_sequence::operator=(s);
+    sequence_base::operator=(s);
     return *this;
 }
 
@@ -218,7 +218,7 @@ bool operator==(payment_sequence const& lhs, 
payment_sequence const& rhs)
 
 mode_sequence& mode_sequence::operator=(std::string const& s)
 {
-    datum_sequence::operator=(s);
+    sequence_base::operator=(s);
     return *this;
 }
 
@@ -251,7 +251,7 @@ bool operator==(mode_sequence const& lhs, mode_sequence 
const& rhs)
 
 specamt_sequence& specamt_sequence::operator=(std::string const& s)
 {
-    datum_sequence::operator=(s);
+    sequence_base::operator=(s);
     return *this;
 }
 
@@ -292,7 +292,7 @@ bool operator==(specamt_sequence const& lhs, 
specamt_sequence const& rhs)
 
 dbo_sequence& dbo_sequence::operator=(std::string const& s)
 {
-    datum_sequence::operator=(s);
+    sequence_base::operator=(s);
     return *this;
 }
 
diff --git a/datum_sequence.hpp b/datum_sequence.hpp
index 9f8b8cfc..ccc0030c 100644
--- a/datum_sequence.hpp
+++ b/datum_sequence.hpp
@@ -55,11 +55,11 @@
 /// Still others permit both numbers and keywords. Specified amount,
 /// e.g., must accommodate numeric entry.
 
-class datum_sequence
+class sequence_base
     :public datum_string
 {
   public:
-    bool equals(datum_sequence const&) const;
+    bool equals(sequence_base const&) const;
 
     virtual bool numeric_values_are_allowable() const;
     virtual bool keyword_values_are_allowable() const;
@@ -67,16 +67,16 @@ class datum_sequence
     virtual std::map<std::string,std::string> const allowed_keywords() const;
 
   protected:
-    datum_sequence();
-    explicit datum_sequence(std::string const&);
+    sequence_base();
+    explicit sequence_base(std::string const&);
 
-    datum_sequence(datum_sequence const&) = default;
-    datum_sequence(datum_sequence&&) = default;
-    datum_sequence& operator=(datum_sequence const&) = default;
-    datum_sequence& operator=(datum_sequence&&) = default;
-    ~datum_sequence() override = 0;
+    sequence_base(sequence_base const&) = default;
+    sequence_base(sequence_base&&) = default;
+    sequence_base& operator=(sequence_base const&) = default;
+    sequence_base& operator=(sequence_base&&) = default;
+    ~sequence_base() override = 0;
 
-    datum_sequence& operator=(std::string const&);
+    sequence_base& operator=(std::string const&);
 
     void block_keyword_values(bool);
 
@@ -88,20 +88,20 @@ class datum_sequence
     bool keyword_values_are_blocked_;
 };
 
-inline datum_sequence::~datum_sequence() = default;
+inline sequence_base::~sequence_base() = default;
 
-bool operator==(datum_sequence const&, datum_sequence const&);
+bool operator==(sequence_base const&, sequence_base const&);
 
 // Specialize value_cast<> for each derived class, e.g., as follows:
 //
-// template<> inline datum_sequence value_cast<datum_sequence,std::string>
+// template<> inline leaf_class value_cast<leaf_class,std::string>
 //     (std::string const& from)
 // {
-//     return datum_sequence(from);
+//     return leaf_class(from);
 // }
 //
-// template<> inline std::string value_cast<std::string,datum_sequence>
-//     (datum_sequence const& from)
+// template<> inline std::string value_cast<std::string,leaf_class>
+//     (leaf_class const& from)
 // {
 //     return from.value();
 // }
@@ -109,11 +109,11 @@ bool operator==(datum_sequence const&, datum_sequence 
const&);
 /// Numeric MVC input sequence.
 
 class numeric_sequence final
-    :public datum_sequence
+    :public sequence_base
 {
   public:
     numeric_sequence() = default;
-    explicit numeric_sequence(std::string const& s) : datum_sequence(s) {}
+    explicit numeric_sequence(std::string const& s) : sequence_base(s) {}
 
     numeric_sequence& operator=(std::string const&);
 
@@ -139,11 +139,11 @@ template<> inline std::string 
value_cast<std::string,numeric_sequence>
 /// MVC input sequence for payments.
 
 class payment_sequence final
-    :public datum_sequence
+    :public sequence_base
 {
   public:
     payment_sequence() = default;
-    explicit payment_sequence(std::string const& s) : datum_sequence(s) {}
+    explicit payment_sequence(std::string const& s) : sequence_base(s) {}
 
     payment_sequence& operator=(std::string const&);
 
@@ -169,11 +169,11 @@ template<> inline std::string 
value_cast<std::string,payment_sequence>
 /// MVC input sequence for payment mode.
 
 class mode_sequence final
-    :public datum_sequence
+    :public sequence_base
 {
   public:
     mode_sequence() = default;
-    explicit mode_sequence(std::string const& s) : datum_sequence(s) {}
+    explicit mode_sequence(std::string const& s) : sequence_base(s) {}
 
     mode_sequence& operator=(std::string const&);
 
@@ -200,11 +200,11 @@ template<> inline std::string 
value_cast<std::string,mode_sequence>
 /// MVC input sequence for specified amount.
 
 class specamt_sequence final
-    :public datum_sequence
+    :public sequence_base
 {
   public:
     specamt_sequence() = default;
-    explicit specamt_sequence(std::string const& s) : datum_sequence(s) {}
+    explicit specamt_sequence(std::string const& s) : sequence_base(s) {}
 
     specamt_sequence& operator=(std::string const&);
 
@@ -230,11 +230,11 @@ template<> inline std::string 
value_cast<std::string,specamt_sequence>
 /// MVC input sequence for death benefit option.
 
 class dbo_sequence final
-    :public datum_sequence
+    :public sequence_base
 {
   public:
     dbo_sequence() = default;
-    explicit dbo_sequence(std::string const& s) : datum_sequence(s) {}
+    explicit dbo_sequence(std::string const& s) : sequence_base(s) {}
 
     dbo_sequence& operator=(std::string const&);
 
diff --git a/gpt_input.cpp b/gpt_input.cpp
index 2b697e40..e2946a95 100644
--- a/gpt_input.cpp
+++ b/gpt_input.cpp
@@ -49,7 +49,7 @@ template<typename T>
 std::string realize_sequence_string
     (gpt_input           & input
     ,std::vector<T>      & v
-    ,datum_sequence const& sequence_string
+    ,sequence_base  const& sequence_string
     )
 {
     try
diff --git a/input.hpp b/input.hpp
index 2c0e6aaa..3cf9b94a 100644
--- a/input.hpp
+++ b/input.hpp
@@ -468,9 +468,9 @@ class LMI_SO Input final
 /// Specialization of struct template reconstitutor for this Model
 /// and the base class that all its input sequences share.
 
-template<> struct reconstitutor<datum_sequence,Input>
+template<> struct reconstitutor<sequence_base,Input>
 {
-    typedef datum_sequence DesiredType;
+    typedef sequence_base DesiredType;
     static DesiredType* reconstitute(any_member<Input>& m)
         {
         DesiredType* z = nullptr;
@@ -561,9 +561,9 @@ template<> struct reconstitutor<datum_base,Input>
         {
         DesiredType* z = nullptr;
         z = exact_cast<datum_string            >(m); if(z) return z;
-        z = reconstitutor<datum_sequence,Input>::reconstitute(m); if(z) return 
z;
-        z = reconstitutor<mc_enum_base  ,Input>::reconstitute(m); if(z) return 
z;
-        z = reconstitutor<tn_range_base ,Input>::reconstitute(m); if(z) return 
z;
+        z = reconstitutor<sequence_base,Input>::reconstitute(m); if(z) return 
z;
+        z = reconstitutor<mc_enum_base ,Input>::reconstitute(m); if(z) return 
z;
+        z = reconstitutor<tn_range_base,Input>::reconstitute(m); if(z) return 
z;
         return z;
         }
 };
diff --git a/input_realization.cpp b/input_realization.cpp
index e1c451e8..29daa1f8 100644
--- a/input_realization.cpp
+++ b/input_realization.cpp
@@ -51,7 +51,7 @@ template<typename T>
 std::string realize_sequence_string
     (Input          const& input
     ,std::vector<T>      & v
-    ,datum_sequence const& sequence_string
+    ,sequence_base  const& sequence_string
     )
 {
     try
@@ -80,7 +80,7 @@ template<typename T>
 std::string realize_sequence_string
     (Input             const& input
     ,std::vector<T>         & v
-    ,datum_sequence    const& sequence_string
+    ,sequence_base     const& sequence_string
     ,detail::stringmap const& keyword_dictionary
     ,std::string       const& default_keyword
     )
@@ -119,7 +119,7 @@ std::string realize_sequence_string
     (Input               const& input
     ,std::vector<Numeric>     & vn
     ,std::vector<Enumerative> & ve
-    ,datum_sequence      const& sequence_string
+    ,sequence_base       const& sequence_string
     ,detail::stringmap   const& keyword_dictionary
     ,std::string         const& default_keyword
     )
diff --git a/input_sequence_entry.cpp b/input_sequence_entry.cpp
index 165ccec9..2a98498b 100644
--- a/input_sequence_entry.cpp
+++ b/input_sequence_entry.cpp
@@ -1581,7 +1581,7 @@ void InputSequenceEntry::DoOpenEditor()
     InputSequenceEditor editor(button_, title_, in);
 
     std::string sequence_string = text_->GetValue().ToStdString(wxConvUTF8);
-    datum_sequence const& ds = *member_cast<datum_sequence>(in[field_name()]);
+    sequence_base const& ds = *member_cast<sequence_base>(in[field_name()]);
 
     std::map<std::string,std::string> const kwmap = ds.allowed_keywords();
     std::vector<std::string> const keywords =
diff --git a/mec_input.cpp b/mec_input.cpp
index 0f0b32c1..d3bbf6c0 100644
--- a/mec_input.cpp
+++ b/mec_input.cpp
@@ -49,7 +49,7 @@ template<typename T>
 std::string realize_sequence_string
     (mec_input           & input
     ,std::vector<T>      & v
-    ,datum_sequence const& sequence_string
+    ,sequence_base  const& sequence_string
     )
 {
     try