| LicenseSpring C++ SDK 7.32.0 Easily add Software Licensing to your application

Public Member Functions | Static Public Member Functions | List of all members
LicenseSpring::LicenseHandler Class Reference

This class encapsulates functionality of the both LicenseManager and the License.
. More...

`#include <LicenseSpring/LicenseHandler.h>`

## Public Member Functions
| LicenseHandler (Configuration::ptr_t config=nullptr, LicenseStorage::ptr_t storage=nullptr)
| Constructor for LicenseHandler. More...
| LicenseHandler (const LicenseHandler &)=delete
LicenseHandler & | operator= (const LicenseHandler &)=delete
| ~LicenseHandler ()
| Destructor for LicenseHandler. More...
void | reconfigure (Configuration::ptr_t config, LicenseStorage::ptr_t storage=nullptr)
Configuration::ptr_t | currentConfig () const
const std::wstring & | dataLocation () const
void | setDataLocation (const std::wstring &path)
std::wstring | licenseFileName () const
void | setLicenseFileName (const std::wstring &name)
std::wstring | licenseFilePath () const
bool | isOnline () const
ProductDetails::ptr_t | getProductDetails (bool includeLatestVersion=false) const
const LicenseID & | getTrialLicense (Customer::ptr_t user=nullptr, const std::string &licensePolicy=std::string()) const
const LicenseID & | getTrialLicense (const std::string &userEmail) const
const std::string & | getSSOUrl (const std::string &accountCode=std::string(), bool useAuthCode=true)
const std::string & | getAirGapActivationCode (const std::string &initializationCode, const std::string &licenseKey)
const std::string & | getAirGapDeactivationCode (const std::string &initializationCode)
void | activateAirGapLicense (const std::string &confirmationCode, const std::wstring &activationResponseFile, const std::string &licenseKey, uint32_t policyId)
void | deactivateAirGapLicense (const std::string &confirmationCode)
std::vector< LicenseUser::ptr_t > | getLicenseUsers (const Customer &customer)
std::vector< LicenseUser::ptr_t > | getLicenseUsers (const std::string &customerEmail)
void | activateLicense (const LicenseID &licenseID)
void | activateLicense (const std::string &authData, const std::string &accountCode=std::string(), bool useAuthCode=true)
bool | deactivateLicense ()
bool | changePassword (const std::string &password, const std::string &newPassword, const std::string &user=std::string())
void | relinkLicense (DeviceIDAlgorithm deviceIdAlgorithm, const std::string &userPassword=std::string())
InstallationFile::ptr_t | checkLicense (const InstallFileFilter &filter=InstallFileFilter(), bool includeExpiredFeatures=false)
const std::vector< std::string > & | getVersionList (const LicenseID &licenseID=LicenseID(), const InstallFileFilter &filter=InstallFileFilter())
InstallationFile::ptr_t | getInstallFile (const LicenseID &licenseID=LicenseID(), const std::string &version=std::string(), const InstallFileFilter &filter=InstallFileFilter())
void | sendDeviceVariables ()
std::vector< DeviceVariable > | getDeviceVariables (bool getFromBackend=false)
void | syncConsumption (int32_t requestOverage=-1)
void | syncFeatureConsumption (const std::string &featureCode=std::string())
void | registerFloatingLicense ()
void | borrowFloatingLicense (uint32_t hours, uint32_t days=0)
void | borrowFloatingLicense (const std::string &borrowEndDateTime=std::string())
void | releaseFloatingLicense ()
void | registerFloatingFeature (const std::string &featureCode, bool addToWatchdog=true)
void | releaseFloatingFeature (const std::string &featureCode)
bool | isInitialized () const
bool | isLicenseExists () const
void | updateConsumption (int32_t value=1, bool saveLicense=true)
void | updateFeatureConsumption (const std::string &featureCode, int32_t value=1, bool saveLicense=true)
void | checkLicenseLocal ()
void | clearLocalStorage ()
void | addUserData (const CustomField &data, bool saveLicense=true)
void | removeUserData (const std::string &key=std::string(), bool saveLicense=true)
const std::vector< CustomField > & | userData ()
std::string | userData (const std::string &key)
bool | isAutoReleaseSet () const
void | setAutoRelease (bool autoRelease)
void | setupLicenseWatchdog (LicenseWatchdogCallback callback, uint32_t timeout=0)
void | resumeLicenseWatchdog ()
void | stopLicenseWatchdog ()
void | setupFeatureWatchdog (LicenseWatchdogCallback callback, uint32_t timeout=0)
void | resumeFeatureWatchdog ()
void | stopFeatureWatchdog ()
void | addDeviceVariable (const std::string &name, const std::string &value, bool saveLicense=true)
void | addDeviceVariable (const DeviceVariable &variable, bool saveLicense=true)
void | addDeviceVariables (const std::vector< DeviceVariable > &variables)
DeviceVariable | deviceVariable (const std::string &name) const
const std::string & | deviceVariableValue (const std::string &name) const
const std::wstring & | createOfflineActivationFile (const LicenseID &licenseID, const std::wstring &activationRequestFile=std::wstring())
void | activateLicenseOffline (const std::wstring &activationResponseFile=std::wstring())
const std::wstring & | deactivateLicenseOffline (const std::wstring &deactivationRequestFile=std::wstring())
bool | updateOffline (const std::wstring &path=std::wstring(), bool resetConsumption=false)
bool | isLicenseValid () const
bool | isLicenseTrial () const
bool | isLicenseAirGapped () const
bool | isLicenseActive () const
bool | isLicenseEnabled () const
bool | isLicenseExpired () const
bool | isLicenseMaintenanceExpired () const
bool | isLicenseOfflineActivated () const
bool | isLicenseFloating () const
bool | isLicenseBorrowed () const
bool | isLicenseOveragesAllowed () const
bool | isLicenseUnlimitedConsumptionAllowed () const
bool | isLicenseVMAllowed () const
bool | isSubscriptionGracePeriodStarted () const
bool | isGracePeriodStarted () const
tm | gracePeriodEndDateTime () const
tm | gracePeriodEndDateTimeUTC () const
int | gracePeriodHoursRemaining () const
uint32_t | getLicenseTrialPeriod () const
const LicenseID & | getLicenseID () const
const std::string & | getLicenseKey () const
const std::string & | getLicenseUser () const
const std::string & | getLicenseStatusStr () const
const std::string & | getLicenseStartDate () const
const std::string & | getLicenseMetadata () const
LicenseType | getLicenseType () const
tm | getLicenseExpiryDate () const
tm | getLicenseExpiryDateUtc () const
tm | getLicenseMaintenancePeriod () const
tm | getLicenseMaintenancePeriodUtc () const
tm | getLicenseLastCheckDate () const
tm | getLicenseLastCheckDateUtc () const
tm | getLicenseFloatingEndDateTime () const
tm | getLicenseFloatingEndDateTimeUtc () const
int | getDaysRemaining () const
int | getMaintenanceDaysRemaining () const
int | getDaysPassedSinceLastCheck () const
uint32_t | getSubscriptionLicenseGracePeriod () const
tm | validityWithGracePeriod () const
tm | validityWithGracePeriodUtc () const
const Customer & | getLicenseOwner () const
LicenseUser::ptr_t | getLicenseUserPtr () const
bool | hasLicenseFeatures () const
const LicenseFeature & | getLicenseFeature (const std::string &featureCode) const
const std::vector< LicenseFeature > & | getLicenseFeatures () const
bool | hasLicenseCustomFields () const
const std::vector< CustomField > & | getLicenseCustomFields () const
uint32_t | getLicenseTimesActivated () const
uint32_t | getLicenseMaxActivations () const
uint32_t | getLicenseTransferCount () const
int32_t | getLicenseTransferLimit () const
bool | isDeviceTransferAllowed () const
bool | isDeviceTransferLimited () const
uint32_t | getLicensePolicyId () const
int32_t | getLicenseTotalConsumption () const
int32_t | getLicenseMaxConsumption () const
int32_t | getLicenseMaxOverages () const
bool | isResetLicenseConsumptionEnabled () const
ConsumptionPeriod | getLicenseConsumptionPeriod () const
uint32_t | getLicenseFloatingTimeout () const
uint32_t | getLicenseFloatingInUseCount () const
uint32_t | getLicenseMaxFloatingUsers () const
uint32_t | getMaxBorrowTime () const
void | enableExceptions (bool enable)
bool | isExceptionsEnabled () const
bool | wasError () const
LSErrorCode | getLastError () const
const std::string & | getLastErrorMsg () const
bool | isInitializationError () const
bool | isInternalServerError () const
bool | isNetworkTimeoutError () const
bool | isNoInternetError () const
bool | isActivationFailed () const
bool | isLicenseExpiredError () const
bool | isLicenseNotFoundError () const
bool | isLicenseStateError () const
bool | isHardwareIDError () const
bool | isGeneralError () const
bool | isLicenseFeatureError () const
bool | canIgnoreError () const

