cxFunction.h

Go to the documentation of this file.

// Copyright (c) 2026 E. Oulashin
#ifndef __CXFUNCTION_H__
#define __CXFUNCTION_H__
 
/*
 * cxFunction.h - function
 *
 * Copyright (C) 2005-2007 Michael H. Kinney
 *
 *
 */
 
#include <string>
#include <memory>
 
namespace cx {
 
// Typedefs for various function pointer types
typedef std::string (*funcPtr0)();
typedef std::string (*funcPtr2)(void *p1, void *p2);
typedef std::string (*funcPtr4)(void *p1, void *p2, void *p3, void *p4);
 
class cxFunction
{
   public:
      cxFunction(bool pUseReturnVal, bool pExitAfterRun, bool pRunOnLeaveFunction);
 
      virtual ~cxFunction();
 
      virtual bool functionIsSet() const = 0;
 
      virtual std::string runFunction() const = 0;
 
      virtual void* getFuncPtr() const = 0;
 
      virtual bool getUseReturnVal() const;
 
      virtual void setUseReturnVal(bool pUseReturnVal);
 
      virtual bool getExitAfterRun() const;
 
      virtual void setExitAfterRun(bool pExitAfterRun);
 
      virtual bool getRunOnLeaveFunction() const;
 
      virtual void setRunOnLeaveFunction(bool pRunOnLeaveFunction);
 
      virtual std::string cxTypeStr() const = 0;
 
   private:
      bool mUseReturnVal;
      bool mExitAfterRun;
      bool mRunOnLeaveFunction;
}; // end of class cxFunction
 
class cxFunction0 : public cxFunction
{
   public:
      explicit cxFunction0(funcPtr0 pFuncPtr = nullptr, bool pUseReturnVal = false,
                           bool pExitAfterRun = false,
                           bool pRunOnLeaveFunction = true);
 
      virtual ~cxFunction0();
 
      virtual bool functionIsSet() const override;
 
      void setFunction(funcPtr0 pFuncPtr);
 
      funcPtr0 getFunction() const;
 
      virtual std::string runFunction() const override;
 
      virtual void* getFuncPtr() const override;
 
      virtual std::string cxTypeStr() const override;
 
   private:
      funcPtr0 mFunction; // This is the actual function pointer
}; // end of class cxFunction2
 
class cxFunction2 : public cxFunction
{
   public:
      explicit cxFunction2(funcPtr2 pFuncPtr = nullptr, void *pParam1 = nullptr,
                           void *pParam2 = nullptr, bool pUseReturnVal = false,
                           bool pExitAfterRun = false,
                           bool pRunOnLeaveFunction = true);
 
      virtual ~cxFunction2();
 
      virtual bool functionIsSet() const override;
 
      void setFunction(funcPtr2 pFuncPtr);
 
      funcPtr2 getFunction() const;
 
      void setParams(void *pParam1, void *pParam2);
 
      void setParam1(void *pParam);
 
      void setParam2(void *pParam);
 
      void* getParam1() const;
 
      void* getParam2() const;
 
      virtual std::string runFunction() const override;
 
      virtual void* getFuncPtr() const override;
 
      virtual std::string cxTypeStr() const override;
 
   private:
      funcPtr2 mFunction; // The actual function pointer
      void *mParam1;  // The first parameter to pass to the function
      void *mParam2;  // The second parameter to pass to the function
}; // end of class cxFunction2
 
class cxFunction4 : public cxFunction
{
   public:
      explicit cxFunction4(funcPtr4 pFuncPtr = nullptr, void *pParam1 = nullptr,
                           void *pParam2 = nullptr, void *pParam3 = nullptr,
                           void *pParam4 = nullptr, bool pUseReturnVal = false,
                           bool pExitAfterRun = false,
                           bool pRunOnLeaveFunction = true);
 
      virtual ~cxFunction4();
 
      virtual bool functionIsSet() const override;
 
      void setFunction(funcPtr4 pFuncPtr);
 
      funcPtr4 getFunction() const;
 
      void setParams(void *pParam1, void *pParam2, void *pParam3, void *pParam4);
 
