Added specialization of str2x for doubles.

[stg.git] / include / stg / resetable.h

diff --git a/include/stg/resetable.h b/include/stg/resetable.h
index d31bffda739146d324b865c468fdee714f99d7ce..a451b357326cd946c72b77ddf7b4bd57c65b1a36 100644 (file)
--- a/include/stg/resetable.h
+++ b/include/stg/resetable.h
@@ -1,9 +1,3 @@
- /*
- $Revision: 1.9 $
- $Date: 2010/03/11 14:42:04 $
- $Author: faust $
- */
-

 /*
  * Copyright (c) 2001 by Peter Simons <simons@cryp.to>.
  * All rights reserved.
 /*
  * Copyright (c) 2001 by Peter Simons <simons@cryp.to>.
  * All rights reserved.


@@ -15,84 +9,56 @@
 // This is a wrapper class about variables where you want to keep
 // track of whether it has been assigened yet or not.
 
 // This is a wrapper class about variables where you want to keep
 // track of whether it has been assigened yet or not.
 

-#include <iostream>
-
-template <typename varT>
+template <typename T>

 class RESETABLE
 {
 class RESETABLE
 {

-    template <typename varT1>
-    friend std::ostream & operator<<(std::ostream & o, RESETABLE<varT1> v);

 public:
 public:

-    typedef varT value_type;
+    typedef T value_type;

 
 

-    //-------------------------------------------------------------------------
-    RESETABLE()
-        : value(),
-          is_set(false)
-    {
-    }
-    //-------------------------------------------------------------------------
-    RESETABLE<value_type>(const RESETABLE<value_type> & rvalue)
+    RESETABLE() : value(), is_set(false) {}
+    RESETABLE(const T & v) : value(v), is_set(true) {}
+
+    RESETABLE(const RESETABLE<T> & rvalue)

         : value(rvalue.value),
           is_set(rvalue.is_set)
         : value(rvalue.value),
           is_set(rvalue.is_set)

+    {}
+
+    RESETABLE<T> & operator=(const RESETABLE<T> & rhs)

     {
     {

-    }
-    //-------------------------------------------------------------------------
-    RESETABLE(const value_type& val)
-        : value(val),
-          is_set(true)
-    {
-    }
-    //-------------------------------------------------------------------------
-    RESETABLE<value_type> & operator=(const RESETABLE<value_type> & rvalue)
-    {
-        value = rvalue.value;
-        is_set = rvalue.is_set;
+        value = rhs.value;
+        is_set = rhs.is_set;

         return *this;
     }
         return *this;
     }

-    //-------------------------------------------------------------------------
-    RESETABLE<value_type> & operator= (const value_type& rhs)
+
+    RESETABLE<T> & operator=(const T & rhs)

     {
         value = rhs;
         is_set = true;
         return *this;
     }
     {
         value = rhs;
         is_set = true;
         return *this;
     }

-    //-------------------------------------------------------------------------
-    const value_type& const_data() const throw()
-    {
-        return value;
-    }
-    //-------------------------------------------------------------------------
-    value_type& data() throw()
-    {
-        return value;
-    }
-    //-------------------------------------------------------------------------
-    operator const value_type&() const throw()
-    {
-        return value;
-    }
-    //-------------------------------------------------------------------------
-    bool res_empty() const throw()
+
+    const T & const_data() const throw() { return value; }
+    T & data() throw() { return value; }
+    const T & data() const throw() { return value; }
+    bool empty() const throw() { return !is_set; }
+    void reset() throw() { is_set = false; }
+    void splice(const RESETABLE<T> & rhs)

     {
     {

-        return !is_set;
+        if (rhs.is_set)
+        {
+            value = rhs.value;
+            is_set = true;
+        }

     }
     }

-    //-------------------------------------------------------------------------
-    void reset() throw()
+    void maybeSet(value_type& dest) const

     {
     {

-        is_set = false;
+        if (is_set)
+            dest = value;

     }
     }

-    //-------------------------------------------------------------------------
-protected:
-    value_type  value;
-    bool        is_set;
+
+private:
+    value_type value;
+    bool       is_set;

 };
 };

-//-----------------------------------------------------------------------------
-template <typename varT>
-std::ostream & operator<<(std::ostream & o, RESETABLE<varT> v)
-{
-    return o << v.value;
-}
-//-------------------------------------------------------------------------
-#endif // RESETABLE_VARIABLE_H

 
 

+#endif // RESETABLE_VARIABLE_H