## Static Public Member Functions
static LicenseHandler & | instance (bool globalInit=false)
| Get singleton object of LicenseHandler. More...

## Detailed Description

This class encapsulates functionality of the both LicenseManager and the License.
.

By default it is exceptions free, but you can enable exceptions.
It's up to you whether to use LicenseManager and License directly or use this class.
This class also useful for Unreal Engine clients.
Because it is free of memory access violation problems due to runtime conflicts with UE.

See also
  License and LicenseManager for more details on these methods.

Definition at line 26 of file LicenseHandler.h.

## Constructor & Destructor Documentation

## ◆ LicenseHandler() [1/2]

LicenseSpring::LicenseHandler::LicenseHandler | ( | Configuration::ptr_t | config = `nullptr`,
|  | LicenseStorage::ptr_t | storage = `nullptr`
| ) |  |

Constructor for LicenseHandler.

Parameters

  config | Your LicenseSpring configuration
  storage | Optional custom storage implementation for local license

## ◆ LicenseHandler() [2/2]

LicenseSpring::LicenseHandler::LicenseHandler | ( | const LicenseHandler & |  | ) |
| delete

## ◆ ~LicenseHandler()

LicenseSpring::LicenseHandler::~LicenseHandler | ( |  | ) |

Destructor for LicenseHandler.

