zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/include/Ice/StreamableTraits.h

@@ -0,0 +1,291 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_STREAMABLE_TRAITS_H
+#define ICE_STREAMABLE_TRAITS_H
+
+#include "ValueF.h"
+
+#include <optional>
+#include <string_view>
+
+namespace Ice
+{
+    class ObjectPrx;
+    class UserException;
+
+    /// The stream helper category allows to select a StreamHelper specialization for a specific category of types.
+    /// The possible values are #StreamHelperCategoryUnknown, #StreamHelperCategoryBuiltinValue,
+    /// #StreamHelperCategoryBuiltin, #StreamHelperCategoryStruct, #StreamHelperCategoryEnum,
+    /// #StreamHelperCategorySequence, #StreamHelperCategoryDictionary, #StreamHelperCategoryProxy,
+    /// #StreamHelperCategoryClass, or #StreamHelperCategoryUserException. You can also define your own value if you
+    /// want to add support for a new type category.
+    using StreamHelperCategory = int;
+
+    /// Types with no StreamHelper specialization.
+    constexpr StreamHelperCategory StreamHelperCategoryUnknown = 0;
+
+    /// Built-in types usually passed by value.
+    constexpr StreamHelperCategory StreamHelperCategoryBuiltinValue = 1;
+
+    /// Built-in types usually passed by reference.
+    constexpr StreamHelperCategory StreamHelperCategoryBuiltin = 2;
+
+    /// Generated struct types.
+    constexpr StreamHelperCategory StreamHelperCategoryStruct = 3;
+
+    /// Generated enum types.
+    constexpr StreamHelperCategory StreamHelperCategoryEnum = 4;
+
+    /// Sequence types.
+    constexpr StreamHelperCategory StreamHelperCategorySequence = 5;
+
+    /// Dictionary types.
+    constexpr StreamHelperCategory StreamHelperCategoryDictionary = 6;
+
+    /// Proxy types.
+    constexpr StreamHelperCategory StreamHelperCategoryProxy = 7;
+
+    /// Generated class types.
+    constexpr StreamHelperCategory StreamHelperCategoryClass = 8;
+
+    /// User exception types.
+    constexpr StreamHelperCategory StreamHelperCategoryUserException = 9;
+
+    /// The optional format, used for marshaling optional fields and arguments.
+    /// It describes how the data is marshaled and how it can be skipped by the unmarshaling code if the optional isn't
+    /// known to the receiver.
+    enum class OptionalFormat : std::uint8_t
+    {
+        /// Fixed 1-byte encoding.
+        F1 = 0,
+
+        /// Fixed 2-byte encoding.
+        F2 = 1,
+
+        /// Fixed 4-byte encoding.
+        F4 = 2,
+
+        /// Fixed 8-byte encoding.
+        F8 = 3,
+
+        /// "Size encoding" using either 1 or 5 bytes. Used by enums, class identifiers, etc.
+        Size = 4,
+
+        /// Variable "size encoding" using either 1 or 5 bytes followed by data.
+        /// Used by strings, fixed size structs, and containers whose size can be computed prior to marshaling.
+        VSize = 5,
+
+        /// Fixed "size encoding" using 4 bytes followed by data.
+        /// Used by variable-size structs, and containers whose sizes can't be computed prior to unmarshaling.
+        FSize = 6,
+
+        /// Class instance. No longer supported.
+        Class = 7
+    };
+
+    /// @private
+    /// Determines whether the provided type is a container. The implementation checks if there is a @p T::iterator
+    /// typedef using SFINAE.
+    /// @tparam T The type to check
+    template<typename T> struct IsContainer
+    {
+        template<typename C> static char test(typename C::iterator*) noexcept;
+
+        template<typename C> static long test(...) noexcept;
+
+        static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
+    };
+
+    /// @private
+    /// Determines whether the provided type is a map. The implementation checks if there is a @p T::mapped_type typedef
+    /// using SFINAE.
+    /// @tparam T The type to check
+    template<typename T> struct IsMap
+    {
+        template<typename C> static char test(typename C::mapped_type*) noexcept;
+
+        template<typename C> static long test(...) noexcept;
+
+        static constexpr bool value = IsContainer<T>::value && sizeof(test<T>(nullptr)) == sizeof(char);
+    };
+
+#ifdef ICE_DOXYGEN
+    /// Provides traits for a type that can be marshaled or unmarshaled to/from a stream of bytes using the Slice
+    /// encoding. This template is specialized for each type that can be marshaled/unmarshaled.
+    /// @tparam T The type to provide the traits for.
+    /// @tparam Enabler A type used to enable a partial specialization for several types. It should not be used in the
+    /// partial specialization itself.
+    /// @remark Streamable traits for enumeration types provide two additional traits: `minValue` and `maxValue`.
+    /// @headerfile Ice/Ice.h
+    template<typename T, typename Enabler = void> struct StreamableTraits
+    {
+        /// The category trait, used for selecting the appropriate StreamHelper.
+        static constexpr StreamHelperCategory helper;
+
+        /// The minimum number of bytes needed to marshal this type.
+        static constexpr int minWireSize;
+
+        /// Indicates if the type is always encoded on a fixed number of bytes.
+        // Only used for marshaling/unmarshaling optional data members and parameters.
+        static constexpr bool fixedLength;
+    };
+#endif
+
+    /// @cond INTERNAL
+
+    /// Base traits template. Types with no specialized trait use this trait.
+    template<typename T, typename Enabler = void> struct StreamableTraits
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryUnknown;
+    };
+
+    /// Partial specialization for sequence and dictionary types.
+    template<typename T> struct StreamableTraits<T, std::enable_if_t<IsMap<T>::value || IsContainer<T>::value>>
+    {
+        static constexpr StreamHelperCategory helper =
+            IsMap<T>::value ? StreamHelperCategoryDictionary : StreamHelperCategorySequence;
+
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = false;
+    };
+
+    /// Partial specialization for user exceptions.
+    template<typename T> struct StreamableTraits<T, std::enable_if_t<std::is_base_of_v<UserException, T>>>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryUserException;
+
+        // There is no sequence/dictionary of UserException (so no need for minWireSize) and no optional UserException
+        // (so no need for fixedLength)
+    };
+
+    /// Partial specialization for arrays (std::pair<const T*, const T*>).
+    template<typename T> struct StreamableTraits<std::pair<T*, T*>>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategorySequence;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = false;
+    };
+
+    //
+    // Specialization for built-in types (this is needed for sequence marshaling to figure out the minWireSize of each
+    // type).
+    //
+
+    template<> struct StreamableTraits<bool>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = true;
+    };
+
+    template<> struct StreamableTraits<std::byte>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = true;
+    };
+
+    template<> struct StreamableTraits<std::uint8_t>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = true;
+    };
+
+    template<> struct StreamableTraits<std::int16_t>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 2;
+        static constexpr bool fixedLength = true;
+    };
+
+    template<> struct StreamableTraits<std::int32_t>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 4;
+        static constexpr bool fixedLength = true;
+    };
+
+    template<> struct StreamableTraits<std::int64_t>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 8;
+        static constexpr bool fixedLength = true;
+    };
+    template<> struct StreamableTraits<float>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 4;
+        static constexpr bool fixedLength = true;
+    };
+
+    template<> struct StreamableTraits<double>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 8;
+        static constexpr bool fixedLength = true;
+    };
+
+    template<> struct StreamableTraits<std::string>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltin;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = false;
+    };
+
+    template<> struct StreamableTraits<std::string_view>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = false;
+    };
+
+    template<> struct StreamableTraits<std::wstring>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltin;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = false;
+    };
+
+    template<> struct StreamableTraits<std::wstring_view>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltinValue;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = false;
+    };
+
+    /// vector<bool> is a special type in C++: the streams handle it like a built-in type.
+    template<> struct StreamableTraits<std::vector<bool>>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryBuiltin;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = false;
+    };
+
+    //
+    // Partial specialization for proxies and classes.
+    //
+
+    template<typename T> struct StreamableTraits<std::optional<T>, std::enable_if_t<std::is_base_of_v<ObjectPrx, T>>>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryProxy;
+        static constexpr int minWireSize = 2;
+        static constexpr bool fixedLength = false;
+    };
+
+    template<typename T> struct StreamableTraits<std::shared_ptr<T>, std::enable_if_t<std::is_base_of_v<Value, T>>>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryClass;
+        static constexpr int minWireSize = 1;
+        static constexpr bool fixedLength = false;
+    };
+
+    template<typename T, StreamHelperCategory st> struct StreamHelper;
+
+    /// @endcond
+
+    /// @private
+    template<typename T, StreamHelperCategory st, bool fixedLength> struct StreamOptionalHelper;
+}
+
+#endif

