ssthandler.h

// Copyright 2009-2026 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2026, NTESS
// All rights reserved.
//
// This file is part of the SST software package. For license
// information, see the LICENSE file in the top level directory of the
// distribution.
 
#ifndef SST_CORE_SSTHANDLER_H
#define SST_CORE_SSTHANDLER_H
 
#include "sst/core/serialization/serializable.h"
#include "sst/core/sst_types.h"
 
namespace SST {
 
class Params;
 
// This file contains base classes for use as various handlers (object encapsulating callback functions) in SST.  These
// handlers are checkpointable and encapsulate a pointer to an object and a pointer to a member function of the object's
// class (captured via template parameter).  The classes also allow you to optionally add one additional piece of static
// data to be passed into the callback function along with any data provided by the caller.  There are two versions of
// this class, one that has no data passed from the caller (ending with SSTHandlerNoArgs), and one that has a single
// item passed from the caller (SSTHandler).
 
// These classes provide the full functionality of the handlers and can be added to a class with the "using" keyword, as
// follows (a class can use any type name they'd like in place of HandlerBase and Handler, though those names are
// preferred for consistency).
 
// Note: Support for legacy (noncheckpointable) handlers has been removed and Handler and Handler2 are now identical.
// The name Handler2 is deprecated and will be removed in SST 17, but is included to provide backward compatibility
// until that release.
 
 
// How to declare the Handlers in a class with the "using" keyword:
 
// Need to first declare the base class that will be used to refer to all handlers of that type
 
// using HandlerBase = SSTHandlerBase<return_type_of_callback, arg_type_of_callback>;
 
 
// This is the final class that allows the user to specify the class and function for the callback
 
// template <typename classT, auto funcT, typename dataT = void>
// using Handler = SSTHandler<return_type_of_callback, arg_type_of_callback, classT, dataT, funcT>;
 
 
// The handlers are then instanced as follows:
 
// new Class::Handler<Class, &Class::callback_function>(this)
 
// Or:
 
// new Class::Handler<Class, &Class::callback_function, int>(this, 1)
 
// If it is necessary to add to the API for HandlerBase, it is possible to create a new class for HandlerBase instead of
// just relying on the using statement.  In this case, the new HandlerBase will inherit from SSTHandlerBase with the
// proper template parameters.  This new class can add to the API, while still inheriting all the functionality found in
// SSTHandlerBase.  The final classes are then defined with a slightly modified using statement.
 
// New HandlerBase:
 
// class HandlerBase : public SSTHandlerBase<return_type_of_callback, arg_type_of_callback>
// {
// public:
//     HandlerBase() = default;
//
//    void serialize_order(SST::Core::Serialization::serializer& ser) override
//    {
//        SSTHandlerBase<bool, Cycle_t>::serialize_order(ser);
//        // Serialize any extra data here
//    }
//
//    ImplementVirtualSerializable(HandlerBase);
//
//    // Any other class members/functions
// };
 
// This is the final class that allows the user to specify the class and function for the callback. Note that you must
// include the new HandlerBase base class as a template parameter
 
// template <typename classT, auto funcT, typename dataT = void>
// using Handler = SSTHandler<return_type_of_callback, arg_type_of_callback, classT, dataT, funcT, HandlerBase>;
 
// The handlers are instanced the same as above
 
 
/**********************************************************************
 * Base class templates for handlers.  The base functionality includes
 * the common API for all handlers.  It also includes management of
 * attach points.
 *
 * There are 4 total expansions of the template across 2 classes,
 * based on whether their return and arg values are void or non-void.
 * Each of these also define the appropriate Attach and/or Intercept
 * points.
 **********************************************************************/
 
/**
   Base template for handlers which take a class defined argument.
 
   This default expansion covers the case of non-void return
   type. This version does not support intercepts.
*/
template <typename returnT, typename argT>
class SSTHandlerBase : public SST::Core::Serialization::serializable
{
public:
    /**
       Attach Point to get notified when a handler starts and stops.
       This class is used in conjunction with a Tool type base class to
       create various tool types to attach to the handler.
    */
    class AttachPoint
    {
    public:
        AttachPoint() {}
        virtual ~AttachPoint() {}
 
        /**
           Function that will be called when a handler is registered
           with the tool implementing the attach point.  The metadata
           passed in will be dependent on what type of tool this is
           attached to.  The uintptr_t returned from this function
           will be passed into the beforeHandler() and afterHandler()
           functions.
 
           @param mdata Metadata to be passed into the tool
 
           @return Opaque key that will be passed back into
           beforeHandler() and afterHandler() to identify the source
           of the calls
        */
        virtual uintptr_t registerHandler(const AttachPointMetaData& mdata) = 0;
 