## Member Function Documentation

## ◆ instance()

static LicenseHandler& LicenseSpring::LicenseHandler::instance | ( | bool | globalInit = `false` | ) |
| static

Get singleton object of LicenseHandler.

Parameters

  globalInit | Indicates if curl global initialization should be done first. Set it to true for the first call if you use floating licensing in order to properly release floating license at the app exit. Otherwise this param can be safely ignored, as well as if you release floating license manualy.

Warning
  Automatic floating license releasing may still not work if you link to LicenseSpring dynamically and not do local license check. In this case we recommend you to release license manualy or you can create you own static object.

## ◆ operator=()

LicenseHandler& LicenseSpring::LicenseHandler::operator= | ( | const LicenseHandler & |  | ) |
| delete

## ◆ reconfigure()

void LicenseSpring::LicenseHandler::reconfigure | ( | Configuration::ptr_t | config,
|  | LicenseStorage::ptr_t | storage = `nullptr`
| ) |  |

See also
  BaseManager::reconfigure

## ◆ currentConfig()

Configuration::ptr_t LicenseSpring::LicenseHandler::currentConfig | ( |  | ) | const

See also
  BaseManager::currentConfig

## ◆ dataLocation()

const std::wstring& LicenseSpring::LicenseHandler::dataLocation | ( |  | ) | const

See also
  BaseManager::dataLocation

## ◆ setDataLocation()

void LicenseSpring::LicenseHandler::setDataLocation | ( | const std::wstring & | path | ) |

See also
  BaseManager::setDataLocation

## ◆ licenseFileName()

std::wstring LicenseSpring::LicenseHandler::licenseFileName | ( |  | ) | const

See also
  BaseManager::licenseFileName

## ◆ setLicenseFileName()

void LicenseSpring::LicenseHandler::setLicenseFileName | ( | const std::wstring & | name | ) |

See also
  BaseManager::setLicenseFileName

## ◆ licenseFilePath()

std::wstring LicenseSpring::LicenseHandler::licenseFilePath | ( |  | ) | const

See also
  BaseManager::licenseFilePath

## ◆ isOnline()

bool LicenseSpring::LicenseHandler::isOnline | ( |  | ) | const

See also
  LicenseManager::isOnline

## ◆ getProductDetails()

ProductDetails::ptr_t LicenseSpring::LicenseHandler::getProductDetails | ( | bool | includeLatestVersion = `false` | ) | const

See also
  BaseManager::getProductDetails

## ◆ getTrialLicense() [1/2]

const LicenseID& LicenseSpring::LicenseHandler::getTrialLicense | ( | Customer::ptr_t | user = `nullptr`,
|  | const std::string & | licensePolicy = `std::string()`
| ) |  | const

See also
  LicenseManager::getTrialLicense

## ◆ getTrialLicense() [2/2]

const LicenseID& LicenseSpring::LicenseHandler::getTrialLicense | ( | const std::string & | userEmail | ) | const

See also
  LicenseManager::getTrialLicense

## ◆ getSSOUrl()

const std::string& LicenseSpring::LicenseHandler::getSSOUrl | ( | const std::string & | accountCode = `std::string()`,
|  | bool | useAuthCode = `true`
| ) |  |

See also
  LicenseManager::getSSOUrl

## ◆ getAirGapActivationCode()

const std::string& LicenseSpring::LicenseHandler::getAirGapActivationCode | ( | const std::string & | initializationCode,
|  | const std::string & | licenseKey
| ) |  |

See also
  LicenseManager::getAirGapActivationCode

## ◆ getAirGapDeactivationCode()

const std::string& LicenseSpring::LicenseHandler::getAirGapDeactivationCode | ( | const std::string & | initializationCode | ) |

See also
  License::getAirGapDeactivationCode

## ◆ activateAirGapLicense()

void LicenseSpring::LicenseHandler::activateAirGapLicense | ( | const std::string & | confirmationCode,
|  | const std::wstring & | activationResponseFile,
|  | const std::string & | licenseKey,
|  | uint32_t | policyId
| ) |  |

See also
  LicenseManager::activateAirGapLicense

## ◆ deactivateAirGapLicense()

void LicenseSpring::LicenseHandler::deactivateAirGapLicense | ( | const std::string & | confirmationCode | ) |

