decl_context.hpp

#pragma once
 
#include "../../string.hpp"
#include "../../utilities/system_info.hpp"
 
#include "../py_script.hpp"
 
#include <memory>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<PyScript::Context>::HandleGuard(void *handle) noexcept
      : HandleGuard<PyScript::Context>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace PyScript
  {

    class Context final : public std::enable_shared_from_this<Context>
    {
 
      struct PrivateTag
      {
      };
 
    public:
      /*
       *  \return A pointer to the context.
       *
       * The context automatically attaches to the interpreter found on the command line.
       * This may be a system package or pyenv. If a virtual environment is activated,
       * the context will try to attach to this environment, and falls back to the base python
       * if there is an error.
       *
       * On Linux systems a shared object (libpython3.x.so) must be available.
       */
      static ContextPtr CreateOrGet()
      {
        static ContextPtr context = std::make_shared<Context>(PrivateTag{});
        return context;
      }
 
      explicit Context(PrivateTag)
          : handle_(nullptr)
      {
        CExports::CVPYSCONTEXT context = nullptr;
        CVB_CALL_CAPI_CHECKED(CVPYSCreateOrGetContext(
            *reinterpret_cast<CExports::CVPYSInterpreterVersion *>(&interpreterVersion_), context));
        handle_ = Cvb::HandleGuard<Context>(context);
      }
 
      Context(const Context &other)            = delete;
      Context &operator=(const Context &other) = delete;
      Context(Context &&other)                 = delete;
      Context &operator=(Context &&other)      = delete;
      ~Context()                               = default;

      /*
       *  \param [in] fileName The file name to use for the evaluated code.
       *  \param [in] code The code to compile and evaluate.
       *  \return A pointer to a code object - usually not needed.
       *
       * Function and type objects from the evaluated code are available
       * as items from this context.
       */
      ObjectPtr Eval(const Cvb::String &fileName, const Cvb::String &code);

      /*
       *  \param [in] moduleName The module name.
       *  \return A pointer to a module object .
       *
       * Function and type objects from the module code are available
       * as attributes from returned module object.
       */
      ObjectPtr Import(const Cvb::String &moduleName);

      /*
       *  \param [in] itemName The item name.
       *  \return A pointer to an object.
       *
       * Use this for function and type objects from evaluated code.
       */
      ObjectPtr Item(const Cvb::String &itemName);

      /*
       *  \param [in] path Additional items in the python path (sys.path).
       *
       */
      void AppendToSysPath(const Cvb::String &path)
      {
        CVB_CALL_CAPI(CVPYSContextSysPathAppendTyped(Handle(), path.c_str()));
      }

      /*
       *  \return The interpreter version in use.
       *
       */
      struct InterpreterVersion InterpreterVersion() const noexcept
      {
        return interpreterVersion_;
      }


      void *Handle() const noexcept
      {
        return handle_.Handle();
      }
 
    private:
      HandleGuard<Context> handle_;
 
      struct InterpreterVersion interpreterVersion_ = {};
    };
  }  // namespace PyScript
 
  CVB_END_INLINE_NS
}  // namespace Cvb