        /**
           Function to be called before the handler is called.
 
           @key uintptr_t returned from registerHandler() when handler
           was registered with the tool
 
           @arg argument that will be passed to the handler function.
           If argT is a pointer, this will be passed as a const
           pointer, if not, it will be passed as a const reference
        */
        virtual void beforeHandler(uintptr_t                                                             key,
            std::conditional_t<std::is_pointer_v<argT>, const std::remove_pointer_t<argT>*, const argT&> arg) = 0;
 
        /**
           Function to be called after the handler is called.  The key
           passed in is the uintptr_t returned from registerHandler()
 
           @param key uintptr_t returned from registerHandler() when
           handler was registered with the tool
 
           @param ret_value value that was returned by the handler. If
           retunT is a pointer, this will be passed as a const
           pointer, if not, it will be passed as a const reference
        */
        virtual void afterHandler(uintptr_t key,
            std::conditional_t<std::is_pointer_v<returnT>, const std::remove_pointer_t<returnT>*, const returnT&>
                ret_value) = 0;
 
        /**
           Function that will be called to handle the key returned
           from registerHandler, if the AttachPoint tool is
           serializable.  This is needed because the key is opaque to
           the Link, so it doesn't know how to handle it during
           serialization.  During SIZE and PACK phases of
           serialization, the tool needs to store out any information
           that will be needed to recreate data that is reliant on the
           key.  On UNPACK, the function needs to recreate any state
           and reinitialize the passed in key reference to the proper
           state to continue to make valid calls to beforeHandler()
           and afterHandler().
 
           Since not all tools will be serializable, there is a
           default, empty implementation.
 
           @param ser Serializer to use for serialization
 
           @param key Key that would be passed into the
           beforeHandler() and afterHandler() functions.
         */
        virtual void serializeHandlerAttachPointKey(
            SST::Core::Serialization::serializer& UNUSED(ser), uintptr_t& UNUSED(key))
        {}
    };
 
private:
    using ToolList           = std::vector<std::pair<AttachPoint*, uintptr_t>>;
    ToolList* attached_tools = nullptr;
 
protected:
    // Implementation of operator() to be done in child classes
    virtual returnT operator_impl(argT) = 0;
 
    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        switch ( ser.mode() ) {
        case Core::Serialization::serializer::SIZER:
        case Core::Serialization::serializer::PACK:
        {
            ToolList tools;
            if ( attached_tools ) {
                for ( auto x : *attached_tools ) {
                    if ( dynamic_cast<SST::Core::Serialization::serializable*>(x.first) ) {
                        tools.push_back(x);
                    }
                }
            }
            size_t tool_count = tools.size();
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                // Serialize each tool, then call serializeEventAttachPointKey() to serialize any data associated with
                // the key
                for ( auto x : tools ) {
                    SST::Core::Serialization::serializable* obj =
                        dynamic_cast<SST::Core::Serialization::serializable*>(x.first);
                    SST_SER(obj);
                    x.first->serializeHandlerAttachPointKey(ser, x.second);
                }
            }
            break;
        }
        case Core::Serialization::serializer::UNPACK:
        {
            size_t tool_count;
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                attached_tools = new ToolList();
                for ( size_t i = 0; i < tool_count; ++i ) {
                    SST::Core::Serialization::serializable* tool;
                    uintptr_t                               key;
                    SST_SER(tool);
                    AttachPoint* ap = dynamic_cast<AttachPoint*>(tool);
                    ap->serializeHandlerAttachPointKey(ser, key);
                    attached_tools->emplace_back(ap, key);
                }
            }
            else {
                attached_tools = nullptr;
            }
            break;
        }
        default:
            break;
        }
    }
 
public:
    virtual ~SSTHandlerBase() {}
 
    inline returnT operator()(argT arg)
    {
        if ( !attached_tools ) return operator_impl(arg);
 
        // Tools attached
        for ( auto& x : *attached_tools )
            x.first->beforeHandler(x.second, arg);
 
        returnT ret = operator_impl(arg);
 
        for ( auto& x : *attached_tools )
            x.first->afterHandler(x.second, ret);
 
        return ret;
    }
 
    /**
       Attaches a tool to the AttachPoint
 
       @param tool Tool to attach
 
       @param mdata Metadata to pass to the tool
    */
    void attachTool(AttachPoint* tool, const AttachPointMetaData& mdata)
    {
        if ( !attached_tools ) attached_tools = new ToolList();
 
        auto key = tool->registerHandler(mdata);
        attached_tools->push_back(std::make_pair(tool, key));
    }
 
    /**
       Remove an attached tool
 
       @param tool Tool to remove.  If tool doesn't exist, then no
       action is taken
     */
    void detachTool(AttachPoint* tool)
    {
        if ( !attached_tools ) return;
 
        for ( auto x = attached_tools->begin(); x != attached_tools->end(); ++x ) {
            if ( x->first == tool ) {
                attached_tools->erase(x);
                break;
            }
        }
    }
 
    /**
       Transfers attached tools from existing handler
     */
    void transferAttachedToolInfo(SSTHandlerBase* handler)
    {
        if ( handler->attached_tools ) {
            attached_tools          = handler->attached_tools;
            handler->attached_tools = nullptr;
        }
    }
 
