amps-python-client 5.3.4.1__zip → 5.3.4.2__zip

amps-python-client-5.3.4.2/include/ampspy_recoverypointadapter.hpp

@@ -0,0 +1,52 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef _AMPSPY_RECOVERYPOINTADAPTER_HPP_
+#define _AMPSPY_RECOVERYPOINTADAPTER_HPP_
+
+#include <amps/ampsplusplus.hpp>
+
+namespace ampspy
+{
+  namespace recoverypointadapter
+  {
+    class wrapper : public AMPS::RecoveryPointAdapterImpl
+    {
+    public:
+      wrapper(PyObject* object_);
+      virtual ~wrapper(void);
+      bool next(AMPS::RecoveryPoint& current_);
+      void update(AMPS::RecoveryPoint& recoveryPoint_);
+      void purge(void);
+      void purge(const AMPS::Message::Field& subId_);
+      void close(void);
+      void prune(void);
+
+    protected:
+      PyObject* _pImpl;
+    };
+  }
+}
+
+#endif // _AMPSPY_RECOVERYPOINTADAPTER_HPP_

amps-python-client-5.3.4.2/include/ampspy_shims.hpp

@@ -0,0 +1,113 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include <Python.h>
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// ampspy::shims
+//
+// A very small dynamic loader/shim library so we can use non ABI3 python
+// functions but still be version-independent across 3.x versions. We're only
+// working around the ABI for a minimal set of functions:
+//
+// _Py_Finalizing/Py_IsFinalizing: Our client creates its own thread and
+//    calls Python code from it, and it also holds important resources.
+//    Before calling PyThreadState_Ensure(), we have to make sure the
+//    interpreter isn't shutting down, else PyThreadState_Ensure()
+//    will call pthread_exit() on us, which is unacceptable. (In Python 2.x
+//    we simulate this via a static that is set from an exitfunc).
+//
+// _PyThreadState_Current: If shutdown begins while we're holding the GIL,
+//    then calling PyGILState_Release() will crash shutdown. We have to
+//    have a way to detect if the GIL thinks it is still being held by us
+//    to safely release the GIL from a non-python thread.
+//
+// _PyUnicode_AsUTF8AndSize: This was added to ABI3 for 3.10; we need it
+//    in older Python 3 versions to get access to the internal utf-8 rep
+//    of strings a user passes to us.
+//
+// free(), type_name(): provides a unified interface to tp_free and
+//    tp_name since PyTypeObject is opaque under ABI3.
+//
+/////////////////////////////////////////////////////////////////////////////
+namespace ampspy
+{
+  namespace shims
+  {
+    extern const char* g_shimExitFuncName;
+    typedef bool (*Py_IsFinalizing_t)(void);
+    typedef const char* (*PyUnicode_AsUTF8AndSize_t)(PyObject*, Py_ssize_t*);
+    typedef PyThreadState* (*PyThreadState_UncheckedGet_t)(void);
+
+    extern Py_IsFinalizing_t Py_IsFinalizing;
+    extern PyUnicode_AsUTF8AndSize_t PyUnicode_AsUTF8AndSize;
+    extern PyThreadState_UncheckedGet_t PyThreadState_UncheckedGet;
+
+    bool init(PyObject* module_);
+    PyObject* _shimExitFunc(void);
+
+    inline void free(void* pObject_)
+    {
+      PyObject* pObject = (PyObject*)pObject_;
+      if (pObject)
+      {
+#if PY_MAJOR_VERSION < 3
+        Py_TYPE(pObject)->tp_free(pObject);
+#else
+        ((freefunc)PyType_GetSlot((PyTypeObject*)PyObject_Type(pObject), Py_tp_free))(pObject);
+#endif
+      }
+    }
+    inline const char* type_name(PyTypeObject* pyTypeObject_)
+    {
+      if (pyTypeObject_)
+      {
+#if PY_MAJOR_VERSION < 3
+        return pyTypeObject_->tp_name;
+#else
+        Py_ssize_t ignored = 0;
+        PyObject* name = PyObject_GetAttrString((PyObject*)pyTypeObject_, "__name__");
+        const char* result = PyUnicode_AsUTF8AndSize(name, &ignored);
+        Py_XDECREF(name);
+
+        return result;
+#endif
+      }
+      return NULL;
+    }
+
+#if PY_MAJOR_VERSION >= 3
+    inline const char* PyUnicode_AsUTF8(PyObject* pyObject_)
+    {
+      Py_ssize_t unused = 0;
+      return ampspy::shims::PyUnicode_AsUTF8AndSize(pyObject_, &unused);
+    }
+#endif
+
+  }
+
+}

