LicenseSpring C++ SDK 7.31.0
Easily add Software Licensing to your application
Loading...
Searching...
No Matches
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.
 
 LicenseHandler (const LicenseHandler &)=delete
 
LicenseHandleroperator= (const LicenseHandler &)=delete
 
 ~LicenseHandler ()
 Destructor for LicenseHandler.
 
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 LicenseIDgetTrialLicense (Customer::ptr_t user=nullptr, const std::string &licensePolicy=std::string()) const
 
const LicenseIDgetTrialLicense (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_tgetLicenseUsers (const Customer &customer)
 
std::vector< LicenseUser::ptr_tgetLicenseUsers (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< DeviceVariablegetDeviceVariables (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 LicenseIDgetLicenseID () 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 CustomergetLicenseOwner () const
 
LicenseUser::ptr_t getLicenseUserPtr () const
 
bool hasLicenseFeatures () const
 
const LicenseFeaturegetLicenseFeature (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 LicenseHandlerinstance (bool globalInit=false)
 Get singleton object of LicenseHandler.
 

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
configYour LicenseSpring configuration
storageOptional 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
globalInitIndicates 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 
)

◆ currentConfig()

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

◆ dataLocation()

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

◆ setDataLocation()

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

◆ licenseFileName()

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

◆ setLicenseFileName()

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

◆ licenseFilePath()

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

◆ isOnline()

bool LicenseSpring::LicenseHandler::isOnline ( ) const

◆ getProductDetails()

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

◆ getTrialLicense() [1/2]

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

◆ getTrialLicense() [2/2]

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

◆ getSSOUrl()

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

◆ getAirGapActivationCode()

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

◆ getAirGapDeactivationCode()

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

◆ activateAirGapLicense()

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

◆ deactivateAirGapLicense()

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

◆ getLicenseUsers() [1/2]

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

◆ getLicenseUsers() [2/2]

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

◆ activateLicense() [1/2]

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

◆ activateLicense() [2/2]

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

◆ deactivateLicense()

bool LicenseSpring::LicenseHandler::deactivateLicense ( )

◆ changePassword()

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

◆ relinkLicense()

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

◆ 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() 
)

◆ getInstallFile()

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

◆ sendDeviceVariables()

void LicenseSpring::LicenseHandler::sendDeviceVariables ( )

◆ getDeviceVariables()

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

◆ syncConsumption()

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

◆ syncFeatureConsumption()

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

◆ registerFloatingLicense()

void LicenseSpring::LicenseHandler::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 ( )

◆ registerFloatingFeature()

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

◆ 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 
)

◆ updateFeatureConsumption()

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

◆ checkLicenseLocal()

void LicenseSpring::LicenseHandler::checkLicenseLocal ( )

◆ clearLocalStorage()

void LicenseSpring::LicenseHandler::clearLocalStorage ( )

◆ addUserData()

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

◆ removeUserData()

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

◆ userData() [1/2]

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

◆ userData() [2/2]

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

◆ isAutoReleaseSet()

bool LicenseSpring::LicenseHandler::isAutoReleaseSet ( ) const

◆ setAutoRelease()

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

◆ setupLicenseWatchdog()

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

◆ resumeLicenseWatchdog()

void LicenseSpring::LicenseHandler::resumeLicenseWatchdog ( )

◆ stopLicenseWatchdog()

void LicenseSpring::LicenseHandler::stopLicenseWatchdog ( )

◆ setupFeatureWatchdog()

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

◆ resumeFeatureWatchdog()

void LicenseSpring::LicenseHandler::resumeFeatureWatchdog ( )

◆ stopFeatureWatchdog()

void LicenseSpring::LicenseHandler::stopFeatureWatchdog ( )

◆ addDeviceVariable() [1/2]

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

◆ addDeviceVariable() [2/2]

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

◆ addDeviceVariables()

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

◆ deviceVariable()

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

◆ deviceVariableValue()

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

◆ createOfflineActivationFile()

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

◆ activateLicenseOffline()

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

◆ 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 
)

◆ isLicenseValid()

bool LicenseSpring::LicenseHandler::isLicenseValid ( ) const

◆ isLicenseTrial()

bool LicenseSpring::LicenseHandler::isLicenseTrial ( ) const

◆ isLicenseAirGapped()

bool LicenseSpring::LicenseHandler::isLicenseAirGapped ( ) const

◆ isLicenseActive()

bool LicenseSpring::LicenseHandler::isLicenseActive ( ) const

◆ isLicenseEnabled()

bool LicenseSpring::LicenseHandler::isLicenseEnabled ( ) const

◆ isLicenseExpired()

bool LicenseSpring::LicenseHandler::isLicenseExpired ( ) const

◆ isLicenseMaintenanceExpired()

bool LicenseSpring::LicenseHandler::isLicenseMaintenanceExpired ( ) const

◆ isLicenseOfflineActivated()

bool LicenseSpring::LicenseHandler::isLicenseOfflineActivated ( ) const

◆ isLicenseFloating()

bool LicenseSpring::LicenseHandler::isLicenseFloating ( ) const

◆ isLicenseBorrowed()

bool LicenseSpring::LicenseHandler::isLicenseBorrowed ( ) const

◆ isLicenseOveragesAllowed()

bool LicenseSpring::LicenseHandler::isLicenseOveragesAllowed ( ) const

◆ isLicenseUnlimitedConsumptionAllowed()

bool LicenseSpring::LicenseHandler::isLicenseUnlimitedConsumptionAllowed ( ) const

◆ isLicenseVMAllowed()

bool LicenseSpring::LicenseHandler::isLicenseVMAllowed ( ) const

◆ isSubscriptionGracePeriodStarted()