See also
  License::deactivateAirGap

## ◆ getLicenseUsers() [1/2]

std::vector<LicenseUser::ptr_t> LicenseSpring::LicenseHandler::getLicenseUsers | ( | const Customer & | customer | ) |

See also
  LicenseManager::getLicenseUsers

## ◆ getLicenseUsers() [2/2]

std::vector<LicenseUser::ptr_t> LicenseSpring::LicenseHandler::getLicenseUsers | ( | const std::string & | customerEmail | ) |

See also
  LicenseManager::getLicenseUsers

## ◆ activateLicense() [1/2]

void LicenseSpring::LicenseHandler::activateLicense | ( | const LicenseID & | licenseID | ) |

See also
  LicenseManager::activateLicense

## ◆ activateLicense() [2/2]

void LicenseSpring::LicenseHandler::activateLicense | ( | const std::string & | authData,
|  | const std::string & | accountCode = `std::string()`,
|  | bool | useAuthCode = `true`
| ) |  |

See also
  LicenseManager::activateLicense

## ◆ deactivateLicense()

bool LicenseSpring::LicenseHandler::deactivateLicense | ( |  | ) |

See also
  License::deactivate

## ◆ changePassword()

bool LicenseSpring::LicenseHandler::changePassword | ( | const std::string & | password,
|  | const std::string & | newPassword,
|  | const std::string & | user = `std::string()`
| ) |  |

See also
  License::changePassword

## ◆ relinkLicense()

void LicenseSpring::LicenseHandler::relinkLicense | ( | DeviceIDAlgorithm | deviceIdAlgorithm,
|  | const std::string & | userPassword = `std::string()`
| ) |  |

See also
  LicenseManager::relinkLicense

## ◆ checkLicense()

InstallationFile::ptr_t LicenseSpring::LicenseHandler::checkLicense | ( | const InstallFileFilter & | filter = `InstallFileFilter()`,
|  | bool | includeExpiredFeatures = `false`
| ) |  |

See also
  License::check

## ◆ getVersionList()

const std::vector<std::string>& LicenseSpring::LicenseHandler::getVersionList | ( | const LicenseID & | licenseID = `LicenseID()`,
|  | const InstallFileFilter & | filter = `InstallFileFilter()`
| ) |  |

See also
  LicenseManager::getVersionList

## ◆ getInstallFile()

InstallationFile::ptr_t LicenseSpring::LicenseHandler::getInstallFile | ( | const LicenseID & | licenseID = `LicenseID()`,
|  | const std::string & | version = `std::string()`,
|  | const InstallFileFilter & | filter = `InstallFileFilter()`
| ) |  |

See also
  LicenseManager::getInstallationFile

## ◆ sendDeviceVariables()

void LicenseSpring::LicenseHandler::sendDeviceVariables | ( |  | ) |

See also
  License::sendDeviceVariables

## ◆ getDeviceVariables()

std::vector<DeviceVariable> LicenseSpring::LicenseHandler::getDeviceVariables | ( | bool | getFromBackend = `false` | ) |

See also
  License::getDeviceVariables

## ◆ syncConsumption()

void LicenseSpring::LicenseHandler::syncConsumption | ( | int32_t | requestOverage = `-1` | ) |

See also
  License::syncConsumption

## ◆ syncFeatureConsumption()

void LicenseSpring::LicenseHandler::syncFeatureConsumption | ( | const std::string & | featureCode = `std::string()` | ) |

See also
  License::syncFeatureConsumption

## ◆ registerFloatingLicense()

void LicenseSpring::LicenseHandler::registerFloatingLicense | ( |  | ) |

See also
  License::registerFloatingLicense

## ◆ borrowFloatingLicense() [1/2]

void LicenseSpring::LicenseHandler::borrowFloatingLicense | ( | uint32_t | hours,
|  | uint32_t | days = `0`
| ) |  |

See also
  License::borrow

## ◆ borrowFloatingLicense() [2/2]

void LicenseSpring::LicenseHandler::borrowFloatingLicense | ( | const std::string & | borrowEndDateTime = `std::string()` | ) |

See also
  License::borrow

## ◆ releaseFloatingLicense()

void LicenseSpring::LicenseHandler::releaseFloatingLicense | ( |  | ) |

See also
  License::releaseFloatingLicense

## ◆ registerFloatingFeature()

void LicenseSpring::LicenseHandler::registerFloatingFeature | ( | const std::string & | featureCode,
|  | bool | addToWatchdog = `true`
| ) |  |

See also
  License::registerFloatingFeature

## ◆ releaseFloatingFeature()

void LicenseSpring::LicenseHandler::releaseFloatingFeature | ( | const std::string & | featureCode | ) |

See also
  License::releasefloatingFeature

## ◆ isInitialized()

bool LicenseSpring::LicenseHandler::isInitialized | ( |  | ) | const

## ◆ isLicenseExists()