data/dist/ice/cpp/include/Ice/StringConverter.h

@@ -1,78 +1,167 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_STRING_CONVERTER_H
 #define ICE_STRING_CONVERTER_H
 
-#include <Ice/Config.h>
-#include <IceUtil/StringConverter.h>
-#include <IceUtil/ConsoleUtil.h>
+#include "Config.h"
+#include "LocalException.h"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
 
 namespace Ice
 {
-
-/** Encapsulates bytes in the UTF-8 encoding. */
-typedef IceUtil::UTF8Buffer UTF8Buffer;
-
-/** Narrow string converter. */
-typedef IceUtil::StringConverter StringConverter;
-typedef IceUtil::StringConverterPtr StringConverterPtr;
-
-/** Wide string converter. */
-typedef IceUtil::WstringConverter WstringConverter;
-typedef IceUtil::WstringConverterPtr WstringConverterPtr;
-
-/** Indicates an error occurred during string conversion. */
-typedef IceUtil::IllegalConversionException IllegalConversionException;
-
-#ifdef ICE_CPP11_MAPPING
-/** Base class for a string converter. */
-template<typename charT>
-using BasicStringConverter = IceUtil::BasicStringConverter<charT>;
+    /// Provides bytes to toUTF8.
+    /// @headerfile Ice/Ice.h
+    class ICE_API UTF8Buffer
+    {
+    public:
+        /// Obtains more bytes.
+        /// @param howMany The number of bytes requested.
+        /// @param firstUnused A pointer to the first unused byte.
+        /// @return A pointer to the beginning of the buffer.
+        /// @throws std::bad_alloc Thrown when too many bytes are requested.
+        /// @throws MarshalException Thrown when too many bytes are requested.
+        virtual std::byte* getMoreBytes(size_t howMany, std::byte* firstUnused) = 0;
+
+        virtual ~UTF8Buffer();
+    };
+
+    /// A StringConverter converts narrow or wide-strings to and from UTF-8 byte sequences.
+    /// It's used by the communicator during marshaling (toUTF8) and unmarshaling (fromUTF8).
+    /// It report errors by throwing IllegalConversionException or an exception thrown
+    /// by UTF8Buffer.
+    /// @headerfile Ice/Ice.h
+    template<typename charT> class BasicStringConverter
+    {
+    public:
+        /// Returns a pointer to byte after the last written byte (which may be
+        /// past the last byte returned by getMoreBytes).
+        virtual std::byte* toUTF8(const charT* sourceStart, const charT* sourceEnd, UTF8Buffer& buf) const = 0;
+
+        /// Unmarshals a UTF-8 sequence into a basic_string.
+        virtual void
+        fromUTF8(const std::byte* sourceStart, const std::byte* sourceEnd, std::basic_string<charT>& target) const = 0;
+
+        virtual ~BasicStringConverter() = default;
+    };
+
+#if defined(__clang__)
+    // Explicit template instantiation so that dynamic_cast of derived exported
+    // classes works well with clang, see ICE-7473.
+    template class __attribute__((visibility("default"))) BasicStringConverter<char>;
+    template class __attribute__((visibility("default"))) BasicStringConverter<wchar_t>;
 #endif
 
-#ifdef _WIN32
-/**
- * Creates a string converter that converts between multi-byte and UTF-8 strings and uses MultiByteToWideChar
- * and WideCharToMultiByte for its implementation.
- */
-using IceUtil::createWindowsStringConverter;
+    /// A narrow string converter.
+    using StringConverter = BasicStringConverter<char>;
+
+    /// A shared pointer to a StringConverter.
+    using StringConverterPtr = std::shared_ptr<StringConverter>;
+
+    /// A wide string converter.
+    using WstringConverter = BasicStringConverter<wchar_t>;
+
+    /// A shared pointer to a WstringConverter.
+    using WstringConverterPtr = std::shared_ptr<WstringConverter>;
+
+    /// Creates a WstringConverter that converts to and from UTF-16 or UTF-32 depending on sizeof(wchar_t).
+    /// @return The string converter.
+    ICE_API WstringConverterPtr createUnicodeWstringConverter();
+
+    /// Retrieves the per-process narrow string converter.
+    /// @return The string converter.
+    ICE_API StringConverterPtr getProcessStringConverter();
+
+    /// Sets the per-process narrow string converter.
+    /// @param c The string converter.
+    ICE_API void setProcessStringConverter(const StringConverterPtr& c);
+
+    /// Retrieves the per-process wide string converter.
+    /// @return The string converter.
+    ICE_API WstringConverterPtr getProcessWstringConverter();
+
+    /// Sets the per process wide string converter.
+    /// @param c The string converter.
+    ICE_API void setProcessWstringConverter(const WstringConverterPtr& c);
+
+    /// Converts a wide string to a narrow string.
+    /// @param str The wide string to convert.
+    /// @param nc The narrow string converter. If null, the result's encoding is UTF-8.
+    /// @param wc The wide string converter. If null, the encoding of @p str is UTF-16 or UTF-32 depending on the size
+    /// of wchar_t.
+    /// @return A narrow string.
+    ICE_API std::string wstringToString(
+        const std::wstring& str,
+        const StringConverterPtr& nc = nullptr,
+        const WstringConverterPtr& wc = nullptr);
+
+    /// Converts a narrow string to a wide string.
+    /// @param str The narrow string to convert.
+    /// @param nc The narrow string converter. If null, the encoding of @p str is UTF-8.
+    /// @param wc The wide string converter. If null, the result's encoding is UTF-16 or UTF-32 depending on the size of
+    /// wchar_t.
+    /// @return A wide string.
+    ICE_API std::wstring stringToWstring(
+        const std::string& str,
+        const StringConverterPtr& nc = nullptr,
+        const WstringConverterPtr& wc = nullptr);
+
+    /// Converts the given string from the native narrow string encoding to
+    /// UTF-8 using the given converter.
+    /// @param str The native narrow string.
+    /// @param nc The narrow string converter. If null, the native string is returned.
+    /// @return A UTF-8 string.
+    ICE_API std::string nativeToUTF8(std::string_view str, const StringConverterPtr& nc);
+
+    /// Converts the given string from UTF-8 to the native narrow string
+    /// encoding using the given converter.
+    /// @param str The UTF-8 string.
+    /// @param nc The narrow string converter. If null, the UTF-8 string is returned.
+    /// @return A native narrow string.
+    ICE_API std::string UTF8ToNative(std::string_view str, const StringConverterPtr& nc);
+
+#if defined(_WIN32) || defined(ICE_DOXYGEN)
+    /// Creates a StringConverter that converts to and from narrow chars
+    /// in the given code page, using MultiByteToWideChar and WideCharToMultiByte.
+    /// @param page The code page.
+    /// @return The string converter.
+    /// @remark Windows only.
+    ICE_API StringConverterPtr createWindowsStringConverter(unsigned int page);
 #endif
 
-/** Creates a string converter that converts between Unicode wide strings and UTF-8 strings. */
-using IceUtil::createUnicodeWstringConverter;
-
-/** Installs a default narrow string converter for the process. */
-using IceUtil::setProcessStringConverter;
-
-/** Obtains the default narrow string converter for the process. */
-using IceUtil::getProcessStringConverter;
-
-/** Installs a default wide string converter for the process. */
-using IceUtil::setProcessWstringConverter;
-
-/** Obtains the default wide string converter for the process. */
-using IceUtil::getProcessWstringConverter;
-
-/** Converts a wide string to a narrow string. */
-using IceUtil::wstringToString;
-
-/** Converts a narrow string to a wide string. */
-using IceUtil::stringToWstring;
-
-/**
- * Converts a narrow string to a UTF-8 encoded string using a string converter.
- * No conversion is performed if the string converter is nil.
- */
-using IceUtil::nativeToUTF8;
-
-/**
- * Converts a UTF-8 encoded string to a narrow string using a string converter.
- * No conversion is performed if the string converter is nil.
- */
-using IceUtil::UTF8ToNative;
+    /// This exception indicates the failure of a string conversion.
+    /// @headerfile Ice/Ice.h
+    class ICE_API IllegalConversionException final : public LocalException
+    {
+    public:
+        /// Constructs an IllegalConversionException.
+        /// @param file The file where this exception is constructed. This C string is not copied.
+        /// @param line The line where this exception is constructed.
+        /// @param message The error message adopted by this exception and returned by what().
+        IllegalConversionException(const char* file, int line, std::string message)
+            : LocalException(file, line, std::move(message))
+        {
+        }
+
+        [[nodiscard]] const char* ice_id() const noexcept final;
+    };
+}
 
