Merge pull request #345 from ax3l/topic-getAttributeCast

Attribute: Implement get<>() Cast

Author: ax3l

CHANGELOG.rst

@@ -23,6 +23,7 @@ Bug Fixes
 - Refactor type system and ``Attribute`` set/get
   - integers #337
   - support ``long double`` reads on MSVC #184
+  - make ``::get`` cast if convertible #345
 - ``setAttribute``: explicit C-string handling #341
 - ``Dataset``: ``setCompression`` warning and error logic #326
 - avoid impact on unrelated classes in invasive tests #324

include/openPMD/Datatype.hpp

@@ -517,6 +517,11 @@ isSame( openPMD::Datatype const d, openPMD::Datatype const e )
 
     return false;
 }
+
+void
+warnWrongDtype(std::string const& key,
+               Datatype store,
+               Datatype request);
 } // namespace openPMD
 
 #if !defined(_MSC_VER)
@@ -529,12 +534,22 @@ isSame( openPMD::Datatype const d, openPMD::Datatype const e )
  *   https://stackoverflow.com/questions/44515148/why-is-operator-overload-of-enum-ambiguous-in-msvc
  *
  * @see openPMD::isSame
+ *
+ * @{
  */
 inline bool
 operator==( openPMD::Datatype d, openPMD::Datatype e )
 {
     return openPMD::isSame(d, e);
 }
+
+inline bool
+operator!=( openPMD::Datatype d, openPMD::Datatype e )
+{
+    return !(d == e);
+}
+/** @}
+ */
 #endif
 
 namespace std

include/openPMD/RecordComponent.hpp

@@ -156,7 +156,7 @@ RecordComponent::loadChunk(Offset const& o, Extent const& e, std::shared_ptr< T
         for( auto const& dimensionSize : e )
             numPoints *= dimensionSize;
 
-        T value = getCast< T >(*m_constantValue);
+        T value = m_constantValue->get< T >();
 
         T* raw_ptr = data.get();
         std::fill(raw_ptr, raw_ptr + numPoints, value);

include/openPMD/backend/Attributable.hpp

@@ -203,12 +203,6 @@ class Attributable
     std::shared_ptr< A_MAP > m_attributes;
 }; // Attributable
 
-
-void
-warnWrongDtype(std::string const& key,
-               Datatype store,
-               Datatype request);
-
 //TODO explicitly instanciate Attributable::setAttribute for all T in Datatype
 template< typename T >
 inline bool
@@ -244,96 +238,21 @@ Attributable::setAttribute(std::string const& key, char const value[])
     return this->setAttribute(key, std::string(value));
 }
 
-extern template
-float
-Attributable::readFloatingpoint(std::string const& key) const;
-
-extern template
-double
-Attributable::readFloatingpoint(std::string const& key) const;
-
-extern template
-long double
-Attributable::readFloatingpoint(std::string const& key) const;
-
 template< typename T >
 inline T
 Attributable::readFloatingpoint(std::string const& key) const
 {
     static_assert(std::is_floating_point< T >::value, "Type of attribute must be floating point");
 
-    T t{0};
-    Attribute a = getAttribute(key);
-    Datatype target_dtype = determineDatatype< T >();
-    if( a.dtype == target_dtype )
-        t = a.get< T >();
-    else
-    {
-        warnWrongDtype(key, a.dtype, target_dtype);
-        using DT = Datatype;
-        switch( a.dtype )
-        {
-            case DT::FLOAT:
-                t = static_cast< T >(a.get< float >());
-                break;
-            case DT::DOUBLE:
-                t = static_cast< T >(a.get< double >());
-                break;
-            case DT::LONG_DOUBLE:
-                t = static_cast< T >(a.get< long double >());
-                break;
-            default:
-                throw std::runtime_error("Unknown floating point datatype.");
-        }
-    }
-    return t;
+    return getAttribute(key).get< T >();
 }
 
-extern template
-std::vector< float >
-Attributable::readVectorFloatingpoint(std::string const& key) const;
-
-extern template
-std::vector< double >
-Attributable::readVectorFloatingpoint(std::string const& key) const;
-
-extern template
-std::vector< long double >
-Attributable::readVectorFloatingpoint(std::string const& key) const;
-
 template< typename T >
 inline std::vector< T >
 Attributable::readVectorFloatingpoint(std::string const& key) const
 {
     static_assert(std::is_floating_point< T >::value, "Type of attribute must be floating point");
 
-    std::vector< T > vt{};
-    Attribute a = getAttribute(key);
-    Datatype target_dtype = determineDatatype< std::vector< T > >();
-    if( a.dtype == target_dtype )
-        vt = a.get< std::vector< T > >();
-    else
-    {
-        warnWrongDtype(key, a.dtype, target_dtype);
-        using DT = Datatype;
-        switch( a.dtype )
-        {
-            case DT::VEC_FLOAT:
-                for( auto const& val : a.get< std::vector< float > >() )
-                    vt.push_back(static_cast< T >(val));
-                break;
-            case DT::VEC_DOUBLE:
-                for( auto const& val : a.get< std::vector< double > >() )
-                    vt.push_back(static_cast< T >(val));
-                break;
-            case DT::VEC_LONG_DOUBLE:
-                for( auto const& val : a.get< std::vector< long double > >() )
-                    vt.push_back(static_cast< T >(val));
-                break;
-            default:
-                throw std::runtime_error("Unknown floating point datatype.");
-        }
-    }
-    return vt;
+    return getAttribute(key).get< std::vector< T > >();
 }
 } // namespace openPMD