bool LicenseSpring::LicenseHandler::isLicenseExists | ( |  | ) | const

## ◆ updateConsumption()

void LicenseSpring::LicenseHandler::updateConsumption | ( | int32_t | value = `1`,
|  | bool | saveLicense = `true`
| ) |  |

See also
  License::updateConsumption

## ◆ updateFeatureConsumption()

void LicenseSpring::LicenseHandler::updateFeatureConsumption | ( | const std::string & | featureCode,
|  | int32_t | value = `1`,
|  | bool | saveLicense = `true`
| ) |  |

See also
  License::updateFeatureConsumption

## ◆ checkLicenseLocal()

void LicenseSpring::LicenseHandler::checkLicenseLocal | ( |  | ) |

See also
  License::localCheck

## ◆ clearLocalStorage()

void LicenseSpring::LicenseHandler::clearLocalStorage | ( |  | ) |

See also
  BaseManager::clearLocalStorage

## ◆ addUserData()

void LicenseSpring::LicenseHandler::addUserData | ( | const CustomField & | data,
|  | bool | saveLicense = `true`
| ) |  |

See also
  License::addUserData

## ◆ removeUserData()

void LicenseSpring::LicenseHandler::removeUserData | ( | const std::string & | key = `std::string()`,
|  | bool | saveLicense = `true`
| ) |  |

See also
  License::removeUserData

## ◆ userData() [1/2]

const std::vector<CustomField>& LicenseSpring::LicenseHandler::userData | ( |  | ) |

See also
  License::userData

## ◆ userData() [2/2]

std::string LicenseSpring::LicenseHandler::userData | ( | const std::string & | key | ) |

See also
  License::userData

## ◆ isAutoReleaseSet()

bool LicenseSpring::LicenseHandler::isAutoReleaseSet | ( |  | ) | const

See also
  License::isAutoReleaseSet

## ◆ setAutoRelease()

void LicenseSpring::LicenseHandler::setAutoRelease | ( | bool | autoRelease | ) |

See also
  License::setAutoRelease

## ◆ setupLicenseWatchdog()

void LicenseSpring::LicenseHandler::setupLicenseWatchdog | ( | LicenseWatchdogCallback | callback,
|  | uint32_t | timeout = `0`
| ) |  |

See also
  License::setupLicenseWatchdog

## ◆ resumeLicenseWatchdog()

void LicenseSpring::LicenseHandler::resumeLicenseWatchdog | ( |  | ) |

See also
  License::resumeLicenseWatchdog

## ◆ stopLicenseWatchdog()

void LicenseSpring::LicenseHandler::stopLicenseWatchdog | ( |  | ) |

See also
  License::stopLicenseWatchdog

## ◆ setupFeatureWatchdog()

void LicenseSpring::LicenseHandler::setupFeatureWatchdog | ( | LicenseWatchdogCallback | callback,
|  | uint32_t | timeout = `0`
| ) |  |

See also
  License::setupFeatureWatchdog

## ◆ resumeFeatureWatchdog()

void LicenseSpring::LicenseHandler::resumeFeatureWatchdog | ( |  | ) |

See also
  License::resumeFeatureWatchdog

## ◆ stopFeatureWatchdog()

void LicenseSpring::LicenseHandler::stopFeatureWatchdog | ( |  | ) |

See also
  License::stopFeatureWatchdog

## ◆ addDeviceVariable() [1/2]

void LicenseSpring::LicenseHandler::addDeviceVariable | ( | const std::string & | name,
|  | const std::string & | value,
|  | bool | saveLicense = `true`
| ) |  |

See also
  License::addDeviceVariable

## ◆ addDeviceVariable() [2/2]

void LicenseSpring::LicenseHandler::addDeviceVariable | ( | const DeviceVariable & | variable,
|  | bool | saveLicense = `true`
| ) |  |

See also
  License::addDeviceVariable

## ◆ addDeviceVariables()

void LicenseSpring::LicenseHandler::addDeviceVariables | ( | const std::vector< DeviceVariable > & | variables | ) |

See also
  License::addDeviceVariable

## ◆ deviceVariable()

DeviceVariable LicenseSpring::LicenseHandler::deviceVariable | ( | const std::string & | name | ) | const

See also
  License::deviceVariable

## ◆ deviceVariableValue()

const std::string& LicenseSpring::LicenseHandler::deviceVariableValue | ( | const std::string & | name | ) | const

See also
  License::deviceVariable

## ◆ createOfflineActivationFile()

const std::wstring& LicenseSpring::LicenseHandler::createOfflineActivationFile | ( | const LicenseID & | licenseID,
|  | const std::wstring & | activationRequestFile = `std::wstring()`
| ) |  |

See also
  LicenseManager::createOfflineActivationFile

## ◆ activateLicenseOffline()

void LicenseSpring::LicenseHandler::activateLicenseOffline | ( | const std::wstring & | activationResponseFile = `std::wstring()` | ) |

