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

Loading...
Searching...
No Matches
Exceptions.h
Go to the documentation of this file.
1#ifndef LS_EXCEPTIONS_H
2#define LS_EXCEPTIONS_H
3
4#ifdef _MSC_VER
5#pragma once
6#pragma warning( push )
7#pragma warning( disable : 4275 )
8#endif
9
10#include <stdexcept>
11#include <string>
12#include "APIDef.h"
13#include "PODTypes.h"
14
15 namespace LicenseSpring
16{
18 class LS_API LicenseSpringException : public std::runtime_error
19 {
20 public:
21 LicenseSpringException( const std::string& message, LSErrorCode errorCode = LSErrorCode::eGeneralLSError )
22 : std::runtime_error( message.c_str() )
23 , m_errorCode( errorCode )
24 {}
25 LSErrorCode getCode() const { return m_errorCode; }
26 protected:
27 LSErrorCode m_errorCode;
28 };
29
30
32 class LS_API NoInternetException : public LicenseSpringException
33 {
34 public:
35 NoInternetException( const std::string& message )
36 : LicenseSpringException( message, LSErrorCode::eNoInternetError ) {}
37 };
38
39
42 class LS_API NetworkTimeoutException : public LicenseSpringException
43 {
44 public:
45 NetworkTimeoutException( const std::string& message )
46 : LicenseSpringException( message, LSErrorCode::eNetworkTimeoutError ) {}
47 };
48
49
51 class LS_API ConfigurationException : public LicenseSpringException
52 {
53 public:
54 ConfigurationException( const std::string& message )
55 : LicenseSpringException( message, LSErrorCode::eInitializationError ) {}
56 };
57
58
60 class LS_API TrialNotAllowedException : public LicenseSpringException
61 {
62 public:
63 TrialNotAllowedException( const std::string& message )
64 : LicenseSpringException( message, LSErrorCode::eTrialNotAllowed ) {}
65 };
66
67
69 class LS_API LicenseStateException : public LicenseSpringException
70 {
71 public:
72 LicenseStateException( const std::string& message, LSErrorCode errorCode )
73 : LicenseSpringException( message, errorCode ) {}
74 };
75
76
78 class LS_API FloatingTimeoutExpiredException : public LicenseStateException
79 {
80 public:
81 FloatingTimeoutExpiredException( const std::string& message )
82 : LicenseStateException( message, LSErrorCode::eFloatingTimeoutExpired ) {}
83 };
84
85
87 class LS_API DeviceNotLicensedException : public LicenseSpringException
88 {
89 public:
90 DeviceNotLicensedException( const std::string& message )
91 : LicenseSpringException( message, LSErrorCode::eDeviceError ) {}
92 };
93
94
96 class LS_API LicenseNotFoundException : public LicenseSpringException
97 {
98 public:
99 LicenseNotFoundException( const std::string& message )
100 : LicenseSpringException( message, LSErrorCode::eLicenseNotFound ) {}
101 };
102
103
105 class LS_API ProductNotFoundException : public LicenseSpringException
106 {
107 public:
108 ProductNotFoundException( const std::string& message )
109 : LicenseSpringException( message, LSErrorCode::eProductError ) {}
110 };
111
112
114 class LS_API ProductVersionException : public LicenseSpringException
115 {
116 public:
117 ProductVersionException( const std::string& message )
118 : LicenseSpringException( message, LSErrorCode::eVersionError ) {}
119 };
120
121
126 class LS_API LicenseActivationException : public LicenseSpringException
127 {
128 public:
129 LicenseActivationException( const std::string& message )
130 : LicenseSpringException( message, LSErrorCode::eActivationFailed ) {}
131 };
132
133
135 class LS_API LicenseNoAvailableActivationsException : public LicenseActivationException
136 {
137 public:
138 LicenseNoAvailableActivationsException( const std::string& message )
139 : LicenseActivationException( message ) { m_errorCode = eLicenseNoAvailableActivations; }
140 };
141
142
144 class LS_API AirGapActivationException : public LicenseActivationException
145 {
146 public:
147 AirGapActivationException( const std::string& message )
148 : LicenseActivationException( message ) { m_errorCode = eInvalidConfirmationCode; }
149 };
150
151
154 class LS_API CannotBeActivatedNowException : public LicenseActivationException
155 {
156 public:
157 CannotBeActivatedNowException( const std::string& message )
158 : LicenseActivationException( message ) { m_errorCode = eCannotBeActivatedNow; }
159 };
160
162 class LS_API LicenseServerException : public LicenseSpringException
163 {
164 public:
165 LicenseServerException( const std::string& message )
166 : LicenseSpringException( message, LSErrorCode::eServerError ) {}
167 };
168
170 class LS_API AuthorizationException : public LicenseSpringException
171 {
172 public:
173 AuthorizationException( const std::string& message )
174 : LicenseSpringException( message, LSErrorCode::eAuthorizationError )
175 {}
176 };
177
179 class LS_API NotEnoughConsumptionException : public LicenseSpringException
180 {
181 public:
182 NotEnoughConsumptionException( const std::string& message )
183 : LicenseSpringException( message, LSErrorCode::eNotEnoughConsumptionError ) {}
184 };
185
186
188 class LS_API ProductMismatchException : public LicenseSpringException
189 {
190 public:
191 ProductMismatchException( const std::string& message )
192 : LicenseSpringException( message, LSErrorCode::eProductMismatchError ) {}
193 };
194
195
197 class LS_API SignatureMismatchException : public LicenseSpringException
198 {
199 public:
200 SignatureMismatchException( const std::string& message )
201 : LicenseSpringException( message, LSErrorCode::eSignatureMismatchError ) {}
202 };
203
204
206 class LS_API LocalLicenseException : public LicenseSpringException
207 {
208 public:
209 LocalLicenseException( const std::string& message )
210 : LicenseSpringException( message, LSErrorCode::eLocalLicenseError ) {}
211 };
212
213
215 class LS_API ClockTamperedException : public LicenseSpringException
216 {
217 public:
218 ClockTamperedException( const std::string& message )
219 : LicenseSpringException( message, LSErrorCode::eClockTamperedError ) {}
220 };
221
222
224 class LS_API InvalidCredentialException : public LicenseSpringException
225 {
226 public:
227 InvalidCredentialException( const std::string& message )
228 : LicenseSpringException( message, LSErrorCode::eInvalidCredential ) {}
229 };
230
231
233 class LS_API MissingEmailException : public LicenseSpringException
234 {
235 public:
236 MissingEmailException( const std::string& message )
237 : LicenseSpringException( message, LSErrorCode::eMissingEmailError ) {}
238 };
239
240
242 class LS_API InvalidOrderIDException : public LicenseSpringException
243 {
244 public:
245 InvalidOrderIDException( const std::string& message )
246 : LicenseSpringException( message, LSErrorCode::eInvalidOrderIDError ) {}
247 };
248
249
251 class LS_API InvalidLicenseFeatureException : public LicenseSpringException
252 {
253 public:
254 InvalidLicenseFeatureException( const std::string& message )
255 : LicenseSpringException( message, LSErrorCode::eInvalidLicenseFeatureError ) {}
256 };
257
258
260 class LS_API LicenseSpringInternalException : public LicenseSpringException
261 {
262 public:
263 LicenseSpringInternalException( const std::string& message )
264 : LicenseSpringException( message, LSErrorCode::eLicenseSpringInternalError ) {}
265 };
266
267
270 class LS_API UnknownLicenseSpringException : public LicenseSpringException
271 {
272 public:
273 UnknownLicenseSpringException( const std::string& message )
274 : LicenseSpringException( message, LSErrorCode::eUnknownError ) {}
275 };
276
277
279 class LS_API VMIsNotAllowedException : public LicenseSpringException
280 {
281 public:
282 VMIsNotAllowedException( const std::string& message )
283 : LicenseSpringException( message, LSErrorCode::eVMNotAllowed ) {}
284 };
285
287 class LS_API VMDNotAvailableException : public LicenseSpringException
288 {
289 public:
290 VMDNotAvailableException( const std::string& message )
291 : LicenseSpringException( message, LSErrorCode::eVMDNotAvailable )
292 {
293 }
294 };
295
297 class LS_API MaxFloatingReachedException : public LicenseSpringException
298 {
299 public:
300 MaxFloatingReachedException( const std::string& message )
301 : LicenseSpringException( message, LSErrorCode::eMaxFloatingReached ) {}
302 };
303
304
306 class LS_API LicenseNotFloatingException : public LicenseSpringException
307 {
308 public:
309 LicenseNotFloatingException( const std::string& message )
310 : LicenseSpringException( message, LSErrorCode::eLicenseNotFloating ) {}
311 };
312
313
315 class LS_API DeviceBlacklistedException : public LicenseSpringException
316 {
317 public:
318 DeviceBlacklistedException( const std::string& message )
319 : LicenseSpringException( message, LSErrorCode::eDeviceBlacklisted ) {}
320 };
321
324 class LS_API PasswordChangeNotAllowedException : public LicenseSpringException
325 {
326 public:
327 PasswordChangeNotAllowedException( const std::string& message )
328 : LicenseSpringException( message, LSErrorCode::ePasswordChangeNotAllowed ) {}
329 };
330
333 class LS_API SSOException : public LicenseSpringException
334 {
335 public:
336 SSOException( const std::string& message )
337 : LicenseSpringException( message, LSErrorCode::eSSOError ) {}
338 };
339
341 class LS_API SSOTokenException : public SSOException
342 {
343 public:
344 SSOTokenException( const std::string& message )
345 : SSOException( message ) { m_errorCode = eSSOTokenError; }
346 };
347
350 class LS_API BorrowLicenseException : public LicenseSpringException
351 {
352 public:
353 BorrowLicenseException( const std::string& message, LSErrorCode errorCode )
354 : LicenseSpringException( message, errorCode ) {}
355 };
356
358 class LS_API ApiKeyException : public LicenseSpringException
359 {
360 public:
361 ApiKeyException( const std::string& message, LSErrorCode errorCode )
362 : LicenseSpringException( message, errorCode ) {}
363 };
364
366 class LS_API WatchdogException : public LicenseSpringException
367 {
368 public:
369 WatchdogException( const std::string& message )
370 : LicenseSpringException( message, LSErrorCode::eWatchdogError ) {}
371 };
372
373
375 class LS_API RequestDateInvalidException : public LicenseSpringException
376 {
377 public:
378 RequestDateInvalidException( const std::string& message )
379 : LicenseSpringException( message, LSErrorCode::eRequestDateHeaderInvalid ) {}
380 };
381
383 class LS_API InvalidLicenseFeatureCodeException : public LicenseSpringException
384 {
385 public:
386 InvalidLicenseFeatureCodeException( const std::string& message )
387 : LicenseSpringException( message, LSErrorCode::eInvalidLicenseFeatureCode ) {}
388 };
389
391 class LS_API FeatureNotFloatingException : public LicenseSpringException
392 {
393 public:
394 FeatureNotFloatingException( const std::string& message )
395 : LicenseSpringException( message, LSErrorCode::eFeatureNotFloating ) {}
396 };
397
399 class LS_API FloatingFeatureDeviceNotInUseException : public LicenseSpringException
400 {
401 public:
402 FloatingFeatureDeviceNotInUseException( const std::string& message )
403 : LicenseSpringException( message, LSErrorCode::eFloatingFeatureDeviceNotInUse ) {}
404 };
405}
406
407#ifdef _MSC_VER
408#pragma warning( pop )
409#endif
410
411#endif // LS_EXCEPTIONS_H
APIDef.h
LS_API
#define LS_API
Macros that expands to dllexport, dllimport or nothing on non Windows platforms or in case of static ...
Definition APIDef.h:22
PODTypes.h
LSErrorCode
LSErrorCode
LicenseSpring Error codes enum.
Definition PODTypes.h:48
eLicenseNotFound
@ eLicenseNotFound
License not found.
Definition PODTypes.h:54
eNotEnoughConsumptionError
@ eNotEnoughConsumptionError
Consumption license or feature run out of resources.
Definition PODTypes.h:65
eInvalidCredential
@ eInvalidCredential
Username does not exist or wrong password provided.
Definition PODTypes.h:70
eWatchdogError
@ eWatchdogError
Failed to set license watchdog.
Definition PODTypes.h:94
eTrialNotAllowed
@ eTrialNotAllowed
Getting trial licenses is restricted by product license policy.
Definition PODTypes.h:81
eFloatingFeatureDeviceNotInUse
@ eFloatingFeatureDeviceNotInUse
Device was never used to check out a floating feature.
Definition PODTypes.h:99
eServerError
@ eServerError
Internal server error.
Definition PODTypes.h:59
eInvalidConfirmationCode
@ eInvalidConfirmationCode
Air gap confirmation code is invalid.
Definition PODTypes.h:95
eSSOTokenError
@ eSSOTokenError
Token for SSO is not valid or expired.
Definition PODTypes.h:84
eInvalidLicenseFeatureError
@ eInvalidLicenseFeatureError
Feature does not exist or wrong feature type.
Definition PODTypes.h:74
eInvalidLicenseFeatureCode
@ eInvalidLicenseFeatureCode
Feature code not found on license.
Definition PODTypes.h:97
eLicenseSpringInternalError
@ eLicenseSpringInternalError
Internal SDK error, please contact support or try to update SDK.
Definition PODTypes.h:71
eDeviceError
@ eDeviceError
Device from which the call is made is not licensed (Hardware ID mismatch)
Definition PODTypes.h:60
eProductMismatchError
@ eProductMismatchError
License product code doesn't correspond to configuration product code.
Definition PODTypes.h:66
eClockTamperedError
@ eClockTamperedError
Detected that system clock has been set back.
Definition PODTypes.h:69
eDeviceBlacklisted
@ eDeviceBlacklisted
Device has been added to the blacklist by admin on LicenseSpring platform.
Definition PODTypes.h:79
eInvalidOrderIDError
@ eInvalidOrderIDError
Order with specified ID already exists and ShouldAppend flag set to false.
Definition PODTypes.h:73
eSignatureMismatchError
@ eSignatureMismatchError
Server signature is not valid.
Definition PODTypes.h:67
eLicenseNotFloating
@ eLicenseNotFloating
The license is not floating.
Definition PODTypes.h:78
eFeatureNotFloating
@ eFeatureNotFloating
License feature that should be released is not a floating feature.
Definition PODTypes.h:98
eAuthorizationError
@ eAuthorizationError
Authorization failed.
Definition PODTypes.h:87
eNetworkTimeoutError
@ eNetworkTimeoutError
Request to the backend has timed out.
Definition PODTypes.h:64
eRequestDateHeaderInvalid
@ eRequestDateHeaderInvalid
Request DateTime header is invalid, please set correct date time on target device,...
Definition PODTypes.h:96
eVMDNotAvailable
@ eVMDNotAvailable
Windows only, in case VM detection dll not found or tempered.
Definition PODTypes.h:88
eNoInternetError
@ eNoInternetError
Problems with Internet connection.
Definition PODTypes.h:63
eLocalLicenseError
@ eLocalLicenseError
SDK could not read or write license to the storage.
Definition PODTypes.h:68
eVMNotAllowed
@ eVMNotAllowed
Running on Virtual machine not allowed.
Definition PODTypes.h:76
eGeneralLSError
@ eGeneralLSError
General LicenseSpring error.
Definition PODTypes.h:52
eVersionError
@ eVersionError
App version not found on the backend.
Definition PODTypes.h:61
eActivationFailed
@ eActivationFailed
Internal server error.
Definition PODTypes.h:58
ePasswordChangeNotAllowed
@ ePasswordChangeNotAllowed
Password change is restricted by product policy.
Definition PODTypes.h:80
eFloatingTimeoutExpired
@ eFloatingTimeoutExpired
Floating license borrowing period or floating timeout expired.
Definition PODTypes.h:93
eMissingEmailError
@ eMissingEmailError
Missing email in API call for user-based product, probably attempt to get trial license with empty em...
Definition PODTypes.h:72
eLicenseNoAvailableActivations
@ eLicenseNoAvailableActivations
The license has already been activated maximum number of times.
Definition PODTypes.h:75
eMaxFloatingReached
@ eMaxFloatingReached
Reached max users count for floating license.
Definition PODTypes.h:77
eInitializationError
@ eInitializationError
Invalid Configuration settings.
Definition PODTypes.h:53
eProductError
@ eProductError
Product not found on the backend.
Definition PODTypes.h:62
eCannotBeActivatedNow
@ eCannotBeActivatedNow
Current date is behind license start date.
Definition PODTypes.h:82
eUnknownError
@ eUnknownError
Unknown error encountered.
Definition PODTypes.h:50
eSSOError
@ eSSOError
Customer account not found or SSO is not set up properly.
Definition PODTypes.h:83
LicenseSpring::AirGapActivationException
Throws when confirmation code from the air gap activation portal is invalid.
Definition Exceptions.h:145
LicenseSpring::AirGapActivationException::AirGapActivationException
AirGapActivationException(const std::string &message)
Definition Exceptions.h:147
LicenseSpring::ApiKeyException
This exception can arise if provided api key cannot be used for the request.
Definition Exceptions.h:359
LicenseSpring::ApiKeyException::ApiKeyException
ApiKeyException(const std::string &message, LSErrorCode errorCode)
Definition Exceptions.h:361
LicenseSpring::AuthorizationException
Authorization failed, please check your proxy settings.
Definition Exceptions.h:171
LicenseSpring::AuthorizationException::AuthorizationException
AuthorizationException(const std::string &message)
Definition Exceptions.h:173
LicenseSpring::BorrowLicenseException
This exception can arise if provided borrowing period bigger than max possible. Or if license borrowi...
Definition Exceptions.h:351
LicenseSpring::BorrowLicenseException::BorrowLicenseException
BorrowLicenseException(const std::string &message, LSErrorCode errorCode)
Definition Exceptions.h:353
LicenseSpring::CannotBeActivatedNowException
Can be thrown if start date field is set for the license and current date is behind start date.
Definition Exceptions.h:155
LicenseSpring::CannotBeActivatedNowException::CannotBeActivatedNowException
CannotBeActivatedNowException(const std::string &message)
Definition Exceptions.h:157
LicenseSpring::ClockTamperedException
This exception means that detected that system clock has been set back.
Definition Exceptions.h:216
LicenseSpring::ClockTamperedException::ClockTamperedException
ClockTamperedException(const std::string &message)
Definition Exceptions.h:218
LicenseSpring::ConfigurationException
Throws in case of something wrong with Configuration. E.g. wrong API or Shared key.
Definition Exceptions.h:52
LicenseSpring::ConfigurationException::ConfigurationException
ConfigurationException(const std::string &message)
Definition Exceptions.h:54
LicenseSpring::DeviceBlacklistedException
This exception can arise during license check if device has been blacklisted by Product manager.
Definition Exceptions.h:316
LicenseSpring::DeviceBlacklistedException::DeviceBlacklistedException
DeviceBlacklistedException(const std::string &message)
Definition Exceptions.h:318
LicenseSpring::DeviceNotLicensedException
Throws in case computer hardware configuration has been changed or license does not belong to this co...
Definition Exceptions.h:88
LicenseSpring::DeviceNotLicensedException::DeviceNotLicensedException
DeviceNotLicensedException(const std::string &message)
Definition Exceptions.h:90
LicenseSpring::FeatureNotFloatingException
This exception can arise if releasing a device on a non-floating license feature.
Definition Exceptions.h:392
LicenseSpring::FeatureNotFloatingException::FeatureNotFloatingException
FeatureNotFloatingException(const std::string &message)
Definition Exceptions.h:394
LicenseSpring::FloatingFeatureDeviceNotInUseException
This exception can arise if device was never used to check a feature.
Definition Exceptions.h:400
LicenseSpring::FloatingFeatureDeviceNotInUseException::FloatingFeatureDeviceNotInUseException
FloatingFeatureDeviceNotInUseException(const std::string &message)
Definition Exceptions.h:402
LicenseSpring::FloatingTimeoutExpiredException
Throws in case floating license timeout or borrowing period is expired and it needs to be registered.
Definition Exceptions.h:79
LicenseSpring::FloatingTimeoutExpiredException::FloatingTimeoutExpiredException
FloatingTimeoutExpiredException(const std::string &message)
Definition Exceptions.h:81
LicenseSpring::InvalidCredentialException
This exception means that user or password is wrong.
Definition Exceptions.h:225
LicenseSpring::InvalidCredentialException::InvalidCredentialException
InvalidCredentialException(const std::string &message)
Definition Exceptions.h:227
LicenseSpring::InvalidLicenseFeatureCodeException
This exception can arise if the given feature code is not found on a license.
Definition Exceptions.h:384
LicenseSpring::InvalidLicenseFeatureCodeException::InvalidLicenseFeatureCodeException
InvalidLicenseFeatureCodeException(const std::string &message)
Definition Exceptions.h:386
LicenseSpring::InvalidLicenseFeatureException
Throws when product feature does not exist or wrong feature type.
Definition Exceptions.h:252
LicenseSpring::InvalidLicenseFeatureException::InvalidLicenseFeatureException
InvalidLicenseFeatureException(const std::string &message)
Definition Exceptions.h:254
LicenseSpring::InvalidOrderIDException
Throws when order with specified ID already exists and ShouldAppend flag set to false.
Definition Exceptions.h:243
LicenseSpring::InvalidOrderIDException::InvalidOrderIDException
InvalidOrderIDException(const std::string &message)
Definition Exceptions.h:245
LicenseSpring::LicenseActivationException
Rare exception, can arise if activation is limited to some device count or license transfer is prohib...
Definition Exceptions.h:127
LicenseSpring::LicenseActivationException::LicenseActivationException
LicenseActivationException(const std::string &message)
Definition Exceptions.h:129
LicenseSpring::LicenseNoAvailableActivationsException
Throws when license has already been activated maximum number of times.
Definition Exceptions.h:136
LicenseSpring::LicenseNoAvailableActivationsException::LicenseNoAvailableActivationsException
LicenseNoAvailableActivationsException(const std::string &message)
Definition Exceptions.h:138
LicenseSpring::LicenseNotFloatingException
This exception can arise during floating license registration on floating server.
Definition Exceptions.h:307
LicenseSpring::LicenseNotFloatingException::LicenseNotFloatingException
LicenseNotFloatingException(const std::string &message)
Definition Exceptions.h:309
LicenseSpring::LicenseNotFoundException
Throws in case license not found on the server.
Definition Exceptions.h:97
LicenseSpring::LicenseNotFoundException::LicenseNotFoundException
LicenseNotFoundException(const std::string &message)
Definition Exceptions.h:99
LicenseSpring::LicenseServerException
Indicates internal server error, please contact support if you face this exception.
Definition Exceptions.h:163
LicenseSpring::LicenseServerException::LicenseServerException
LicenseServerException(const std::string &message)
Definition Exceptions.h:165
LicenseSpring::LicenseSpringException
Base class for all LicenseSpring exceptions.
Definition Exceptions.h:19
LicenseSpring::LicenseSpringException::m_errorCode
LSErrorCode m_errorCode
Definition Exceptions.h:27
LicenseSpring::LicenseSpringException::getCode
LSErrorCode getCode() const
Definition Exceptions.h:25
LicenseSpring::LicenseSpringException::LicenseSpringException
LicenseSpringException(const std::string &message, LSErrorCode errorCode=LSErrorCode::eGeneralLSError)
Definition Exceptions.h:21
LicenseSpring::LicenseSpringInternalException
Please, contact support or try to update SDK if you got this exception. Normally should never happen.
Definition Exceptions.h:261
LicenseSpring::LicenseSpringInternalException::LicenseSpringInternalException
LicenseSpringInternalException(const std::string &message)
Definition Exceptions.h:263
LicenseSpring::LicenseStateException
Throws in case license is in invalid state (disabled, epired or inactive).
Definition Exceptions.h:70
LicenseSpring::LicenseStateException::LicenseStateException
LicenseStateException(const std::string &message, LSErrorCode errorCode)
Definition Exceptions.h:72
LicenseSpring::LocalLicenseException
This exception means that SDK could not read or write license to the storage.
Definition Exceptions.h:207
LicenseSpring::LocalLicenseException::LocalLicenseException
LocalLicenseException(const std::string &message)
Definition Exceptions.h:209
LicenseSpring::MaxFloatingReachedException
This exception can arise during online check of floating license if reached maximum users count for t...
Definition Exceptions.h:298
LicenseSpring::MaxFloatingReachedException::MaxFloatingReachedException
MaxFloatingReachedException(const std::string &message)
Definition Exceptions.h:300
LicenseSpring::MissingEmailException
Throws when email is missing in API call for user-based product, probably attempt to get trial licens...
Definition Exceptions.h:234
LicenseSpring::MissingEmailException::MissingEmailException
MissingEmailException(const std::string &message)
Definition Exceptions.h:236
LicenseSpring::NetworkTimeoutException
This exception means that network operation timed out.
Definition Exceptions.h:43
LicenseSpring::NetworkTimeoutException::NetworkTimeoutException
NetworkTimeoutException(const std::string &message)
Definition Exceptions.h:45
LicenseSpring::NoInternetException
This exception means that SDK cannot reach the server. Because of no internet connection,...
Definition Exceptions.h:33
LicenseSpring::NoInternetException::NoInternetException
NoInternetException(const std::string &message)
Definition Exceptions.h:35
LicenseSpring::NotEnoughConsumptionException
This exceptions means that Consumption license or feature ran out of resources.
Definition Exceptions.h:180
LicenseSpring::NotEnoughConsumptionException::NotEnoughConsumptionException
NotEnoughConsumptionException(const std::string &message)
Definition Exceptions.h:182
LicenseSpring::PasswordChangeNotAllowedException
This exception can arise if password change is restricted by company policy.
Definition Exceptions.h:325
LicenseSpring::PasswordChangeNotAllowedException::PasswordChangeNotAllowedException
PasswordChangeNotAllowedException(const std::string &message)
Definition Exceptions.h:327
LicenseSpring::ProductMismatchException
This exceptions means that license product code doesn't correspond to configuration product code.
Definition Exceptions.h:189
LicenseSpring::ProductMismatchException::ProductMismatchException
ProductMismatchException(const std::string &message)
Definition Exceptions.h:191
LicenseSpring::ProductNotFoundException
Throws in case product not found on the server.
Definition Exceptions.h:106
LicenseSpring::ProductNotFoundException::ProductNotFoundException
ProductNotFoundException(const std::string &message)
Definition Exceptions.h:108
LicenseSpring::ProductVersionException
Throws in case installation file not found for requested app version.
Definition Exceptions.h:115
LicenseSpring::ProductVersionException::ProductVersionException
ProductVersionException(const std::string &message)
Definition Exceptions.h:117
LicenseSpring::RequestDateInvalidException
This exception can arise if system date time on the current device is incorrectly set.
Definition Exceptions.h:376
LicenseSpring::RequestDateInvalidException::RequestDateInvalidException
RequestDateInvalidException(const std::string &message)
Definition Exceptions.h:378
LicenseSpring::SSOException
This exception can arise if the backend cannot create URL for Single sign-on (SSO)
Definition Exceptions.h:334
LicenseSpring::SSOException::SSOException
SSOException(const std::string &message)
Definition Exceptions.h:336
LicenseSpring::SSOTokenException
This exception can arise if token for Single sign-on (SSO) is invalid or expired.
Definition Exceptions.h:342
LicenseSpring::SSOTokenException::SSOTokenException
SSOTokenException(const std::string &message)
Definition Exceptions.h:344
LicenseSpring::SignatureMismatchException
Throws in case signature returned by LicenseSpring server is not valid.
Definition Exceptions.h:198
LicenseSpring::SignatureMismatchException::SignatureMismatchException
SignatureMismatchException(const std::string &message)
Definition Exceptions.h:200
LicenseSpring::TrialNotAllowedException
Can be thrown in case getting trial licenses is restricted by product license policy.
Definition Exceptions.h:61
LicenseSpring::TrialNotAllowedException::TrialNotAllowedException
TrialNotAllowedException(const std::string &message)
Definition Exceptions.h:63
LicenseSpring::UnknownLicenseSpringException
In case LicenseSpring backend returns unexpected error or something went wrong.
Definition Exceptions.h:271
LicenseSpring::UnknownLicenseSpringException::UnknownLicenseSpringException
UnknownLicenseSpringException(const std::string &message)
Definition Exceptions.h:273
LicenseSpring::VMDNotAvailableException
Windows only. In case VM detection dll not found, tempered or detection failed.
Definition Exceptions.h:288
LicenseSpring::VMDNotAvailableException::VMDNotAvailableException
VMDNotAvailableException(const std::string &message)
Definition Exceptions.h:290
LicenseSpring::VMIsNotAllowedException
This exception can arise on virtual machine when VM detection is enabled but product policy prohibits...
Definition Exceptions.h:280
LicenseSpring::VMIsNotAllowedException::VMIsNotAllowedException
VMIsNotAllowedException(const std::string &message)
Definition Exceptions.h:282
LicenseSpring::WatchdogException
This exception can arise if setting license watchdog failed.
Definition Exceptions.h:367
LicenseSpring::WatchdogException::WatchdogException
WatchdogException(const std::string &message)
Definition Exceptions.h:369
LicenseSpring
Definition BaseManager.h:16