      void setParam1(void *pParam);
 
      void setParam2(void *pParam);
 
      void setParam3(void *pParam);
 
      void setParam4(void *pParam);
 
      void* getParam1() const;
 
      void* getParam2() const;
 
      void* getParam3() const;
 
      void* getParam4() const;
 
      virtual std::string runFunction() const override;
 
      virtual void* getFuncPtr() const override;
 
      virtual std::string cxTypeStr() const override;
 
   private:
      funcPtr4 mFunction; // The actual function pointer
      void *mParam1;  // The first parameter to pass to the function
      void *mParam2;  // The second parameter to pass to the function
      void *mParam3;  // The 3rd parameter to pass to the function
      void *mParam4;  // The 4th parameter to pass to the function
};
 
template<typename T1, typename T2>
class cxFunction2Templated : public cxFunction
{
   public:
      using FuncPtr = std::string (*)(T1 *, T2 *);
 
      static std::shared_ptr<cxFunction2Templated<T1, T2>> create(FuncPtr pFuncPtr, T1 *pParam1, T2 *pParam2,
                                      bool pUseReturnVal = false, bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
                                      {
         return std::make_shared<cxFunction2Templated<T1, T2>>(pFuncPtr, pParam1, pParam2,
                                      pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction);
      }
 
       explicit cxFunction2Templated(FuncPtr pFuncPtr = nullptr, T1 *pParam1 = nullptr,
                                      T2 *pParam2 = nullptr, bool pUseReturnVal = false,
                                      bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
           : cxFunction(pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction),
             mFunction(pFuncPtr),
             mParam1(pParam1),
             mParam2(pParam2)
        {
        }
 
      virtual ~cxFunction2Templated() { }
 
      virtual bool functionIsSet() const override
      {
         return (mFunction != nullptr);
      }
 
      void setFunction(FuncPtr pFuncPtr)
      {
         mFunction = pFuncPtr;
      }
 
      FuncPtr getFunction() const
      {
         return mFunction;
      }
 
      void setParams(T1 *pParam1, T2 *pParam2)
      {
         mParam1 = pParam1;
         mParam2 = pParam2;
      }
 
      void setParam1(T1 *pParam)
      {
         mParam1 = pParam;
      }
 
      void setParam2(T2 *pParam)
      {
         mParam2 = pParam;
      }
 
      T1* getParam1() const
      {
         return mParam1;
      }
 
      T2* getParam2() const
      {
         return mParam2;
      }
 
      virtual std::string runFunction() const override
      {
         if (mFunction != nullptr)
         {
            return(mFunction(mParam1, mParam2));
         }
         else
         {
            return("");
         }
      }
 
      virtual void* getFuncPtr() const override
      {
         return (void*)mFunction;
      }
 
      virtual std::string cxTypeStr() const override
      {
         return("cxFunction2Templated");
      }
 
   private:
      FuncPtr mFunction; // The actual function pointer
      T1 *mParam1;  // The first parameter to pass to the function
      T2 *mParam2;  // The second parameter to pass to the function
};
 
template<typename T1>
class cxFunction1RefTemplated : public cxFunction
{
   public:
      using FuncPtr = std::string (*)(T1&);
 
      static std::shared_ptr<cxFunction1RefTemplated<T1>> create(FuncPtr pFuncPtr, T1& pParam1,
                                      bool pUseReturnVal = false, bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
                                      {
         return std::make_shared<cxFunction1RefTemplated<T1>>(pFuncPtr, pParam1,
                                      pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction);
      }
 
       explicit cxFunction1RefTemplated(FuncPtr pFuncPtr, T1& pParam,
                                      bool pUseReturnVal = false,
                                      bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
           : cxFunction(pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction),
             mFunction(pFuncPtr),
             mParam(pParam)
        {
        }
 
      virtual ~cxFunction1RefTemplated() { }
 
      virtual bool functionIsSet() const override
      {
         return (mFunction != nullptr);
      }
 
      void setFunction(FuncPtr pFuncPtr)
      {
         mFunction = pFuncPtr;
      }
 
      FuncPtr getFunction() const
      {
         return mFunction;
      }
 
      void setParam(T1& pParam)
      {
         mParam = pParam;
      }
 
      const T1& getParam() const
      {
         return mParam;
      }
 
      virtual std::string runFunction() const override
      {
         if (mFunction != nullptr)
         {
            return(mFunction(mParam));
         }
         else
         {
            return("");
         }
      }
 
      virtual void* getFuncPtr() const override
      {
         return (void*)mFunction;
      }
 
      virtual std::string cxTypeStr() const override
      {
         return("cxFunction1RefTemplated");
      }
 
   private:
      FuncPtr mFunction; // The actual function pointer
      T1& mParam;  // The parameter to pass to the function
};
 
 
template<typename T1, typename T2>
class cxFunction2RefTemplated : public cxFunction
{
   public:
      using FuncPtr = std::string (*)(T1&, T2&);
 
      static std::shared_ptr<cxFunction2RefTemplated<T1, T2>> create(FuncPtr pFuncPtr, T1& pParam1, T2& pParam2,
                                      bool pUseReturnVal = false, bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
                                      {
         return std::make_shared<cxFunction2RefTemplated<T1, T2>>(pFuncPtr, pParam1, pParam2,
                                      pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction);
      }
 
       explicit cxFunction2RefTemplated(FuncPtr pFuncPtr, T1& pParam1,
                                      T2 &pParam2, bool pUseReturnVal = false,
                                      bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
           : cxFunction(pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction),
             mFunction(pFuncPtr),
             mParam1(pParam1),
             mParam2(pParam2)
        {
        }
 
      virtual ~cxFunction2RefTemplated() { }
 
      virtual bool functionIsSet() const override
      {
         return (mFunction != nullptr);
      }
 
      void setFunction(FuncPtr pFuncPtr)
      {
         mFunction = pFuncPtr;
      }
 
      FuncPtr getFunction() const
      {
         return mFunction;
      }
 
      void setParams(T1& pParam1, T2& pParam2)
      {
         mParam1 = pParam1;
         mParam2 = pParam2;
      }
 
      void setParam1(T1& pParam)
      {
         mParam1 = pParam;
      }
 
      void setParam2(T2 &pParam)
      {
         mParam2 = pParam;
      }
 
      const T1& getParam1() const
      {
         return mParam1;
      }
 
      const T2& getParam2() const
      {
         return mParam2;
      }
 
      virtual std::string runFunction() const override
      {
         if (mFunction != nullptr)
         {
            return(mFunction(mParam1, mParam2));
         }
         else
         {
            return("");
         }
      }
 
      virtual void* getFuncPtr() const override
      {
         return (void*)mFunction;
      }
 
      virtual std::string cxTypeStr() const override
      {
         return("cxFunction2RefTemplated");
      }
 
   private:
      FuncPtr mFunction; // The actual function pointer
      T1& mParam1;  // The first parameter to pass to the function
      T2& mParam2;  // The second parameter to pass to the function
};
 
template<typename T1, typename T2, typename T3>
class cxFunction3RefTemplated : public cxFunction
{
   public:
      using FuncPtr = std::string (*)(T1&, T2&, T3&);
 
      static std::shared_ptr<cxFunction3RefTemplated<T1, T2, T3>> create(FuncPtr pFuncPtr, T1& pParam1, T2& pParam2, T3& pParam3,
                                      bool pUseReturnVal = false, bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
                                      {
         return std::make_shared<cxFunction3RefTemplated<T1, T2, T3>>(pFuncPtr, pParam1, pParam2, pParam3,
                                      pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction);
      }
 
       explicit cxFunction3RefTemplated(FuncPtr pFuncPtr, T1& pParam1,
                                      T2& pParam2, T3& pParam3,
                                      bool pUseReturnVal = false,
                                      bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
           : cxFunction(pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction),
             mFunction(pFuncPtr),
             mParam1(pParam1),
             mParam2(pParam2),
             mParam3(pParam3)
        {
        }
 
      virtual ~cxFunction3RefTemplated() { }
 
      virtual bool functionIsSet() const override
      {
         return (mFunction != nullptr);
      }
 
      void setFunction(FuncPtr pFuncPtr)
      {
         mFunction = pFuncPtr;
      }
 
      FuncPtr getFunction() const
      {
         return mFunction;
      }
 
      void setParams(T1& pParam1, T2& pParam2, T3& pParam3)
      {
         mParam1 = pParam1;
         mParam2 = pParam2;
         mParam3 = pParam3;
      }
 
      void setParam1(T1& pParam)
      {
         mParam1 = pParam;
      }
 
      void setParam2(T2& pParam)
      {
         mParam2 = pParam;
      }
 
      void setParam2(T3& pParam)
      {
         mParam3 = pParam;
      }
 
      const T1& getParam1() const
      {
         return mParam1;
      }
 
      const T2& getParam2() const
      {
         return mParam2;
      }
 
      const T3& getParam3() const
      {
         return mParam3;
      }
 
      virtual std::string runFunction() const override
      {
         if (mFunction != nullptr)
         {
            return(mFunction(mParam1, mParam2));
         }
         else
         {
            return("");
         }
      }
 
      virtual void* getFuncPtr() const override
      {
         return (void*)mFunction;
      }
 
      virtual std::string cxTypeStr() const override
      {
         return("cxFunction3RefTemplated");
      }
 
   private:
      FuncPtr mFunction; // The actual function pointer
      T1& mParam1;  // The first parameter to pass to the function
      T2& mParam2;  // The second parameter to pass to the function
      T3& mParam3;  // The third parameter to pass to the function
};
 
template<typename T1, typename T2, typename T3, typename T4>
class cxFunction4Templated : public cxFunction
{
   public:
      using FuncPtr = std::string (*)(T1 *, T2 *, T3 *, T4 *);
 
      static std::shared_ptr<cxFunction4Templated<T1, T2, T3, T4>> create(FuncPtr pFuncPtr, T1 *pParam1, T2 *pParam2,
                                      T3 *pParam3, T4 *pParam4, bool pUseReturnVal = false,
                                      bool pExitAfterRun = false, bool pRunOnLeaveFunction = true)
                                      {
         return std::make_shared<cxFunction4Templated<T1, T2, T3, T4>>(pFuncPtr, pParam1, pParam2,
                                      pParam3, pParam4, pUseReturnVal, pExitAfterRun,
                                      pRunOnLeaveFunction);
      }
 
       explicit cxFunction4Templated(FuncPtr pFuncPtr = nullptr, T1 *pParam1 = nullptr,
                                      T2 *pParam2 = nullptr, T3 *pParam3 = nullptr,
                                      T4 *pParam4 = nullptr, bool pUseReturnVal = false,
                                      bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
           : cxFunction(pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction),
             mFunction(pFuncPtr),
             mParam1(pParam1),
             mParam2(pParam2),
             mParam3(pParam3),
             mParam4(pParam4)
        {
        }
 
      virtual ~cxFunction4Templated() { }
 
      virtual bool functionIsSet() const override
      {
         return (mFunction != nullptr);
      }
 
      void setFunction(FuncPtr pFuncPtr)
      {
         mFunction = pFuncPtr;
      }
 
      FuncPtr getFunction() const
      {
         return mFunction;
      }
 
      void setParams(T1 *pParam1, T2 *pParam2, T3 *pParam3, T4 *pParam4)
      {
         mParam1 = pParam1;
         mParam2 = pParam2;
         mParam3 = pParam3;
         mParam4 = pParam4;
      }
 
      void setParam1(T1 *pParam)
      {
         mParam1 = pParam;
      }
 
      void setParam2(T2 *pParam)
      {
         mParam2 = pParam;
      }
 
      void setParam3(T3 *pParam)
      {
         mParam3 = pParam;
      }
 
      void setParam4(T4 *pParam)
      {
         mParam4 = pParam;
      }
 
      T1* getParam1() const
      {
         return mParam1;
      }
 
      T2* getParam2() const
      {
         return mParam2;
      }
 
      T3* getParam3() const
      {
         return mParam3;
      }
 
      T4* getParam4() const
      {
         return mParam4;
      }
 
      virtual std::string runFunction() const override
      {
         if (mFunction != nullptr)
         {
            return(mFunction(mParam1, mParam2, mParam3, mParam4));
         }
         else
         {
            return("");
         }
      }
 
      virtual void* getFuncPtr() const override
      {
         return (void*)mFunction;
      }
 
      virtual std::string cxTypeStr() const override
      {
         return("cxFunction4Templated");
      }
 
   private:
      FuncPtr mFunction; // The actual function pointer
      T1 *mParam1;  // The first parameter to pass to the function
      T2 *mParam2;  // The second parameter to pass to the function
      T3 *mParam3;  // The 3rd parameter to pass to the function
      T4 *mParam4;  // The 4th parameter to pass to the function
};
 
template<typename T1, typename T2, typename T3, typename T4>
class cxFunction4RefTemplated : public cxFunction
{
   public:
      using FuncPtr = std::string (*)(T1&, T2&, T3&, T4&);
 
      static std::shared_ptr<cxFunction4RefTemplated<T1, T2, T3, T4>> create(FuncPtr pFuncPtr, T1& pParam1, T2& pParam2,
                                      T3& pParam3, T4& pParam4, bool pUseReturnVal = false,
                                      bool pExitAfterRun = false, bool pRunOnLeaveFunction = true)
                                      {
         return std::make_shared<cxFunction4RefTemplated<T1, T2, T3, T4>>(pFuncPtr, pParam1, pParam2,
                                      pParam3, pParam4, pUseReturnVal, pExitAfterRun,
                                      pRunOnLeaveFunction);
      }
 
       explicit cxFunction4RefTemplated(FuncPtr pFuncPtr, T1& pParam1,
                                      T2& pParam2, T3& pParam3, T4& pParam4,
                                      bool pUseReturnVal = false,
                                      bool pExitAfterRun = false,
                                      bool pRunOnLeaveFunction = true)
           : cxFunction(pUseReturnVal, pExitAfterRun, pRunOnLeaveFunction),
             mFunction(pFuncPtr),
             mParam1(pParam1),
             mParam2(pParam2),
             mParam3(pParam3),
             mParam4(pParam4)
        {
        }
 
      virtual ~cxFunction4RefTemplated() { }
 
      virtual bool functionIsSet() const override
      {
         return (mFunction != nullptr);
      }
 
      void setFunction(FuncPtr pFuncPtr)
      {
         mFunction = pFuncPtr;
      }
 
      FuncPtr getFunction() const
      {
         return mFunction;
      }
 
      void setParams(T1& pParam1, T2& pParam2, T3& pParam3, T4& pParam4)
      {
         mParam1 = pParam1;
         mParam2 = pParam2;
         mParam3 = pParam3;
         mParam4 = pParam4;
      }
 
      void setParam1(T1& pParam)
      {
         mParam1 = pParam;
      }
 
      void setParam2(T2& pParam)
      {
         mParam2 = pParam;
      }
 
      void setParam3(T3& pParam)
      {
         mParam3 = pParam;
      }
 
      void setParam4(T4& pParam)
      {
         mParam4 = pParam;
      }
 
      const T1& getParam1() const
      {
         return mParam1;
      }
 
      const T2& getParam2() const
      {
         return mParam2;
      }
 
      const T3& getParam3() const
      {
         return mParam3;
      }
 
      const T4& getParam4() const
      {
         return mParam4;
      }
 
      virtual std::string runFunction() const override
      {
         if (mFunction != nullptr)
         {
            return(mFunction(mParam1, mParam2, mParam3, mParam4));
         }
         else
         {
            return("");
         }
      }
 
      virtual void* getFuncPtr() const override
      {
         return (void*)mFunction;
      }
 
      virtual std::string cxTypeStr() const override
      {
         return("cxFunction4RefTemplated");
      }
 
   private:
      FuncPtr mFunction; // The actual function pointer
      T1& mParam1;  // The first parameter to pass to the function
      T2& mParam2;  // The second parameter to pass to the function
      T3& mParam3;  // The third parameter to pass to the function
      T4& mParam4;  // The fourth parameter to pass to the function
};
 
} // namespace cx
 
#endif