[lmi-commits] [5020] Implement two specimen derived classes

[Greg Chicares]

Revision: 5020
          http://svn.sv.gnu.org/viewvc/?view=rev&root=lmi&revision=5020
Author:   chicares
Date:     2010-07-03 15:42:31 +0000 (Sat, 03 Jul 2010)
Log Message:
-----------
Implement two specimen derived classes

Modified Paths:
--------------
    lmi/trunk/ChangeLog
    lmi/trunk/datum_sequence.cpp
    lmi/trunk/datum_sequence.hpp

Modified: lmi/trunk/ChangeLog
===================================================================
--- lmi/trunk/ChangeLog 2010-07-03 00:55:15 UTC (rev 5019)
+++ lmi/trunk/ChangeLog 2010-07-03 15:42:31 UTC (rev 5020)
@@ -26237,3 +26237,10 @@
   datum_sequence.hpp
 Implement base class for MVC input sequences.
 
+20100703T1542Z <address@hidden> [697]
+
+  datum_sequence.cpp
+  datum_sequence.hpp
+Implement two specimen derived classes. For the moment, only a dummy
+implementation of allowed_keywords() is provided.
+

Modified: lmi/trunk/datum_sequence.cpp
===================================================================
--- lmi/trunk/datum_sequence.cpp        2010-07-03 00:55:15 UTC (rev 5019)
+++ lmi/trunk/datum_sequence.cpp        2010-07-03 15:42:31 UTC (rev 5020)
@@ -144,3 +144,49 @@
     return lhs.equals(rhs);
 }
 
+// Payments.
+
+payment_sequence& payment_sequence::operator=(std::string const& s)
+{
+    datum_sequence::operator=(s);
+    return *this;
+}
+
+std::map<std::string,std::string> const payment_sequence::allowed_keywords() 
const
+{
+    static std::map<std::string,std::string> all_keywords;
+    if(all_keywords.empty())
+        {
+        all_keywords["dummy"] = "DummyValue";
+        }
+    return all_keywords;
+}
+
+bool operator==(payment_sequence const& lhs, payment_sequence const& rhs)
+{
+    return lhs.equals(rhs);
+}
+
+// Payment modes.
+
+mode_sequence& mode_sequence::operator=(std::string const& s)
+{
+    datum_sequence::operator=(s);
+    return *this;
+}
+
+std::map<std::string,std::string> const mode_sequence::allowed_keywords() const
+{
+    static std::map<std::string,std::string> all_keywords;
+    if(all_keywords.empty())
+        {
+        all_keywords["dummy"] = "DummyValue";
+        }
+    return all_keywords;
+}
+
+bool operator==(mode_sequence const& lhs, mode_sequence const& rhs)
+{
+    return lhs.equals(rhs);
+}
+

Modified: lmi/trunk/datum_sequence.hpp
===================================================================
--- lmi/trunk/datum_sequence.hpp        2010-07-03 00:55:15 UTC (rev 5019)
+++ lmi/trunk/datum_sequence.hpp        2010-07-03 15:42:31 UTC (rev 5020)
@@ -91,19 +91,75 @@
 
 bool operator==(datum_sequence const&, datum_sequence const&);
 
-template<>
-inline datum_sequence value_cast<datum_sequence,std::string>
+template<> inline datum_sequence value_cast<datum_sequence,std::string>
     (std::string const& from)
 {
     return datum_sequence(from);
 }
 
-template<>
-inline std::string value_cast<std::string,datum_sequence>
+template<> inline std::string value_cast<std::string,datum_sequence>
     (datum_sequence const& from)
 {
     return from.value();
 }
 
+class payment_sequence
+    :public datum_sequence
+    ,private boost::equality_comparable<payment_sequence,payment_sequence>
+{
+  public:
+    payment_sequence() {}
+    explicit payment_sequence(std::string const& s) : datum_sequence(s) {}
+
+    payment_sequence& operator=(std::string const&);
+
+    virtual bool numeric_values_are_allowable() const {return true;}
+    virtual bool keyword_values_are_allowable() const {return true;}
+    virtual std::map<std::string,std::string> const allowed_keywords() const;
+};
+
+bool operator==(payment_sequence const&, payment_sequence const&);
+
+template<> inline payment_sequence value_cast<payment_sequence,std::string>
+    (std::string const& from)
+{
+    return payment_sequence(from);
+}
+
+template<> inline std::string value_cast<std::string,payment_sequence>
+    (payment_sequence const& from)
+{
+    return from.value();
+}
+
+class mode_sequence
+    :public datum_sequence
+    ,private boost::equality_comparable<mode_sequence,mode_sequence>
+{
+  public:
+    mode_sequence() {}
+    explicit mode_sequence(std::string const& s) : datum_sequence(s) {}
+
+    mode_sequence& operator=(std::string const&);
+
+    virtual bool numeric_values_are_allowable() const {return false;}
+    virtual bool keyword_values_are_allowable() const {return true;}
+    virtual std::map<std::string,std::string> const allowed_keywords() const;
+};
+
+bool operator==(mode_sequence const&, mode_sequence const&);
+
+template<> inline mode_sequence value_cast<mode_sequence,std::string>
+    (std::string const& from)
+{
+    return mode_sequence(from);
+}
+
+template<> inline std::string value_cast<std::string,mode_sequence>
+    (mode_sequence const& from)
+{
+    return from.value();
+}
+
 #endif // datum_sequence_hpp