See also
  LicenseManager::activateLicenseOffline

## ◆ deactivateLicenseOffline()

const std::wstring& LicenseSpring::LicenseHandler::deactivateLicenseOffline | ( | const std::wstring & | deactivationRequestFile = `std::wstring()` | ) |

See also
  License::deactivateLiceneseOffline

## ◆ updateOffline()

bool LicenseSpring::LicenseHandler::updateOffline | ( | const std::wstring & | path = `std::wstring()`,
|  | bool | resetConsumption = `false`
| ) |  |

See also
  License::updateOffline

## ◆ isLicenseValid()

bool LicenseSpring::LicenseHandler::isLicenseValid | ( |  | ) | const

See also
  License::isValid

## ◆ isLicenseTrial()

bool LicenseSpring::LicenseHandler::isLicenseTrial | ( |  | ) | const

See also
  License::isTrial

## ◆ isLicenseAirGapped()

bool LicenseSpring::LicenseHandler::isLicenseAirGapped | ( |  | ) | const

See also
  License::isAirGapped

## ◆ isLicenseActive()

bool LicenseSpring::LicenseHandler::isLicenseActive | ( |  | ) | const

See also
  License::isActive

## ◆ isLicenseEnabled()

bool LicenseSpring::LicenseHandler::isLicenseEnabled | ( |  | ) | const

See also
  License::isEnabled

## ◆ isLicenseExpired()

bool LicenseSpring::LicenseHandler::isLicenseExpired | ( |  | ) | const

See also
  License::isExpired

## ◆ isLicenseMaintenanceExpired()

bool LicenseSpring::LicenseHandler::isLicenseMaintenanceExpired | ( |  | ) | const

See also
  License::isMaintenancePeriodExpired

## ◆ isLicenseOfflineActivated()

bool LicenseSpring::LicenseHandler::isLicenseOfflineActivated | ( |  | ) | const

See also
  License::isOfflineActivated

## ◆ isLicenseFloating()

bool LicenseSpring::LicenseHandler::isLicenseFloating | ( |  | ) | const

See also
  License::isFloating

## ◆ isLicenseBorrowed()

bool LicenseSpring::LicenseHandler::isLicenseBorrowed | ( |  | ) | const

See also
  License::isBorrowed

## ◆ isLicenseOveragesAllowed()

bool LicenseSpring::LicenseHandler::isLicenseOveragesAllowed | ( |  | ) | const

See also
  License::isOveragesAllowed

## ◆ isLicenseUnlimitedConsumptionAllowed()

bool LicenseSpring::LicenseHandler::isLicenseUnlimitedConsumptionAllowed | ( |  | ) | const

See also
  License::isUnlimitedConsumptionAllowed

## ◆ isLicenseVMAllowed()

bool LicenseSpring::LicenseHandler::isLicenseVMAllowed | ( |  | ) | const

See also
  License::isVMAllowed

## ◆ isSubscriptionGracePeriodStarted()

bool LicenseSpring::LicenseHandler::isSubscriptionGracePeriodStarted | ( |  | ) | const

See also
  License::isGracePeriodStarted

## ◆ isGracePeriodStarted()

bool LicenseSpring::LicenseHandler::isGracePeriodStarted | ( |  | ) | const

See also
  License::isGracePeriodStarted

## ◆ gracePeriodEndDateTime()

tm LicenseSpring::LicenseHandler::gracePeriodEndDateTime | ( |  | ) | const

See also
  License::gracePeriodEndDateTime

## ◆ gracePeriodEndDateTimeUTC()

tm LicenseSpring::LicenseHandler::gracePeriodEndDateTimeUTC | ( |  | ) | const

See also
  License::gracePeriodEndDateTimeUTC

## ◆ gracePeriodHoursRemaining()

int LicenseSpring::LicenseHandler::gracePeriodHoursRemaining | ( |  | ) | const

See also
  License::gracePeriodHoursRemaining

## ◆ getLicenseTrialPeriod()

uint32_t LicenseSpring::LicenseHandler::getLicenseTrialPeriod | ( |  | ) | const

See also
  License::trialPeriod

## ◆ getLicenseID()

const LicenseID& LicenseSpring::LicenseHandler::getLicenseID | ( |  | ) | const

See also
  License::id

## ◆ getLicenseKey()

const std::string& LicenseSpring::LicenseHandler::getLicenseKey | ( |  | ) | const

See also
  License::key

## ◆ getLicenseUser()

const std::string& LicenseSpring::LicenseHandler::getLicenseUser | ( |  | ) | const

See also
  License::user

## ◆ getLicenseStatusStr()

const std::string& LicenseSpring::LicenseHandler::getLicenseStatusStr | ( |  | ) | const

See also
  License::status

## ◆ getLicenseStartDate()

const std::string& LicenseSpring::LicenseHandler::getLicenseStartDate | ( |  | ) | const

See also
  License::startDate

## ◆ getLicenseMetadata()

const std::string& LicenseSpring::LicenseHandler::getLicenseMetadata | ( |  | ) | const

See also
  License::metadata

## ◆ getLicenseType()

LicenseType LicenseSpring::LicenseHandler::getLicenseType | ( |  | ) | const

See also
  License::type

## ◆ getLicenseExpiryDate()

tm LicenseSpring::LicenseHandler::getLicenseExpiryDate | ( |  | ) | const

See also
  License::validityPeriod

## ◆ getLicenseExpiryDateUtc()

tm LicenseSpring::LicenseHandler::getLicenseExpiryDateUtc | ( |  | ) | const

See also
  License::validityPeriodUtc

## ◆ getLicenseMaintenancePeriod()

tm LicenseSpring::LicenseHandler::getLicenseMaintenancePeriod | ( |  | ) | const

See also
  License::maintenancePeriod

## ◆ getLicenseMaintenancePeriodUtc()

tm LicenseSpring::LicenseHandler::getLicenseMaintenancePeriodUtc | ( |  | ) | const

See also
  License::maintenancePeriodUtc

## ◆ getLicenseLastCheckDate()

tm LicenseSpring::LicenseHandler::getLicenseLastCheckDate | ( |  | ) | const

See also
  License::lastCheckDate

## ◆ getLicenseLastCheckDateUtc()

tm LicenseSpring::LicenseHandler::getLicenseLastCheckDateUtc | ( |  | ) | const

See also
  License::lastCheckDateUtc

## ◆ getLicenseFloatingEndDateTime()

tm LicenseSpring::LicenseHandler::getLicenseFloatingEndDateTime | ( |  | ) | const

See also
  License::floatingEndDateTime

## ◆ getLicenseFloatingEndDateTimeUtc()

tm LicenseSpring::LicenseHandler::getLicenseFloatingEndDateTimeUtc | ( |  | ) | const

See also
  License::floatingEndDateTimeUtc

## ◆ getDaysRemaining()

int LicenseSpring::LicenseHandler::getDaysRemaining | ( |  | ) | const

See also
  License::daysRemaining

## ◆ getMaintenanceDaysRemaining()

int LicenseSpring::LicenseHandler::getMaintenanceDaysRemaining | ( |  | ) | const

See also
  License::maintenanceDaysRemaining

## ◆ getDaysPassedSinceLastCheck()

int LicenseSpring::LicenseHandler::getDaysPassedSinceLastCheck | ( |  | ) | const

See also
  License::daysPassedSinceLastCheck

## ◆ getSubscriptionLicenseGracePeriod()

uint32_t LicenseSpring::LicenseHandler::getSubscriptionLicenseGracePeriod | ( |  | ) | const

See also
  License::subscriptionGracePeriod

## ◆ validityWithGracePeriod()

tm LicenseSpring::LicenseHandler::validityWithGracePeriod | ( |  | ) | const

See also
  License::validityWithGracePeriod

## ◆ validityWithGracePeriodUtc()

tm LicenseSpring::LicenseHandler::validityWithGracePeriodUtc | ( |  | ) | const

See also
  License::validityWithGracePeriodUtc

## ◆ getLicenseOwner()

const Customer& LicenseSpring::LicenseHandler::getLicenseOwner | ( |  | ) | const

See also
  License::owner

## ◆ getLicenseUserPtr()

LicenseUser::ptr_t LicenseSpring::LicenseHandler::getLicenseUserPtr | ( |  | ) | const

See also
  License::licenseUser

## ◆ hasLicenseFeatures()

bool LicenseSpring::LicenseHandler::hasLicenseFeatures | ( |  | ) | const

## ◆ getLicenseFeature()

const LicenseFeature& LicenseSpring::LicenseHandler::getLicenseFeature | ( | const std::string & | featureCode | ) | const

See also
  License::feature

## ◆ getLicenseFeatures()

const std::vector<LicenseFeature>& LicenseSpring::LicenseHandler::getLicenseFeatures | ( |  | ) | const

See also
  License::features

## ◆ hasLicenseCustomFields()

bool LicenseSpring::LicenseHandler::hasLicenseCustomFields | ( |  | ) | const

## ◆ getLicenseCustomFields()

const std::vector<CustomField>& LicenseSpring::LicenseHandler::getLicenseCustomFields | ( |  | ) | const

See also
  License::customFields

## ◆ getLicenseTimesActivated()

uint32_t LicenseSpring::LicenseHandler::getLicenseTimesActivated | ( |  | ) | const

See also
  License::timesActivated

## ◆ getLicenseMaxActivations()

uint32_t LicenseSpring::LicenseHandler::getLicenseMaxActivations | ( |  | ) | const

See also
  License::maxActivations

## ◆ getLicenseTransferCount()

uint32_t LicenseSpring::LicenseHandler::getLicenseTransferCount | ( |  | ) | const

See also
  License::transferCount

## ◆ getLicenseTransferLimit()

int32_t LicenseSpring::LicenseHandler::getLicenseTransferLimit | ( |  | ) | const

See also
  License::transferLimit

## ◆ isDeviceTransferAllowed()

bool LicenseSpring::LicenseHandler::isDeviceTransferAllowed | ( |  | ) | const

See also
  License::isDeviceTransferAllowed

## ◆ isDeviceTransferLimited()

bool LicenseSpring::LicenseHandler::isDeviceTransferLimited | ( |  | ) | const

See also
  License::isDeviceTransferLimited

## ◆ getLicensePolicyId()

uint32_t LicenseSpring::LicenseHandler::getLicensePolicyId | ( |  | ) | const

See also
  License::policyId

## ◆ getLicenseTotalConsumption()

int32_t LicenseSpring::LicenseHandler::getLicenseTotalConsumption | ( |  | ) | const

See also
  License::totalConsumption

## ◆ getLicenseMaxConsumption()

int32_t LicenseSpring::LicenseHandler::getLicenseMaxConsumption | ( |  | ) | const

See also
  License::maxConsumption

## ◆ getLicenseMaxOverages()

int32_t LicenseSpring::LicenseHandler::getLicenseMaxOverages | ( |  | ) | const

See also
  License::maxOverages

## ◆ isResetLicenseConsumptionEnabled()

bool LicenseSpring::LicenseHandler::isResetLicenseConsumptionEnabled | ( |  | ) | const

## ◆ getLicenseConsumptionPeriod()

ConsumptionPeriod LicenseSpring::LicenseHandler::getLicenseConsumptionPeriod | ( |  | ) | const

## ◆ getLicenseFloatingTimeout()

uint32_t LicenseSpring::LicenseHandler::getLicenseFloatingTimeout | ( |  | ) | const

See also
  License::floatingTimeout

## ◆ getLicenseFloatingInUseCount()

uint32_t LicenseSpring::LicenseHandler::getLicenseFloatingInUseCount | ( |  | ) | const

See also
  License::floatingInUseCount

## ◆ getLicenseMaxFloatingUsers()

uint32_t LicenseSpring::LicenseHandler::getLicenseMaxFloatingUsers | ( |  | ) | const

See also
  License::maxFloatingUsers

## ◆ getMaxBorrowTime()

uint32_t LicenseSpring::LicenseHandler::getMaxBorrowTime | ( |  | ) | const

See also
  License::maxBorrowTime

## ◆ enableExceptions()

void LicenseSpring::LicenseHandler::enableExceptions | ( | bool | enable | ) |

## ◆ isExceptionsEnabled()

bool LicenseSpring::LicenseHandler::isExceptionsEnabled | ( |  | ) | const

## ◆ wasError()

bool LicenseSpring::LicenseHandler::wasError | ( |  | ) | const

## ◆ getLastError()

LSErrorCode LicenseSpring::LicenseHandler::getLastError | ( |  | ) | const

## ◆ getLastErrorMsg()

const std::string& LicenseSpring::LicenseHandler::getLastErrorMsg | ( |  | ) | const

## ◆ isInitializationError()

bool LicenseSpring::LicenseHandler::isInitializationError | ( |  | ) | const

## ◆ isInternalServerError()

bool LicenseSpring::LicenseHandler::isInternalServerError | ( |  | ) | const

## ◆ isNetworkTimeoutError()

bool LicenseSpring::LicenseHandler::isNetworkTimeoutError | ( |  | ) | const

## ◆ isNoInternetError()

bool LicenseSpring::LicenseHandler::isNoInternetError | ( |  | ) | const

## ◆ isActivationFailed()

bool LicenseSpring::LicenseHandler::isActivationFailed | ( |  | ) | const

## ◆ isLicenseExpiredError()

bool LicenseSpring::LicenseHandler::isLicenseExpiredError | ( |  | ) | const

## ◆ isLicenseNotFoundError()

bool LicenseSpring::LicenseHandler::isLicenseNotFoundError | ( |  | ) | const

## ◆ isLicenseStateError()

bool LicenseSpring::LicenseHandler::isLicenseStateError | ( |  | ) | const

## ◆ isHardwareIDError()

bool LicenseSpring::LicenseHandler::isHardwareIDError | ( |  | ) | const

## ◆ isGeneralError()

bool LicenseSpring::LicenseHandler::isGeneralError | ( |  | ) | const

## ◆ isLicenseFeatureError()

bool LicenseSpring::LicenseHandler::isLicenseFeatureError | ( |  | ) | const

## ◆ canIgnoreError()

bool LicenseSpring::LicenseHandler::canIgnoreError | ( |  | ) | const

The documentation for this class was generated from the following file:

- LicenseSpring/LicenseHandler.h