Add more example code to cxx_modules_cheatsheet.md

Author: ClausKlein

docs/cxx_modules_cheatsheeet.md

@@ -75,21 +75,189 @@ export int foo();
 ---
 
 ## 7️⃣ Header-Only Library Example
+
+### the boost/any/modules/boost_any.cppm
+
 ```cpp
+// Copyright (c) 2016-2025 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
 module;
+
+#include <boost/assert.hpp>
 #include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
 
-#ifdef USE_STD_MODULE
+// FIXME(CK): #include <boost/type_index.hpp>
+import boost.type_index;
+
+#ifdef BOOST_ANY_USE_STD_MODULE
 import std;
 #else
 #include <memory>
+#include <stdexcept>
+#include <typeinfo>
 #include <type_traits>
+#include <utility>
 #endif
 
+#define BOOST_ANY_INTERFACE_UNIT
+
 export module boost.any;
-#include <boost/any.hpp>  // exported
+
+#ifdef __clang__
+#   pragma clang diagnostic ignored "-Winclude-angled-in-module-purview"
+#endif
+
+#include <boost/any.hpp>
+#include <boost/any/basic_any.hpp>
+#include <boost/any/unique_any.hpp>
+
 ```
 
+### the boost/any.hpp
+
+```cpp
+// See http://www.boost.org/libs/any for Documentation.
+
+#ifndef BOOST_ANY_INCLUDED
+#define BOOST_ANY_INCLUDED
+
+#include <boost/any/detail/config.hpp>
+
+#if !defined(BOOST_USE_MODULES) || defined(BOOST_ANY_INTERFACE_UNIT)
+
+#ifndef BOOST_ANY_INTERFACE_UNIT
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <memory>  // for std::addressof
+#include <type_traits>
+
+#include <boost/throw_exception.hpp>
+#include <boost/type_index.hpp>
+
+#endif  // #ifndef BOOST_ANY_INTERFACE_UNIT
+
+#include <boost/any/bad_any_cast.hpp>
+#include <boost/any/fwd.hpp>
+#include <boost/any/detail/placeholder.hpp>
+
+namespace boost {
+
+BOOST_ANY_BEGIN_MODULE_EXPORT
+
+    /// \brief A class whose instances can hold instances of any
+    /// type that satisfies \forcedlink{ValueType} requirements.
+    class any
+    {
+    public:
+
+        /// \post this->empty() is true.
+        constexpr any() noexcept
+          : content(0)
+        {
+        }
+
+        /// Makes a copy of `value`, so
+
+        /// ... #### more code ###
+
+    private: // representation
+        template<typename ValueType>
+        friend ValueType * unsafe_any_cast(any *) noexcept;
+
+        friend class boost::anys::unique_any;
+
+        placeholder * content;
+        /// @endcond
+    };
+
+    /// Exchange of the contents of `lhs` and `rhs`.
+    /// \throws Nothing.
+    inline void swap(any & lhs, any & rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
+
+    /// ... ### more code ###
+
+    /// \returns ValueType stored in `operand`
+    /// \throws boost::bad_any_cast if `operand` does not contain
+    /// specified ValueType.
+    template<typename ValueType>
+    ValueType any_cast(any & operand)
+    {
+        using nonref = typename std::remove_reference<ValueType>::type;
+
+        nonref * result = boost::any_cast<nonref>(std::addressof(operand));
+        if(!result)
+            boost::throw_exception(bad_any_cast());
+
+        // Attempt to avoid construction of a temporary object in cases when
+        // `ValueType` is not a reference. Example:
+        // `static_cast<std::string>(*result);`
+        // which is equal to `std::string(*result);`
+        typedef typename std::conditional<
+            std::is_reference<ValueType>::value,
+            ValueType,
+            typename std::add_lvalue_reference<ValueType>::type
+        >::type ref_type;
+
+#ifdef BOOST_MSVC
+#   pragma warning(push)
+#   pragma warning(disable: 4172) // "returning address of local variable or temporary" but *result is not local!
+#endif
+        return static_cast<ref_type>(*result);
+#ifdef BOOST_MSVC
+#   pragma warning(pop)
+#endif
+    }
+
+    /// \returns `ValueType` stored in `operand`
+    /// \throws boost::bad_any_cast if `operand` does not contain
+    /// specified `ValueType`.
+    template<typename ValueType>
+    inline ValueType any_cast(const any & operand)
+    {
+        using nonref = typename std::remove_reference<ValueType>::type;
+        return boost::any_cast<const nonref &>(const_cast<any &>(operand));
+    }
+
+    /// \returns `ValueType` stored in `operand`, leaving the `operand` empty.
+    /// \throws boost::bad_any_cast if `operand` does not contain
+    /// specified `ValueType`.
+    template<typename ValueType>
+    inline ValueType any_cast(any&& operand)
+    {
+        static_assert(
+            std::is_rvalue_reference<ValueType&&>::value /*true if ValueType is rvalue or just a value*/
+            || std::is_const< typename std::remove_reference<ValueType>::type >::value,
+            "boost::any_cast shall not be used for getting nonconst references to temporary objects"
+        );
+        return boost::any_cast<ValueType>(operand);
+    }
+
+BOOST_ANY_END_MODULE_EXPORT
+
+}
+
+// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
+// Copyright Antony Polukhin, 2013-2025.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#endif  // #if !defined(BOOST_USE_MODULES) || defined(BOOST_ANY_INTERFACE_UNIT)
+
+#endif
+
+```
 ---
 
 ## 8️⃣ Quick Rules Summary