system_info.hpp

#pragma once
 
#include <chrono>
#include <codecvt>
#include <exception>
#include <locale>
#include <string>
#include <sstream>
#include <thread>
#include <vector>
 
#include "../_cexports/c_utilities.h"
#include "../_cexports/c_core.h"
 
#include "../exception.hpp"
#include "../string.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Utilities
  {

    namespace SystemInfo
    {


      class LicenseInfo final
      {
        friend std::vector<LicenseInfo> GetLicenseInfo();
 
      public:

        int SerialNumber() const noexcept
        {
          return serialNumber_;
        }
        int SerialNumber() const noexcept {…}


        bool IsFoundation() const noexcept
        {
          return isFoundation_;
        }
        bool IsFoundation() const noexcept {…}
 
      private:
        LicenseInfo(int serialNumber, bool isFoundation) noexcept
            : serialNumber_(serialNumber)
            , isFoundation_(isFoundation)
        {
        }
 
        int serialNumber_  = 0;
        bool isFoundation_ = false;
      };
      class LicenseInfo final {…};


      class MagicNumberEntry final
      {
        friend std::vector<MagicNumberEntry> GetMagicNumberEntries();
 
      public:

        String Provider() const noexcept
        {
          return provider_;
        }
        String Provider() const noexcept {…}


        String ToolID() const noexcept
        {
          return toolID_;
        }
        String ToolID() const noexcept {…}


        String MagicNumber() const noexcept
        {
          return magicNumber_;
        }
        String MagicNumber() const noexcept {…}


        int SerialNumber() const noexcept
        {
          return serialNumber_;
        }
        int SerialNumber() const noexcept {…}
 
      private:
        MagicNumberEntry(const String &provider, const String &toolID, const String &magicNumber,
                         int serialNumber) noexcept
            : provider_(provider)
            , toolID_(toolID)
            , magicNumber_(magicNumber)
            , serialNumber_(serialNumber)
        {
        }
 
        String provider_;
        String toolID_;
        String magicNumber_;
        int serialNumber_ = 0;
      };
      class MagicNumberEntry final {…};


      inline std::string GetLastErrorMessage(int &errorCode)
      {
        CExports::cvbres_t code = 0;
        std::size_t messageSize = 0;
        auto res                = CVB_CALL_CAPI(CVCGetLastErrorW(code, nullptr, messageSize));
        if (res == 0)
        {
          std::wstring message;
          message.resize(messageSize);
          res = CVB_CALL_CAPI(CVCGetLastErrorW(code, &message[0], messageSize));
          if (res == 0)
          {
            errorCode = static_cast<int>(code);
            // currently the only standard way
            return Internal::WideCharStrToUTF8(message);
          }
        }
        errorCode = static_cast<int>(res);
        return std::string();
      }
      inline std::string GetLastErrorMessage(int &errorCode) {…}


      inline std::string GetLastErrorMessage()
      {
        int dummy           = 0;
        std::string message = GetLastErrorMessage(dummy);
        return message;
      }
      inline std::string GetLastErrorMessage() {…}


      inline std::exception_ptr GetLastError() noexcept
      {
        int errorCode = 0;
        auto message  = GetLastErrorMessage(errorCode);
        if (errorCode == 0)
          return std::exception_ptr();
 
        return CvbException::FromCvbResult(errorCode, message);
      }
      inline std::exception_ptr GetLastError() noexcept {…}
 
      inline void ThrowLastError(int errorCode)
      {
        auto exception = GetLastError();
        // Raise an exception for the code specified by errorCode:
        if (!exception)
          std::rethrow_exception(CvbException::FromCvbResult(errorCode, "no specific message"));
        std::rethrow_exception(exception);
      }
 
      inline void ThrowLastError()
      {
        ThrowLastError(ErrorCodes::CVB_ERROR);
      }
 
      inline std::chrono::microseconds DefaultTimeout()
      {
        CExports::cvbval_t defaultTimeout = 0;
        if (!CExports::GetDefaultTimeout(defaultTimeout))
          return std::chrono::milliseconds(10000);
 
        return std::chrono::milliseconds(defaultTimeout);
      }


      inline String ExpandPath(const String &path)
      {
        std::vector<Char> buffer(CExports::CVB_MAX_PATH);
        if (!CExports::TranslateFileNameTyped(path.c_str(), &buffer[0], CExports::CVB_MAX_PATH))
          ThrowLastError();
        return String(&buffer[0]);
      }
      inline String ExpandPath(const String &path) {…}


      inline String InstallPath()
      {
        std::vector<Char> buffer(260);
        if (!CExports::GetCVBDirectoryTyped(&buffer[0], buffer.size()))
          ThrowLastError();
 
        String path(&buffer[0]);
 
#ifndef _WIN32
        if (path.back() != CVB_LIT('/'))
          path += CVB_LIT('/');
#endif
        return path;
      }
      inline String InstallPath() {…}


      inline String DataPath()
      {
        std::vector<Char> buffer(260);
        if (!CExports::GetCVBDataDirectoryTyped(&buffer[0], buffer.size()))
          ThrowLastError();
 
        return String(&buffer[0]);
      }
      inline String DataPath() {…}


      inline std::vector<LicenseInfo> GetLicenseInfo()
      {
        auto resultUpdate = CVB_CALL_CAPI(UpdateLicenses());
        if (resultUpdate < 0)
          std::rethrow_exception(CvbException::FromCvbResult(resultUpdate, "failed to update licenses"));
 
        auto licCount = static_cast<int>(CExports::GetLicenseCount());
 
        std::vector<LicenseInfo> licenseList;
 
        for (int i = 0; i < licCount; ++i)
        {
          CExports::cvblicres_t serialNumber = 0;
          CExports::cvbbool_t isFoundation   = false;
 
          auto resultInfo =
              CVB_CALL_CAPI(GetLicenseInfoEx(static_cast<CExports::cvbval_t>(i), serialNumber, isFoundation));
          if (resultInfo < 0)
            ThrowLastError(resultInfo);
 
          licenseList.push_back(LicenseInfo(static_cast<int>(serialNumber), (isFoundation) ? true : false));
        }
        return licenseList;
      }
      inline std::vector<LicenseInfo> GetLicenseInfo() {…}


      template <class Rep, class Period>
      inline WaitStatus WaitForLicense(const std::chrono::duration<Rep, Period> &timeSpan) noexcept
      {
        auto start = std::chrono::system_clock::now();
 
        while (true)
        {
          auto result = CVB_CALL_CAPI(UpdateLicenses());
          if (result >= 0 && CExports::GetLicenseCount() > 0)
            return WaitStatus::Ok;
          else
          {
            // wait until services are running
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
            auto end = std::chrono::system_clock::now();
            if (end - start > timeSpan)
              return WaitStatus::Timeout;
          }
        }
      }
      inline WaitStatus WaitForLicense(const std::chrono::duration<Rep, Period> &timeSpan) noexcept {…}


      inline std::vector<MagicNumberEntry> GetMagicNumberEntries()
      {
        auto resultUpdate = CVB_CALL_CAPI(UpdateLicensesDeep());
        if (resultUpdate < 0)
          ThrowLastError(resultUpdate);
 
        auto magicNumberCount = static_cast<int>(CExports::GetMagicNumberCount());
 
        std::vector<MagicNumberEntry> entryList;
 
        for (int i = 0; i < magicNumberCount; ++i)
        {
          std::size_t providerSize           = 0;
          std::size_t toolIDSize             = 0;
          std::size_t magicNumberSize        = 0;
          CExports::cvblicres_t serialNumber = 0;
          auto resultMnSize = CVB_CALL_CAPI(GetMagicNumber(static_cast<std::size_t>(i), nullptr, providerSize, nullptr,
                                                           toolIDSize, nullptr, magicNumberSize, serialNumber));
          if (resultMnSize >= 0)
          {
            std::vector<char> provider(providerSize);
            std::vector<char> toolID(toolIDSize);
            std::vector<char> magicNumber(magicNumberSize);
            auto resultMn =
                CVB_CALL_CAPI(GetMagicNumber(static_cast<std::size_t>(i), &provider[0], providerSize, &toolID[0],
                                             toolIDSize, &magicNumber[0], magicNumberSize, serialNumber));
            if (resultMn < 0)
              continue;
 
            entryList.push_back(
                MagicNumberEntry(String(provider.begin(), provider.end()), String(toolID.begin(), toolID.end()),
                                 String(magicNumber.begin(), magicNumber.end()), static_cast<int>(serialNumber)));
          }
        }
 
        return entryList;
      }
      inline std::vector<MagicNumberEntry> GetMagicNumberEntries() {…}
 
    }  // namespace SystemInfo
 
    using SystemInfo::DataPath;
    using SystemInfo::ExpandPath;
    using SystemInfo::GetLicenseInfo;
    using SystemInfo::GetMagicNumberEntries;
    using SystemInfo::InstallPath;
    using SystemInfo::LicenseInfo;
    using SystemInfo::MagicNumberEntry;
    using SystemInfo::WaitForLicense;
 
  }  // namespace Utilities
 
  using Utilities::DataPath;
  using Utilities::ExpandPath;
  using Utilities::GetLicenseInfo;
  using Utilities::GetMagicNumberEntries;
  using Utilities::InstallPath;
  using Utilities::LicenseInfo;
  using Utilities::MagicNumberEntry;
  using Utilities::WaitForLicense;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb
    using SystemInfo::WaitForLicense; {…}
    using SystemInfo::InstallPath; {…}
    using SystemInfo::GetMagicNumberEntries; {…}
    using SystemInfo::GetLicenseInfo; {…}
    using SystemInfo::ExpandPath; {…}
    using SystemInfo::DataPath; {…}