core.hpp

Go to the documentation of this file.

// Copyright (c) 2026 Capgemini Engineering Research and Development.
//
// This file is part of OCCT-Light software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Affero General Public License version 3 as published
// by the Free Software Foundation, with an option to use any later version.
// Consult the file LICENSE_AGPL_30.txt included in OCCT-Light distribution
// for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of a commercial
// license or contractual agreement.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef OCCTL_HPP_CORE_HPP
#define OCCTL_HPP_CORE_HPP
 
#include <occtl/occtl_core.h>
 
#include <cstdint>
#include <stdexcept>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
 
namespace occtl
{
 
class Error : public std::runtime_error
{
public:
  static Error from_last(const ::occtl_status_t theFallback) noexcept
  {
    const ::occtl_error_t* anErr = ::occtl_error_last();
    if (anErr != nullptr && anErr->status != OCCTL_OK)
    {
      return Error(anErr->status,
                   anErr->message != nullptr ? anErr->message : "",
                   anErr->source.bits,
                   anErr->extended);
    }
    return Error(theFallback, ::occtl_status_to_string(theFallback), 0, 0);
  }
 
  Error(const ::occtl_status_t theCode,
        std::string            theMessage,
        const std::uint64_t    theSourceUidBits,
        const std::uint32_t    theExtended) noexcept
      : std::runtime_error(std::move(theMessage)),
        myCode(theCode),
        mySourceUidBits(theSourceUidBits),
        myExtended(theExtended)
  {
  }
 
  ::occtl_status_t code() const noexcept { return myCode; }
 
  std::uint64_t source_uid_bits() const noexcept { return mySourceUidBits; }
 
  std::uint32_t extended() const noexcept { return myExtended; }
 
private:
  ::occtl_status_t myCode;
  std::uint64_t    mySourceUidBits;
  std::uint32_t    myExtended;
};
 
inline void check(const ::occtl_status_t theStatus)
{
  if (theStatus != OCCTL_OK)
  {
    throw Error::from_last(theStatus);
  }
}
 
inline std::tuple<std::uint32_t, std::uint32_t, std::uint32_t> version() noexcept
{
  std::uint32_t aMajor = 0;
  std::uint32_t aMinor = 0;
  std::uint32_t aPatch = 0;
  ::occtl_runtime_version(&aMajor, &aMinor, &aPatch);
  return {aMajor, aMinor, aPatch};
}
 
inline std::uint32_t abi_version() noexcept
{
  return ::occtl_runtime_abi_version();
}
 
inline std::string_view occt_version() noexcept
{
  const char* aStr = ::occtl_runtime_occt_version();
  return aStr != nullptr ? std::string_view{aStr} : std::string_view{};
}
 
inline void init_runtime_info(::occtl_runtime_init_info_t* theInfo)
{
  check(::occtl_runtime_init_info_init(theInfo));
}
 
inline int32_t uid_equal(const ::occtl_uid_t theA, const ::occtl_uid_t theB) noexcept
{
  return ::occtl_uid_equal(theA, theB);
}
 
class Runtime
{
public:
  Runtime()
  {
    check(::occtl_runtime_init(nullptr));
    myInitialised = true;
  }
 
  explicit Runtime(const ::occtl_runtime_init_info_t& theInfo)
  {
    check(::occtl_runtime_init(&theInfo));
    myInitialised = true;
  }
 
  ~Runtime() noexcept
  {
    if (myInitialised)
    {
      ::occtl_runtime_shutdown();
    }
  }
 
  Runtime(const Runtime&)            = delete;
  Runtime& operator=(const Runtime&) = delete;
 
  Runtime(Runtime&& theOther) noexcept
      : myInitialised(theOther.myInitialised)
  {
    theOther.myInitialised = false;
  }
 
  Runtime& operator=(Runtime&& theOther) noexcept
  {
    if (this != &theOther)
    {
      if (myInitialised)
      {
        ::occtl_runtime_shutdown();
      }
      myInitialised          = theOther.myInitialised;
      theOther.myInitialised = false;
    }
    return *this;
  }
 
private:
  bool myInitialised = false;
};
 
} // namespace occtl
 
#endif // OCCTL_HPP_CORE_HPP