private:
    ImplementVirtualSerializable(SSTHandlerBase)
};
 
 
/**
   Base template for handlers which take an class defined argument.
 
   This expansion covers the case of void return type. This version
   supports intercepts.
*/
template <typename argT>
class SSTHandlerBase<void, argT> : public SST::Core::Serialization::serializable
{
public:
    /**
       Attach Point to get notified when a handler starts and stops.
       This class is used in conjunction with a Tool type base class to
       create various tool types to attach to the handler.
    */
    class AttachPoint
    {
    public:
        AttachPoint() {}
        virtual ~AttachPoint() {}
 
        /**
           Function that will be called when a handler is registered
           with the tool implementing the attach point.  The metadata
           passed in will be dependent on what type of tool this is
           attached to.  The uintptr_t returned from this function
           will be passed into the beforeHandler() and afterHandler()
           functions.
 
           @param mdata Metadata to be passed into the tool
 
           @return Opaque key that will be passed back into
           beforeHandler() and afterHandler() to identify the source
           of the calls
        */
        virtual uintptr_t registerHandler(const AttachPointMetaData& mdata) = 0;
 
        /**
           Function to be called before the handler is called.
 
           @key uintptr_t returned from registerHandler() when handler
           was registered with the tool
 
           @arg argument that will be passed to the handler function.
           If argT is a pointer, this will be passed as a const
           pointer, if not, it will be passed as a const reference
        */
        virtual void beforeHandler(uintptr_t                                                             key,
            std::conditional_t<std::is_pointer_v<argT>, const std::remove_pointer_t<argT>*, const argT&> arg) = 0;
 
        /**
           Function to be called after the handler is called.  The key
           passed in is the uintptr_t returned from registerHandler()
 
           @param key uintptr_t returned from registerHandler() when
           handler was registered with the tool
        */
        virtual void afterHandler(uintptr_t key) = 0;
 
        /**
           Function that will be called to handle the key returned
           from registerHandler, if the AttachPoint tool is
           serializable.  This is needed because the key is opaque to
           the Link, so it doesn't know how to handle it during
           serialization.  During SIZE and PACK phases of
           serialization, the tool needs to store out any information
           that will be needed to recreate data that is reliant on the
           key.  On UNPACK, the function needs to recreate any state
           and reinitialize the passed in key reference to the proper
           state to continue to make valid calls to beforeHandler()
           and afterHandler().
 
           Since not all tools will be serializable, there is a
           default, empty implementation.
 
           @param ser Serializer to use for serialization
 
           @param key Key that would be passed into the
           beforeHandler() and afterHandler() functions.
         */
        virtual void serializeHandlerAttachPointKey(
            SST::Core::Serialization::serializer& UNUSED(ser), uintptr_t& UNUSED(key))
        {}
    };
 
 
    /**
       Attach Point to intercept the data being delivered by a
       Handler.  Class is not usable for Handlers that don't take a
       parameter and/or return a value
    */
    class InterceptPoint
    {
    public:
        /**
           Function that will be called when a handler is registered
           with the tool implementing the intercept attach point.  The
           metadata passed in will be dependent on what type of tool
           this is attached to.  The uintptr_t returned from this
           function will be passed into the intercept() function.
 
           @param mdata Metadata to be passed into the tool
 
           @return Opaque key that will be passed back into
           interceptHandler() calls
        */
        virtual uintptr_t registerHandlerIntercept(const AttachPointMetaData& mdata) = 0;
 
        /**
           Function that will be called before the event handler to
           let the attach point intercept the data.  The data can be
           modified, and if cancel is set to true, the handler will
           not be executed.  If cancel is set to true and the
           ownership of a pointer is passed by the call to the
           handler, then the function should also delete the data.
 
           @param key Key that was returned from
           registerHandlerIntercept() function
 
           @param data Data that is to be passed to the handler
 
           @param[out] cancel Set to true if the handler delivery
           should be canceled.
        */
        virtual void interceptHandler(uintptr_t key, argT& data, bool& cancel) = 0;
 
        /**
           Function that will be called to handle the key returned
           from registerHandlerIntercept, if the AttachPoint tool is
           serializable.  This is needed because the key is opaque to
           the Link, so it doesn't know how to handle it during
           serialization.  During SIZE and PACK phases of
           serialization, the tool needs to store out any information
           that will be needed to recreate data that is reliant on the
           key.  On UNPACK, the function needs to recreate any state
           and reinitialize the passed in key reference to the proper
           state to continue to make valid calls to
           interceptHandler().
 
           Since not all tools will be serializable, there is a
           default, empty implementation.
 
           @param ser Serializer to use for serialization
 
           @param key Key that would be passed into the interceptHandler() function.
         */
        virtual void serializeHandlerInterceptPointKey(
            SST::Core::Serialization::serializer& UNUSED(ser), uintptr_t& UNUSED(key))
        {}
 
        virtual ~InterceptPoint() = default;
    };
 
private:
    struct ToolList
    {
        std::vector<std::pair<AttachPoint*, uintptr_t>>    attach_tools;
        std::vector<std::pair<InterceptPoint*, uintptr_t>> intercept_tools;
    };
    ToolList* attached_tools = nullptr;
 
protected:
    // Implementation of operator() to be done in child classes
    virtual void operator_impl(argT) = 0;
 
    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        switch ( ser.mode() ) {
        case Core::Serialization::serializer::SIZER:
        case Core::Serialization::serializer::PACK:
        {
            ToolList tools;
            if ( attached_tools ) {
                for ( auto x : attached_tools->attach_tools ) {
                    if ( dynamic_cast<SST::Core::Serialization::serializable*>(x.first) ) {
                        tools.attach_tools.push_back(x);
                    }
                }
                for ( auto x : attached_tools->intercept_tools ) {
                    if ( dynamic_cast<SST::Core::Serialization::serializable*>(x.first) ) {
                        tools.intercept_tools.push_back(x);
                    }
                }
            }
 
            // Serialize AttachPoint tools
            size_t tool_count = tools.attach_tools.size();
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                // Serialize each tool, then call serializeEventAttachPointKey() to serialize any data associated with
                // the key
                for ( auto x : tools.attach_tools ) {
                    SST::Core::Serialization::serializable* obj =
                        dynamic_cast<SST::Core::Serialization::serializable*>(x.first);
                    SST_SER(obj);
                    x.first->serializeHandlerAttachPointKey(ser, x.second);
                }
            }
            // Serialize InterceptPoint tools
            tool_count = tools.intercept_tools.size();
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                // Serialize each tool, then call serializeEventAttachPointKey() to serialize any data associated with
                // the key
                for ( auto x : tools.intercept_tools ) {
                    SST::Core::Serialization::serializable* obj =
                        dynamic_cast<SST::Core::Serialization::serializable*>(x.first);
                    SST_SER(obj);
                    x.first->serializeHandlerInterceptPointKey(ser, x.second);
                }
            }
            break;
        }
        case Core::Serialization::serializer::UNPACK:
        {
            // Get serialized AttachPoint tools
            size_t tool_count;
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                attached_tools = new ToolList();
                for ( size_t i = 0; i < tool_count; ++i ) {
                    SST::Core::Serialization::serializable* tool;
                    uintptr_t                               key;
                    SST_SER(tool);
                    AttachPoint* ap = dynamic_cast<AttachPoint*>(tool);
                    ap->serializeHandlerAttachPointKey(ser, key);
                    attached_tools->attach_tools.emplace_back(ap, key);
                }
            }
            else {
                attached_tools = nullptr;
            }
 
            // Get serialized InterceptPoint tools
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                if ( nullptr == attached_tools ) attached_tools = new ToolList();
                for ( size_t i = 0; i < tool_count; ++i ) {
                    SST::Core::Serialization::serializable* tool;
                    uintptr_t                               key;
                    SST_SER(tool);
                    InterceptPoint* ip = dynamic_cast<InterceptPoint*>(tool);
                    ip->serializeHandlerInterceptPointKey(ser, key);
                    attached_tools->intercept_tools.emplace_back(ip, key);
                }
            }
            break;
        }
        default:
            break;
        }
    }
 
public:
    virtual ~SSTHandlerBase() {}
 
    inline void operator()(argT arg)
    {
        if ( !attached_tools ) return operator_impl(arg);
 
        // Tools attached
        for ( auto& x : attached_tools->attach_tools )
            x.first->beforeHandler(x.second, arg);
 
        // Check any intercepts
 
        bool cancel = false;
        for ( auto& x : attached_tools->intercept_tools ) {
            x.first->interceptHandler(x.second, arg, cancel);
            if ( cancel ) {
                // Handler canceled; need to break since arg may no longer be valid and no other intercepts should be
                // called
                break;
            }
        }
        if ( !cancel ) {
            operator_impl(arg);
        }
 
        for ( auto& x : attached_tools->attach_tools )
            x.first->afterHandler(x.second);
    }
 
 
    /**
       Attaches a tool to the AttachPoint
 
       @param tool Tool to attach
 
       @param mdata Metadata to pass to the tool
    */
    void attachTool(AttachPoint* tool, const AttachPointMetaData& mdata)
    {
        if ( !attached_tools ) attached_tools = new ToolList();
 
        auto key = tool->registerHandler(mdata);
        attached_tools->attach_tools.push_back(std::make_pair(tool, key));
    }
 
    /**
       Remove an attached tool
 
       @param tool Tool to remove.  If tool doesn't exist, then no
       action is taken
     */
    void detachTool(AttachPoint* tool)
    {
        if ( !attached_tools ) return;
 
        for ( auto x = attached_tools->attach_tools.begin(); x != attached_tools->attach_tools.end(); ++x ) {
            if ( x->first == tool ) {
                attached_tools->attach_tools.erase(x);
                break;
            }
        }
    }
 
    /**
       Attaches a tool to the AttachPoint
 
       @param tool Tool to attach
 
       @param mdata Metadata to pass to the tool
    */
    void attachInterceptTool(InterceptPoint* tool, const AttachPointMetaData& mdata)
    {
        if ( !attached_tools ) attached_tools = new ToolList();
 
        auto key = tool->registerHandlerIntercept(mdata);
        attached_tools->intercept_tools.push_back(std::make_pair(tool, key));
    }
 
    /**
       Remove an attached tool
 
       @param tool Tool to remove.  If tool doesn't exist, then no
       action is taken
     */
    void detachInterceptTool(InterceptPoint* tool)
    {
        if ( !attached_tools ) return;
 
        for ( auto x = attached_tools->intercept_tools.begin(); x != attached_tools->intercept_tools.end(); ++x ) {
            if ( x->first == tool ) {
                attached_tools->intercept_tools.erase(x);
                break;
            }
        }
    }
 
    /**
       Transfers attached tools from existing handler
     */
    void transferAttachedToolInfo(SSTHandlerBase* handler)
    {
        if ( handler->attached_tools ) {
            attached_tools          = handler->attached_tools;
            handler->attached_tools = nullptr;
        }
    }
 
private:
    ImplementVirtualSerializable(SSTHandlerBase)
};
 
 
/**
   Base template for handlers which don't take a class defined
   argument.
 
   This expansion covers the case of non-void return type. This
   version does not support intercepts.
*/
template <typename returnT>
class SSTHandlerBase<returnT, void> : public SST::Core::Serialization::serializable
{
public:
    /**
       Attach Point to get notified when a handler starts and stops.
       This class is used in conjunction with a Tool type base class to
       create various tool types to attach to the handler.
    */
    class AttachPoint
    {
    public:
        AttachPoint() {}
        virtual ~AttachPoint() {}
 
        /**
           Function that will be called when a handler is registered
           with the tool implementing the attach point.  The metadata
           passed in will be dependent on what type of tool this is
           attached to.  The uintptr_t returned from this function
           will be passed into the beforeHandler() and afterHandler()
           functions.
 
           @param mdata Metadata to be passed into the tool
 
           @return Opaque key that will be passed back into
           beforeHandler() and afterHandler() to identify the source
           of the calls
        */
        virtual uintptr_t registerHandler(const AttachPointMetaData& mdata) = 0;
 
        /**
           Function to be called before the handler is called.
 
           @key uintptr_t returned from registerHandler() when handler
           was registered with the tool
        */
        virtual void beforeHandler(uintptr_t key) = 0;
 
        /**
           Function to be called after the handler is called.  The key
           passed in is the uintptr_t returned from registerHandler()
 
           @param key uintptr_t returned from registerHandler() when
           handler was registered with the tool
 
           @param ret_value value that was returned by the handler. If
           retunT is a pointer, this will be passed as a const
           pointer, if not, it will be passed as a const reference
        */
        virtual void afterHandler(uintptr_t key,
            std::conditional_t<std::is_pointer_v<returnT>, const std::remove_pointer_t<returnT>*, const returnT&>
                ret_value) = 0;
 
