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::vector<wchar_t> message(messageSize);
    res = CVB_CALL_CAPI(CVCGetLastErrorW(code, message.data(), messageSize));
    if (res == 0)
    {
      std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
      errorCode = static_cast<int>(code);
      return converter.to_bytes(message.data());
    }
  }
  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;
  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;
    CExports::cvbbool_t isFoundation;
 
    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
 
}