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_;
        }
 
 
        bool IsFoundation() const noexcept
        {
          return isFoundation_;
        }
 
      private:
 
        LicenseInfo(int serialNumber, bool isFoundation) noexcept
          : serialNumber_(serialNumber)
          , isFoundation_(isFoundation)
        {
        }
 
 
        int serialNumber_ = 0;
        bool isFoundation_ = false;
      };
 
 
      class MagicNumberEntry final
      {
        friend std::vector<MagicNumberEntry> GetMagicNumberEntries();
 
      public:
 
 
        String Provider() const noexcept
        {
          return provider_;
        }
 
 
        String ToolID() const noexcept
        {
          return toolID_;
        }
 
 
        String MagicNumber() const noexcept
        {
          return magicNumber_;
        }
 
 
 
        int SerialNumber() const noexcept
        {
          return serialNumber_;
        }
 
      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;
      };
 
 
 
      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 dummy = 0;
        std::string message = GetLastErrorMessage(dummy);
        return message;
      }
 
 
 
      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 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 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 DataPath()
      {
        std::vector<Char> buffer(260);
        if (!CExports::GetCVBDataDirectoryTyped(&buffer[0], buffer.size()))
          ThrowLastError();
 
        return String(&buffer[0]);
      }
 
 
 
      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;
 
      }
 
 
 
      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 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;
      }
 
    }
 
    using SystemInfo::LicenseInfo;
    using SystemInfo::MagicNumberEntry;
    using SystemInfo::ExpandPath;
    using SystemInfo::InstallPath;
    using SystemInfo::DataPath;
    using SystemInfo::GetLicenseInfo;
    using SystemInfo::WaitForLicense;
    using SystemInfo::GetMagicNumberEntries;
 
  }
 
  using Utilities::LicenseInfo;
  using Utilities::MagicNumberEntry;
  using Utilities::ExpandPath;
  using Utilities::InstallPath;
  using Utilities::DataPath;
  using Utilities::GetLicenseInfo;
  using Utilities::WaitForLicense;
  using Utilities::GetMagicNumberEntries;
 
  CVB_END_INLINE_NS
 
}