        /**
           Function that will be called to handle the key returned
           from registerHandler, if the AttachPoint tool is
           serializable.  This is needed because the key is opaque to
           the Link, so it doesn't know how to handle it during
           serialization.  During SIZE and PACK phases of
           serialization, the tool needs to store out any information
           that will be needed to recreate data that is reliant on the
           key.  On UNPACK, the function needs to recreate any state
           and reinitialize the passed in key reference to the proper
           state to continue to make valid calls to beforeHandler()
           and afterHandler().
 
           Since not all tools will be serializable, there is a
           default, empty implementation.
 
           @param ser Serializer to use for serialization
 
           @param key Key that would be passed into the
           beforeHandler() and afterHandler() functions.
         */
        virtual void serializeHandlerAttachPointKey(
            SST::Core::Serialization::serializer& UNUSED(ser), uintptr_t& UNUSED(key))
        {}
    };
 
private:
    using ToolList           = std::vector<std::pair<AttachPoint*, uintptr_t>>;
    ToolList* attached_tools = nullptr;
 
protected:
    // Implementation of operator() to be done in child classes
    virtual returnT operator_impl() = 0;
 
    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        switch ( ser.mode() ) {
        case Core::Serialization::serializer::SIZER:
        case Core::Serialization::serializer::PACK:
        {
            ToolList tools;
            if ( attached_tools ) {
                for ( auto x : *attached_tools ) {
                    if ( dynamic_cast<SST::Core::Serialization::serializable*>(x.first) ) {
                        tools.push_back(x);
                    }
                }
            }
            size_t tool_count = tools.size();
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                // Serialize each tool, then call serializeEventAttachPointKey() to serialize any data associated with
                // the key
                for ( auto x : tools ) {
                    SST::Core::Serialization::serializable* obj =
                        dynamic_cast<SST::Core::Serialization::serializable*>(x.first);
                    SST_SER(obj);
                    x.first->serializeHandlerAttachPointKey(ser, x.second);
                }
            }
            break;
        }
        case Core::Serialization::serializer::UNPACK:
        {
            size_t tool_count;
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                attached_tools = new ToolList();
                for ( size_t i = 0; i < tool_count; ++i ) {
                    SST::Core::Serialization::serializable* tool;
                    uintptr_t                               key;
                    SST_SER(tool);
                    AttachPoint* ap = dynamic_cast<AttachPoint*>(tool);
                    ap->serializeHandlerAttachPointKey(ser, key);
                    attached_tools->emplace_back(ap, key);
                }
            }
            else {
                attached_tools = nullptr;
            }
            break;
        }
        default:
            break;
        }
    }
 
 
public:
    virtual ~SSTHandlerBase() {}
 
    inline returnT operator()()
    {
        if ( attached_tools ) {
            for ( auto& x : *attached_tools )
                x.first->beforeHandler(x.second);
 
            returnT ret = operator_impl();
 
            for ( auto& x : *attached_tools )
                x.first->afterHandler(x.second, ret);
 
            return ret;
        }
        return operator_impl();
    }
 
    /**
       Attaches a tool to the AttachPoint
 
       @param tool Tool to attach
 
       @param mdata Metadata to pass to the tool
    */
    void attachTool(AttachPoint* tool, const AttachPointMetaData& mdata)
    {
        if ( !attached_tools ) attached_tools = new ToolList();
 
        auto key = tool->registerHandler(mdata);
        attached_tools->push_back(std::make_pair(tool, key));
    }
 
    /**
       Remove an attached tool
 
       @param tool Tool to remove.  If tool doesn't exist, then no
       action is taken
     */
    void detachTool(AttachPoint* tool)
    {
        if ( !attached_tools ) return;
 
        for ( auto x = attached_tools->begin(); x != attached_tools->end(); ++x ) {
            if ( x->first == tool ) {
                attached_tools->erase(x);
                break;
            }
        }
    }
 
    /**
       Transfers attached tools from existing handler
     */
    void transferAttachedToolInfo(SSTHandlerBase* handler)
    {
        if ( handler->attached_tools ) {
            attached_tools          = handler->attached_tools;
            handler->attached_tools = nullptr;
        }
    }
 
private:
    ImplementVirtualSerializable(SSTHandlerBase)
};
 
 
/**
   Base template for handlers which don't take a class defined
   argument.
 
   This expansion covers the case of void return type. This version
   does not support intercepts.
*/
template <>
class SSTHandlerBase<void, void> : public SST::Core::Serialization::serializable
{
public:
    /**
       Attach Point to get notified when a handler starts and stops.
       This class is used in conjunction with a Tool type base class to
       create various tool types to attach to the handler.
    */
    class AttachPoint
    {
    public:
        AttachPoint() {}
        virtual ~AttachPoint() {}
 
        /**
           Function that will be called when a handler is registered
           with the tool implementing the attach point.  The metadata
           passed in will be dependent on what type of tool this is
           attached to.  The uintptr_t returned from this function
           will be passed into the beforeHandler() and afterHandler()
           functions.
 
           @param mdata Metadata to be passed into the tool
 
           @return Opaque key that will be passed back into
           beforeHandler() and afterHandler() to identify the source
           of the calls
        */
        virtual uintptr_t registerHandler(const AttachPointMetaData& mdata) = 0;
 
        /**
           Function to be called before the handler is called.
 
           @key uintptr_t returned from registerHandler() when handler
           was registered with the tool
        */
        virtual void beforeHandler(uintptr_t key) = 0;
 
        /**
           Function to be called after the handler is called.  The key
           passed in is the uintptr_t returned from registerHandler()
 
           @param key uintptr_t returned from registerHandler() when
           handler was registered with the tool
        */
        virtual void afterHandler(uintptr_t key) = 0;
 
