GROMACS: src/gromacs/utility/any.h | Fossies

“Fossies” – the Fresh Open Source Software Archive

Member “gromacs-2021.3/src/gromacs/utility/any.h” (18 Aug 2021, 8080 Bytes) of package /linux/privat/gromacs-2021.3.tar.gz:

As a special service “Fossies” has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option.
Alternatively you can here view or download the uninterpreted source code file.
For more information about “any.h” see the Fossies “Dox” file reference documentation and the last Fossies “Diffs” side-by-side code changes report: 2020.5_vs_2021.

    1 /*
    2  * This file is part of the GROMACS molecular simulation package.
    3  *
    4  * Copyright (c) 2016,2017,2018,2019,2020, by the GROMACS development team, led by
    5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
    6  * and including many others, as listed in the AUTHORS file in the
    7  * top-level source directory and at http://www.gromacs.org.
    8  *
    9  * GROMACS is free software; you can redistribute it and/or
   10  * modify it under the terms of the GNU Lesser General Public License
   11  * as published by the Free Software Foundation; either version 2.1
   12  * of the License, or (at your option) any later version.
   13  *
   14  * GROMACS is distributed in the hope that it will be useful,
   15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   17  * Lesser General Public License for more details.
   18  *
   19  * You should have received a copy of the GNU Lesser General Public
   20  * License along with GROMACS; if not, see
   21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
   22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
   23  *
   24  * If you want to redistribute modifications to GROMACS, please
   25  * consider that scientific software is very special. Version
   26  * control is crucial - bugs must be traceable. We will be happy to
   27  * consider code for inclusion in the official distribution, but
   28  * derived work must not be called official GROMACS. Details are found
   29  * in the README & COPYING files - if they are missing, get the
   30  * official version at http://www.gromacs.org.
   31  *
   32  * To help us fund GROMACS development, we humbly ask that you cite
   33  * the research papers on the package. Check out http://www.gromacs.org.
   34  */
   35 /*! libinternal file
   36  * brief
   37  * Declares gmx::Any.
   38  *
   39  * author Teemu Murtola <teemu.murtola@gmail.com>
   40  * inlibraryapi
   41  * ingroup module_utility
   42  */
   43 #ifndef GMX_UTILITY_ANY_H
   44 #define GMX_UTILITY_ANY_H
   45 
   46 #include <memory>
   47 #include <string>
   48 #include <type_traits>
   49 #include <typeindex>
   50 #include <typeinfo>
   51 #include <utility>
   52 
   53 #include "gromacs/utility/gmxassert.h"
   54 
   55 namespace gmx
   56 {
   57 
   58 /*! libinternal brief
   59  * Represents a dynamically typed value of an arbitrary type.
   60  *
   61  * To create a any, either initialize it as empty, or with the create()
   62  * method (or the equivalent constructor, if the type parameter can be deduced
   63  * and is clear to the reader from the context).
   64  *
   65  * To query the type of the contents in the any, use isEmpty(), type(), and
   66  * isType().
   67  *
   68  * To access the value, you need to know the type as a compile-time constant
   69  * (e.g., through branching based on isType()), and then use cast() or
   70  * tryCast().
   71  *
   72  * Methods in this class do not throw unless otherwise indicated.
   73  *
   74  * This provides essentially the same functionality as boost::any.
   75  *
   76  * ingroup module_utility
   77  */
   78 class Any
   79 {
   80 public:
   81     /*! brief
   82      * Creates a any that holds the given value.
   83      *
   84      * throws std::bad_alloc if out of memory.
   85      *
   86      * This method allows explicitly specifying the template argument,
   87      * contrary to the templated constructor.
   88      */
   89     template<typename T>
   90     static Any create(const T& value)
   91     {
   92         return Any(value);
   93     }
   94     /*! brief
   95      * Creates a any that holds the given value.
   96      *
   97      * throws std::bad_alloc if out of memory.
   98      *
   99      * In addition to allowing specifying the template argument, this
  100      * method avoids copying when move-construction is possible.
  101      */
  102     template<typename T>
  103     static Any create(T&& value)
  104     {
  105         return Any(std::forward<T>(value));
  106     }
  107 
  108     //! Creates an empty any value.
  109     Any() {}
  110     /*! brief
  111      * Creates a any that holds the given value.
  112      *
  113      * throws std::bad_alloc if out of memory.
  114      */
  115     template<typename T, typename = std::enable_if_t<!std::is_same<T, Any>::value>>
  116     explicit Any(T&& value) :
  117         content_(new Content<typename std::decay<T>::type>(std::forward<T>(value)))
  118     {
  119     }
  120     /*! brief
  121      * Creates a deep copy of a any.
  122      *
  123      * throws std::bad_alloc if out of memory.
  124      */
  125     Any(const Any& other) : content_(other.cloneContent()) {}
  126     //! Move-constructs a any.
  127     Any(Any&& other) noexcept : content_(std::move(other.content_)) {}
  128     /*! brief
  129      * Assigns the any.
  130      *
  131      * throws std::bad_alloc if out of memory.
  132      */
  133     Any& operator=(const Any& other)
  134     {
  135         content_ = other.cloneContent();
  136         return *this;
  137     }
  138     //! Move-assigns the any.
  139     Any& operator=(Any&& other) noexcept
  140     {
  141         content_ = std::move(other.content_);
  142         return *this;
  143     }
  144 
  145     //! Whether any value is stored.
  146     bool isEmpty() const { return content_ == nullptr; }
  147     //! Returns the dynamic type of the value that is currently stored.
  148     std::type_index type() const
  149     {
  150         const std::type_info& info = !isEmpty() ? content_->typeInfo() : typeid(void);
  151         return std::type_index(info);
  152     }
  153     //! Returns whether the type stored matches the template parameter.
  154     template<typename T>
  155     bool isType() const
  156     {
  157         return !isEmpty() && content_->typeInfo() == typeid(T);
  158     }
  159 
  160     /*! brief
  161      * Tries to get the value as the given type.
  162      *
  163      * tparam T  Type to get.
  164      * returns Pointer to the value, or nullptr if the type does not match
  165      *     the stored value.
  166      */
  167     template<typename T>
  168     const T* tryCast() const
  169     {
  170         return isType<T>() ? &static_cast<Content<T>*>(content_.get())->value_ : nullptr;
  171     }
  172     /*! brief
  173      * Gets the value when the type is known.
  174      *
  175      * tparam T  Type to get (which must match what the any stores).
  176      *
  177      * Asserts if the any is empty or does not contain the requested type.
  178      */
  179     template<typename T>
  180     const T& cast() const
  181     {
  182         const T* value = tryCast<T>();
  183         GMX_RELEASE_ASSERT(value != nullptr, "Cast to incorrect type");
  184         return *value;
  185     }
  186     /*! brief
  187      * Tries to get the value as the given type as a non-const pointer.
  188      *
  189      * tparam T  Type to get.
  190      * returns Pointer to the value, or nullptr if the type does not match
  191      *     the stored value.
  192      *
  193      * This method allows modifying the value in-place, which is useful
  194      * with more complicated data structures.
  195      */
  196     template<typename T>
  197     T* tryCastRef()
  198     {
  199         return isType<T>() ? &static_cast<Content<T>*>(content_.get())->value_ : nullptr;
  200     }
  201     /*! brief
  202      * Gets the value when the type is known as a modifiable reference.
  203      *
  204      * tparam T  Type to get (which must match what the any stores).
  205      *
  206      * Asserts if the any is empty or does not contain the requested type.
  207      */
  208     template<typename T>
  209     T& castRef()
  210     {
  211         T* value = tryCastRef<T>();
  212         GMX_RELEASE_ASSERT(value != nullptr, "Cast to incorrect type");
  213         return *value;
  214     }
  215 
  216 private:
  217     class IContent
  218     {
  219     public:
  220         virtual ~IContent() {}
  221         virtual const std::type_info&     typeInfo() const = 0;
  222         virtual std::unique_ptr<IContent> clone() const    = 0;
  223     };
  224 
  225     template<typename T>
  226     class Content : public IContent
  227     {
  228     public:
  229         explicit Content(const T& value) : value_(value) {}
  230         explicit Content(T&& value) : value_(std::move(value)) {}
  231 
  232         const std::type_info&     typeInfo() const override { return typeid(T); }
  233         std::unique_ptr<IContent> clone() const override
  234         {
  235             return std::make_unique<Content>(value_);
  236         }
  237 
  238         T value_;
  239     };
  240 
  241     //! Creates a deep copy of the content.
  242     std::unique_ptr<IContent> cloneContent() const
  243     {
  244         return content_ != nullptr ? content_->clone() : nullptr;
  245     }
  246 
  247     std::unique_ptr<IContent> content_;
  248 };
  249 
  250 //! cond libapi
  251 /*! brief
  252  * Converts a Any value to a string.
  253  *
  254  * As the name suggests, only some types of "simple" values (such as int) are
  255  * supported.  Asserts for unsupported types.
  256  *
  257  * ingroup module_utility
  258  */
  259 std::string simpleValueToString(const Any& value);
  260 //! endcond
  261 
  262 } // namespace gmx
  263 
  264 #endif