amps-python-client-5.3.4.2/include/ampspy_type_object.hpp

@@ -0,0 +1,242 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include <Python.h>
+
+#if defined(AMPS_SHARED) && defined(_WIN32)
+  #ifdef AMPS_BUILD
+    #ifndef AMPSDLL
+      #define AMPSDLL __declspec(dllexport)
+    #endif
+    #define AMPSDLL_EXTERN extern __declspec(dllexport)
+  #else
+    #ifndef AMPSDLL
+      #define AMPSDLL __declspec(dllimport)
+    #endif
+    #define AMPSDLL_EXTERN extern __declspec(dllimport)
+  #endif
+#else
+  #ifndef AMPSDLL
+    #define AMPSDLL
+  #endif
+  #define AMPSDLL_EXTERN extern
+#endif
+
+namespace ampspy
+{
+  // A Python 2.x/3.x wrapper for creating a new type object, using the "limited api"
+  // in 3.x and using a static PyTypeObject in 2.x.
+
+  class ampspy_type_object_impl;
+  class AMPSDLL ampspy_type_object
+  {
+  public:
+    ampspy_type_object(void);
+    ~ampspy_type_object(void);
+
+    ampspy_type_object(const ampspy_type_object&) = delete;
+    ampspy_type_object& operator=(const ampspy_type_object&) = delete;
+
+    // Finish creating the type
+    ampspy_type_object& createType(void);
+    // Register this type with the given module
+    ampspy_type_object& registerType(const char*, PyObject*);
+
+    // Return the type object ready to be added to a containing module/object.
+    PyTypeObject* pPyTypeObject(void) const;
+    PyObject* pPyObject(void) const;
+
+    operator PyTypeObject* (void) const
+    {
+      return pPyTypeObject();
+    }
+
+    operator PyObject* (void) const
+    {
+      return pPyObject();
+    }
+
+
+    ampspy_type_object& setName(const char*);
+    ampspy_type_object& setBase(const ampspy_type_object&);
+    ampspy_type_object& setBasicSize(size_t);
+    ampspy_type_object& setHaveGC(void);
+    ampspy_type_object& setBaseType(void);
+
+    ampspy_type_object& setConstructorFunction(void*);
+    template <class T>
+    ampspy_type_object& setConstructorFunction(T* function_)
+    {
+      return setConstructorFunction((void*)function_);
+    }
+    ampspy_type_object& setDestructorFunction(void*);
+    template <class T>
+    ampspy_type_object& setDestructorFunction(T* function_)
+    {
+      return setDestructorFunction((void*)function_);
+    }
+    ampspy_type_object& setCallFunction(void*);
+    template <class T>
+    ampspy_type_object& setCallFunction(T* function_)
+    {
+      return setCallFunction((void*)function_);
+    }
+    ampspy_type_object& setDoc(const char*);
+    ampspy_type_object& setTraverseFunction(void*);
+    template <class T>
+    ampspy_type_object& setTraverseFunction(T* function_)
+    {
+      return setTraverseFunction((void*)function_);
+    }
+    ampspy_type_object& setClearFunction(void*);
+    template <class T>
+    ampspy_type_object& setClearFunction(T* function_)
+    {
+      return setClearFunction((void*)function_);
+    }
+
+    ampspy_type_object& setCompareFunction(void*);
+    template <class T>
+    ampspy_type_object& setCompareFunction(T* function_)
+    {
+      return setCompareFunction((void*)function_);
+    }
+
+    ampspy_type_object& setStrFunction(void*);
+    template <class T>
+    ampspy_type_object& setStrFunction(T* function_)
+    {
+      return setStrFunction((void*)function_);
+    }
+
+    ampspy_type_object& setReprFunction(void*);
+    template <class T>
+    ampspy_type_object& setReprFunction(T* function_)
+    {
+      return setReprFunction((void*)function_);
+    }
+
+    // Takes care of setting the Py_TPFLAGS_HAVE_RICHCOMPARE for you too.
+    ampspy_type_object& setRichCompareFunction(void*);
+    template <class T>
+    ampspy_type_object& setRichCompareFunction(T* function_)
+    {
+      return setRichCompareFunction((void*)function_);
+    }
+
+    ampspy_type_object& setWeakListOffset(size_t);
+
+    ampspy_type_object& setIterFunction(void*);
+    template <class T>
+    ampspy_type_object& setIterFunction(T* function_)
+    {
+      return setIterFunction((void*)function_);
+    }
+
+    ampspy_type_object& setIterNextFunction(void*);
+    template <class T>
+    ampspy_type_object& setIterNextFunction(T* function_)
+    {
+      return setIterNextFunction((void*)function_);
+    }
+
+    ampspy_type_object& addMethod(const char* name_,
+                                  void*       function_,
+                                  const char* doc_);
+
+    template <class T>
+    ampspy_type_object& addMethod(const char* name_,
+                                  T*          function_,
+                                  const char* doc_)
+    {
+      return addMethod(name_, (void*)function_, doc_);
+    }
+
+    ampspy_type_object& addStaticMethod(const char* name_,
+                                        void*       function_,
+                                        const char* doc_);
+
+    template <class T>
+    ampspy_type_object& addStaticMethod(const char* name_,
+                                        T*          function_,
+                                        const char* doc_)
+    {
+      return addStaticMethod(name_, (void*)function_, doc_);
+    }
+
+    ampspy_type_object& addKeywordMethod(const char* name_,
+                                         void*       function_,
+                                         const char* doc_);
+    template <class T>
+    ampspy_type_object& addKeywordMethod(const char* name_,
+                                         T*          function_,
+                                         const char* doc_)
+    {
+      return addKeywordMethod(name_, (void*)function_, doc_);
+    }
+
+    ampspy_type_object& notCopyable(void);
+    // Read-only members
+    ampspy_type_object& addMember(const char* name_,
+                                  size_t      value_);
+    ampspy_type_object& addMember(const char* name_,
+                                  const char* value_);
+
+    ampspy_type_object& addGetter(const char* name_,
+                                  void*       function_,
+                                  const char* doc_);
+    ampspy_type_object& addGetterSetter(const char* name_,
+                                        void*       getter_,
+                                        void*       setter_,
+                                        const char* getterDoc_,
+                                        const char* setterDoc_);
+    template <class T, class U>
+    ampspy_type_object& addGetterSetter(const char* name_,
+                                        T*          getter_,
+                                        U*          setter_,
+                                        const char* getterDoc_,
+                                        const char* setterDoc_)
+    {
+      return addGetterSetter(name_, (void*)getter_, (void*) setter_,
+                             getterDoc_, setterDoc_);
+    }
+
+    ampspy_type_object& addStatic(const char* name_, PyObject* value_);
+
+    bool isInstanceOf(PyObject* pPyObject)
+    {
+      if (!pPyObject || !pPyObject->ob_type)
+      {
+        return false;
+      }
+      return pPyObject->ob_type == pPyTypeObject();
+    }
+
+  protected:
+    ampspy_type_object_impl* _pImpl;
+  }; // class ampspy_type_object
+}
+