include/openPMD/backend/Attribute.hpp

@@ -45,7 +45,8 @@ namespace openPMD
  * @note Extending and/or modifying the available formats requires identical
  *       modifications to Datatype.
  */
-using Attribute = auxiliary::Variant< Datatype,
+class Attribute :
+    public auxiliary::Variant< Datatype,
                             char, unsigned char, // signed char,
                             short, int, long, long long,
                             unsigned short, unsigned int, unsigned long, unsigned long long,
@@ -66,7 +67,24 @@ using Attribute = auxiliary::Variant< Datatype,
                             std::vector< long double >,
                             std::vector< std::string >,
                             std::array< double, 7 >,
-                            bool >;
+                            bool >
+{
+public:
+    Attribute(resource r) : Variant(r)
+    { }
+
+    /** Retrieve a stored specific Attribute and cast if convertible.
+     *
+     * @note This performs a static_cast and might introduce precision loss if
+     *       requested. Check dtype explicitly beforehand if needed.
+     *
+     * @throw   std::runtime_error if stored object is not static castable to U.
+     * @tparam  U   Type of the object to be casted to.
+     * @return  Copy of the retrieved object, casted to type U.
+     */
+    template< typename U >
+    U get() const;
+};
 
 template< typename T, typename U, bool isConvertible = std::is_convertible<T, U>::value >
 struct DoConvert;
@@ -78,7 +96,6 @@ struct DoConvert<T, U, false>
     U operator()( PV )
     {
         throw std::runtime_error("getCast: no cast possible.");
-        return U{};
     }
 };
 
@@ -116,7 +133,7 @@ struct DoConvert<std::vector< T >, std::vector< U >, false>
     }
 };
 
-/** Retrieve a stored specific Attribute and cast if possible.
+/** Retrieve a stored specific Attribute and cast if convertible.
  *
  * @throw   std::runtime_error if stored object is not static castable to U.
  * @tparam  U   Type of the object to be casted to.
@@ -192,8 +209,12 @@ getCast( Attribute const a )
         return DoConvert<bool, U>{}(pvalue_b);
     else
         throw std::runtime_error("getCast: unknown Datatype.");
+}
 
-    return U{};
+template< typename U >
+U Attribute::get() const
+{
+    return getCast< U >( Variant::getResource() );
 }
 
 } // namespace openPMD

src/Datatype.cpp

@@ -20,9 +20,24 @@
  */
 #include "openPMD/Datatype.hpp"
 
+#include <string>
 #include <iostream>
 
 
+namespace openPMD
+{
+void warnWrongDtype(std::string const& key,
+                    Datatype store,
+                    Datatype request)
+{
+    std::cerr << "Warning: Attribute '" << key
+              << "' stored as " << store
+              << ", requested as " << request
+              << ". Casting unconditionally with possible loss of precision.\n";
+}
+} // openPMD
+
+
 std::ostream&
 std::operator<<(std::ostream& os, openPMD::Datatype d)
 {

src/RecordComponent.cpp

@@ -226,9 +226,9 @@ RecordComponent::readBase()
         // uint64_t check
         Datatype const attrDtype = *aRead.dtype;
         if( isSame( attrDtype, determineDatatype< uint64_t >() ) )
-            e.push_back( getCast< uint64_t >( a ) );
+            e.push_back( a.get< uint64_t >() );
         else if( isSame( attrDtype, determineDatatype< std::vector< uint64_t > >() ) )
-            for( auto const& val : getCast< std::vector< uint64_t > >( a ) )
+            for( auto const& val : a.get< std::vector< uint64_t > >() )
                 e.push_back( val );
         else
         {

src/backend/Attributable.cpp

@@ -289,39 +289,4 @@ Attributable::linkHierarchy(std::shared_ptr< Writable > const& w)
     m_writable->parent = writable;
     this->parent = writable;
 }
-
-
-void warnWrongDtype(std::string const& key,
-                    Datatype store,
-                    Datatype request)
-{
-    std::cerr << "Warning: Attribute '" << key
-              << "' stored as " << store
-              << ", requested as " << request
-              << ". Casting unconditionally with possible loss of precision.\n";
-}
-
-template
-float
-Attributable::readFloatingpoint(std::string const& key) const;
-
-template
-double
-Attributable::readFloatingpoint(std::string const& key) const;
-
-template
-long double
-Attributable::readFloatingpoint(std::string const& key) const;
-
-template
-std::vector< float >
-Attributable::readVectorFloatingpoint(std::string const& key) const;
-
-template
-std::vector< double >
-Attributable::readVectorFloatingpoint(std::string const& key) const;
-
-template
-std::vector< long double >
-Attributable::readVectorFloatingpoint(std::string const& key) const;
 } // openPMD