        /**
           Function that will be called to handle the key returned
           from registerHandler, if the AttachPoint tool is
           serializable.  This is needed because the key is opaque to
           the Link, so it doesn't know how to handle it during
           serialization.  During SIZE and PACK phases of
           serialization, the tool needs to store out any information
           that will be needed to recreate data that is reliant on the
           key.  On UNPACK, the function needs to recreate any state
           and reinitialize the passed in key reference to the proper
           state to continue to make valid calls to beforeHandler()
           and afterHandler().
 
           Since not all tools will be serializable, there is a
           default, empty implementation.
 
           @param ser Serializer to use for serialization
 
           @param key Key that would be passed into the
           beforeHandler() and afterHandler() functions.
         */
        virtual void serializeHandlerAttachPointKey(
            SST::Core::Serialization::serializer& UNUSED(ser), uintptr_t& UNUSED(key))
        {}
    };
 
private:
    using ToolList           = std::vector<std::pair<AttachPoint*, uintptr_t>>;
    ToolList* attached_tools = nullptr;
 
protected:
    // Implementation of operator() to be done in child classes
    virtual void operator_impl() = 0;
 
    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        switch ( ser.mode() ) {
        case Core::Serialization::serializer::SIZER:
        case Core::Serialization::serializer::PACK:
        {
            ToolList tools;
            if ( attached_tools ) {
                for ( auto x : *attached_tools ) {
                    if ( dynamic_cast<SST::Core::Serialization::serializable*>(x.first) ) {
                        tools.push_back(x);
                    }
                }
            }
            size_t tool_count = tools.size();
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                // Serialize each tool, then call serializeEventAttachPointKey() to serialize any data associated with
                // the key
                for ( auto x : tools ) {
                    SST::Core::Serialization::serializable* obj =
                        dynamic_cast<SST::Core::Serialization::serializable*>(x.first);
                    SST_SER(obj);
                    x.first->serializeHandlerAttachPointKey(ser, x.second);
                }
            }
            break;
        }
        case Core::Serialization::serializer::UNPACK:
        {
            size_t tool_count;
            SST_SER(tool_count);
            if ( tool_count > 0 ) {
                attached_tools = new ToolList();
                for ( size_t i = 0; i < tool_count; ++i ) {
                    SST::Core::Serialization::serializable* tool;
                    uintptr_t                               key;
                    SST_SER(tool);
                    AttachPoint* ap = dynamic_cast<AttachPoint*>(tool);
                    ap->serializeHandlerAttachPointKey(ser, key);
                    attached_tools->emplace_back(ap, key);
                }
            }
            else {
                attached_tools = nullptr;
            }
            break;
        }
        default:
            break;
        }
    }
 
public:
    virtual ~SSTHandlerBase() {}
 
    inline void operator()()
    {
        if ( attached_tools ) {
            for ( auto& x : *attached_tools )
                x.first->beforeHandler(x.second);
 
            operator_impl();
 
            for ( auto& x : *attached_tools )
                x.first->afterHandler(x.second);
 
            return;
        }
        return operator_impl();
    }
 
    /**
       Attaches a tool to the AttachPoint
 
       @param tool Tool to attach
 
       @param mdata Metadata to pass to the tool
    */
    void attachTool(AttachPoint* tool, const AttachPointMetaData& mdata)
    {
        if ( !attached_tools ) attached_tools = new ToolList();
 
        auto key = tool->registerHandler(mdata);
        attached_tools->push_back(std::make_pair(tool, key));
    }
 
    /**
       Remove an attached tool
 
       @param tool Tool to remove.  If tool doesn't exist, then no
       action is taken
     */
    void detachTool(AttachPoint* tool)
    {
        if ( !attached_tools ) return;
 
        for ( auto x = attached_tools->begin(); x != attached_tools->end(); ++x ) {
            if ( x->first == tool ) {
                attached_tools->erase(x);
                break;
            }
        }
    }
 
    /**
       Transfers attached tools from existing handler
     */
    void transferAttachedToolInfo(SSTHandlerBase* handler)
    {
        if ( handler->attached_tools ) {
            attached_tools          = handler->attached_tools;
            handler->attached_tools = nullptr;
        }
    }
 
private:
    ImplementVirtualSerializable(SSTHandlerBase)
};
 
 
/**********************************************************************
 * New Style Handlers
 *
 * These handlers support checkpointing
 **********************************************************************/
 
/**
   Base template for the class.  If this one gets chosen, then there
   is a mismatch somewhere, so it will just static_assert
 */
template <typename returnT, typename argT, typename classT, typename dataT, auto funcT,
    typename parentT = SSTHandlerBase<returnT, argT>>
class SSTHandler : public parentT
{
    // This has to be dependent on a template parameter, otherwise it always asserts.
    static_assert((funcT, false), "Mismatched handler templates.");
};
 
 
/**
 * Handler class with user-data argument
 */
template <typename returnT, typename argT, typename classT, typename dataT, returnT (classT::*funcT)(argT, dataT),
    typename parentT>
class SSTHandler<returnT, argT, classT, dataT, funcT, parentT> : public parentT
{
    static_assert(std::is_base_of_v<SSTHandlerBase<returnT, argT>, parentT>,
        "Base class of SSTHandler must inherit from SSTBaseHandler<returnT,argT>");
 
private:
    classT* object = nullptr;
    dataT   data;
 
public:
    /** Constructor
     * @param object - Pointer to Object upon which to call the handler
     * @param data - Additional argument to pass to handler
     */
    SSTHandler(classT* const object, dataT data) :
        parentT(),
        object(object),
        data(data)
    {}
 
    SSTHandler() {}
 
    SSTHandler(const SSTHandler&)            = delete;
    SSTHandler& operator=(const SSTHandler&) = delete;
 
    returnT operator_impl(argT arg) override { return (object->*funcT)(arg, data); }
 
    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        parentT::serialize_order(ser);
        SST_SER(object);
        SST_SER(data);
    }
 
    ImplementSerializable(SSTHandler)
};
 
 
/**
 * Event Handler class with no user-data.
 */
template <typename returnT, typename argT, typename classT, returnT (classT::*funcT)(argT), typename parentT>
class SSTHandler<returnT, argT, classT, void, funcT, parentT> : public parentT
{
    static_assert(std::is_base_of_v<SSTHandlerBase<returnT, argT>, parentT>,
        "Base class of SSTHandler must inherit from SSTBaseHandler<returnT,argT>");
 
private:
    classT* object = nullptr;
 
public:
    /** Constructor
     * @param object - Pointer to Object upon which to call the handler
     * @param member - Member function to call as the handler
     */
    explicit SSTHandler(classT* const object) :
        parentT(),
        object(object)
    {}
    SSTHandler() {}
 
    SSTHandler(const SSTHandler&)            = delete;
    SSTHandler& operator=(const SSTHandler&) = delete;
 
    returnT operator_impl(argT arg) override { return (object->*funcT)(arg); }
 
    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        parentT::serialize_order(ser);
        SST_SER(object);
    }
 
    ImplementSerializable(SSTHandler)
};
 
 
/**
 * Event Handler class with user-data argument
 */
template <typename returnT, typename classT, typename dataT, returnT (classT::*funcT)(dataT), typename parentT>
class SSTHandler<returnT, void, classT, dataT, funcT, parentT> : public parentT
{
    static_assert(std::is_base_of_v<SSTHandlerBase<returnT, void>, parentT>,
        "Base class of SSTHandler must inherit from SSTBaseHandler<returnT,argT>");
 
private:
    classT* object = nullptr;
    dataT   data;
 
public:
    /** Constructor
     * @param object - Pointer to Object upon which to call the handler
     * @param data - Additional argument to pass to handler
     */
    SSTHandler(classT* const object, dataT data) :
        parentT(),
        object(object),
        data(data)
    {}
    SSTHandler() {}
 
    SSTHandler(const SSTHandler&)            = delete;
    SSTHandler& operator=(const SSTHandler&) = delete;
 
    returnT operator_impl() override { return (object->*funcT)(data); }
 
    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        parentT::serialize_order(ser);
        SST_SER(object);
        SST_SER(data);
    }
 
    ImplementSerializable(SSTHandler)
};
 
 
/**
 * Event Handler class with user-data argument
 */
template <typename returnT, typename classT, returnT (classT::*funcT)(), typename parentT>
class SSTHandler<returnT, void, classT, void, funcT, parentT> : public parentT
{
    static_assert(std::is_base_of_v<SSTHandlerBase<returnT, void>, parentT>,
        "Base class of SSTHandler must inherit from SSTBaseHandler<returnT,argT>");
 
private:
    classT* object = nullptr;
 
public:
    /** Constructor
     * @param object - Pointer to Object upon which to call the handler
     * @param data - Additional argument to pass to handler
     */
    explicit SSTHandler(classT* const object) :
        parentT(),
        object(object)
    {}
    SSTHandler() {}
 
    SSTHandler(const SSTHandler&)            = delete;
    SSTHandler& operator=(const SSTHandler&) = delete;
 
    returnT operator_impl() override { return (object->*funcT)(); }
 
    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        parentT::serialize_order(ser);
        SST_SER(object);
    }
 
    ImplementSerializable(SSTHandler)
};
 
} // namespace SST
 
#endif // SST_CORE_SSTHANDLER_H