+namespace IceInternal
+{
+    //
+    // Convert from UTF-8 to UTF-16/32
+    //
+    ICE_API std::vector<unsigned short> toUTF16(const std::vector<std::uint8_t>&);
+    ICE_API std::vector<unsigned int> toUTF32(const std::vector<std::uint8_t>&);
+
+    //
+    // Convert from UTF-32 to UTF-8
+    //
+    ICE_API std::vector<std::uint8_t> fromUTF32(const std::vector<unsigned int>&);
 }
 
 #endif

data/dist/ice/cpp/include/Ice/StringUtil.h

@@ -0,0 +1,114 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_STRING_UTIL_H
+#define ICE_STRING_UTIL_H
+
+#include "Ice/Config.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace Ice
+{
+    /// The output mode for xxxToString methods such as identityToString and proxyToString. The actual encoding format
+    /// for the string is the same for all modes: you don't need to specify an encoding format or mode when reading such
+    /// a string.
+    enum class ToStringMode : std::uint8_t
+    {
+        /// Characters with ordinal values greater than 127 are kept as-is in the resulting string. Non-printable ASCII
+        /// characters with ordinal values 127 and below are encoded as \\t, \\n (etc.) or \\unnnn.
+        Unicode,
+        /// Characters with ordinal values greater than 127 are encoded as universal character names in the resulting
+        /// string: \\unnnn for BMP characters and \\Unnnnnnnn for non-BMP characters. Non-printable ASCII characters
+        /// with ordinal values 127 and below are encoded as \\t, \\n (etc.) or \\unnnn.
+        ASCII,
+        /// Characters with ordinal values greater than 127 are encoded as a sequence of UTF-8 bytes using octal
+        /// escapes. Characters with ordinal values 127 and below are encoded as \\t, \\n (etc.) or an octal escape. Use
+        /// this mode to generate strings compatible with Ice 3.6 and earlier.
+        Compat
+    };
+}
+
+namespace IceInternal
+{
+    //
+    // Add escape sequences (like "\n", or "\123") to the input string
+    // (first parameter).
+    // The second parameter adds characters to escape, and can be empty.
+    //
+    ICE_API std::string escapeString(std::string_view s, std::string_view special, Ice::ToStringMode toStringMode);
+
+    //
+    // Remove escape sequences added by escapeString. Throws std::invalid_argument
+    // for an invalid input string.
+    //
+    ICE_API std::string unescapeString(
+        std::string_view,
+        std::string_view::size_type,
+        std::string_view::size_type,
+        std::string_view special);
+
+    //
+    // Split a string using the given delimiters. Considers single and double quotes;
+    // returns false for unbalanced quote, true otherwise.
+    //
+    ICE_API bool splitString(std::string_view, std::string_view, std::vector<std::string>&);
+
+    //
+    // Join a list of strings using the given delimiter.
+    //
+    ICE_API std::string joinString(const std::vector<std::string>&, std::string_view delimiter);
+
+    //
+    // Trim white space
+    //
+    ICE_API std::string trim(std::string_view);
+
+    //
+    // If a single or double quotation mark is found at the start
+    // position, then the position of the matching closing quote is
+    // returned. If no quotation mark is found at the start position, then
+    // 0 is returned. If no matching closing quote is found, then
+    // std::string::npos is returned.
+    //
+    ICE_API std::string::size_type checkQuote(const std::string&, std::string::size_type = 0);
+
+    //
+    // Match `s' against the pattern `pat'. A * in the pattern acts
+    // as a wildcard: it matches any non-empty sequence of characters
+    // other than a period (`.'). We match by hand here because
+    // it's portable across platforms (whereas regex() isn't).
+    //
+    ICE_API bool match(const std::string&, const std::string&, bool = false);
+
+    //
+    // Get the error message for the last error code or given error code.
+    //
+    ICE_API std::string lastErrorToString();
+#ifdef _WIN32
+    using ErrorCode = unsigned long; // DWORD
+    ICE_API std::string errorToStringWithSource(ErrorCode error, const void* source);
+    inline std::string errorToString(ErrorCode error) { return errorToStringWithSource(error, nullptr); }
+#else
+    using ErrorCode = int;
+    ICE_API std::string errorToString(int);
+#endif
+
+    //
+    // Functions to convert to lower/upper case. These functions accept
+    // UTF8 string/characters but ignore non ASCII characters. Unlike, the
+    // C methods, these methods are not local dependent.
+    //
+    ICE_API std::string toLower(std::string_view);
+    ICE_API std::string toUpper(std::string_view);
+    ICE_API bool isAlpha(char);
+    ICE_API bool isDigit(char);
+
+    //
+    // Remove all whitespace from a string
+    //
+    ICE_API std::string removeWhitespace(std::string_view);
+}
+
+#endif

data/dist/ice/cpp/include/Ice/TimerTask.h

@@ -0,0 +1,24 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_TIMER_TASK_H
+#define ICE_TIMER_TASK_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class Timer;
+    using TimerPtr = std::shared_ptr<Timer>;
+
+    class ICE_API TimerTask
+    {
+    public:
+        virtual ~TimerTask();
+
+        virtual void runTimerTask() = 0;
+    };
+
+    using TimerTaskPtr = std::shared_ptr<TimerTask>;
+}
+
+#endif