bool LicenseSpring::LicenseHandler::isSubscriptionGracePeriodStarted ( ) const

◆ isGracePeriodStarted()

bool LicenseSpring::LicenseHandler::isGracePeriodStarted ( ) const

◆ gracePeriodEndDateTime()

tm LicenseSpring::LicenseHandler::gracePeriodEndDateTime ( ) const

◆ gracePeriodEndDateTimeUTC()

tm LicenseSpring::LicenseHandler::gracePeriodEndDateTimeUTC ( ) const

◆ gracePeriodHoursRemaining()

int LicenseSpring::LicenseHandler::gracePeriodHoursRemaining ( ) const

◆ getLicenseTrialPeriod()

uint32_t LicenseSpring::LicenseHandler::getLicenseTrialPeriod ( ) const

◆ 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

◆ getLicenseMetadata()

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

◆ getLicenseType()

LicenseType LicenseSpring::LicenseHandler::getLicenseType ( ) const
See also
License::type

◆ getLicenseExpiryDate()

tm LicenseSpring::LicenseHandler::getLicenseExpiryDate ( ) const

◆ getLicenseExpiryDateUtc()

tm LicenseSpring::LicenseHandler::getLicenseExpiryDateUtc ( ) const

◆ getLicenseMaintenancePeriod()

tm LicenseSpring::LicenseHandler::getLicenseMaintenancePeriod ( ) const

◆ getLicenseMaintenancePeriodUtc()

tm LicenseSpring::LicenseHandler::getLicenseMaintenancePeriodUtc ( ) const

◆ getLicenseLastCheckDate()

tm LicenseSpring::LicenseHandler::getLicenseLastCheckDate ( ) const

◆ getLicenseLastCheckDateUtc()

tm LicenseSpring::LicenseHandler::getLicenseLastCheckDateUtc ( ) const

◆ getLicenseFloatingEndDateTime()

tm LicenseSpring::LicenseHandler::getLicenseFloatingEndDateTime ( ) const

◆ getLicenseFloatingEndDateTimeUtc()

tm LicenseSpring::LicenseHandler::getLicenseFloatingEndDateTimeUtc ( ) const

◆ getDaysRemaining()

int LicenseSpring::LicenseHandler::getDaysRemaining ( ) const

◆ getMaintenanceDaysRemaining()

int LicenseSpring::LicenseHandler::getMaintenanceDaysRemaining ( ) const

◆ getDaysPassedSinceLastCheck()

int LicenseSpring::LicenseHandler::getDaysPassedSinceLastCheck ( ) const

◆ getSubscriptionLicenseGracePeriod()

uint32_t LicenseSpring::LicenseHandler::getSubscriptionLicenseGracePeriod ( ) const

◆ validityWithGracePeriod()

tm LicenseSpring::LicenseHandler::validityWithGracePeriod ( ) const

◆ validityWithGracePeriodUtc()

tm LicenseSpring::LicenseHandler::validityWithGracePeriodUtc ( ) const

◆ getLicenseOwner()

const Customer & LicenseSpring::LicenseHandler::getLicenseOwner ( ) const
See also
License::owner

◆ getLicenseUserPtr()

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

◆ hasLicenseFeatures()

bool LicenseSpring::LicenseHandler::hasLicenseFeatures ( ) const

◆ getLicenseFeature()

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

◆ getLicenseFeatures()

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

◆ hasLicenseCustomFields()

bool LicenseSpring::LicenseHandler::hasLicenseCustomFields ( ) const

◆ getLicenseCustomFields()

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

◆ getLicenseTimesActivated()

uint32_t LicenseSpring::LicenseHandler::getLicenseTimesActivated ( ) const

◆ getLicenseMaxActivations()

uint32_t LicenseSpring::LicenseHandler::getLicenseMaxActivations ( ) const

◆ getLicenseTransferCount()

uint32_t LicenseSpring::LicenseHandler::getLicenseTransferCount ( ) const

◆ getLicenseTransferLimit()

int32_t LicenseSpring::LicenseHandler::getLicenseTransferLimit ( ) const

◆ isDeviceTransferAllowed()

bool LicenseSpring::LicenseHandler::isDeviceTransferAllowed ( ) const

◆ isDeviceTransferLimited()

bool LicenseSpring::LicenseHandler::isDeviceTransferLimited ( ) const

◆ getLicensePolicyId()

uint32_t LicenseSpring::LicenseHandler::getLicensePolicyId ( ) const

◆ getLicenseTotalConsumption()

int32_t LicenseSpring::LicenseHandler::getLicenseTotalConsumption ( ) const

◆ getLicenseMaxConsumption()

int32_t LicenseSpring::LicenseHandler::getLicenseMaxConsumption ( ) const

◆ getLicenseMaxOverages()

int32_t LicenseSpring::LicenseHandler::getLicenseMaxOverages ( ) const

◆ isResetLicenseConsumptionEnabled()

bool LicenseSpring::LicenseHandler::isResetLicenseConsumptionEnabled ( ) const

◆ getLicenseConsumptionPeriod()

ConsumptionPeriod LicenseSpring::LicenseHandler::getLicenseConsumptionPeriod ( ) const

◆ getLicenseFloatingTimeout()

uint32_t LicenseSpring::LicenseHandler::getLicenseFloatingTimeout ( ) const

◆ getLicenseFloatingInUseCount()

uint32_t LicenseSpring::LicenseHandler::getLicenseFloatingInUseCount ( ) const

◆ getLicenseMaxFloatingUsers()

uint32_t LicenseSpring::LicenseHandler::getLicenseMaxFloatingUsers ( ) const

◆ getMaxBorrowTime()

uint32_t LicenseSpring::LicenseHandler::getMaxBorrowTime ( ) const

◆ 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: