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

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 }
382
383 #ifdef _MSC_VER
384 #pragma warning( pop )
385 #endif
386
387 #endif // LS_EXCEPTIONS_H
eTrialNotAllowed
Getting trial licenses is restricted by product license policy.
Definition: PODTypes.h:81
LicenseSpring::AirGapActivationException
Throws when confirmation code from the air gap activation portal is invalid.
Definition: Exceptions.h:144
LicenseSpring::DeviceNotLicensedException::DeviceNotLicensedException
DeviceNotLicensedException(const std::string &message)
Definition: Exceptions.h:90
LicenseSpring::LicenseNotFloatingException
This exception can arise during floating license registration on floating server. ...
Definition: Exceptions.h:306
LSErrorCode
LSErrorCode
LicenseSpring Error codes enum.
Definition: PODTypes.h:47
eUnknownError
Unknown error encountered.
Definition: PODTypes.h:50
LicenseSpring::UnknownLicenseSpringException::UnknownLicenseSpringException
UnknownLicenseSpringException(const std::string &message)
Definition: Exceptions.h:273
eRequestDateHeaderInvalid
Request DateTime header is invalid, please set correct date time on target device.
Definition: PODTypes.h:96
eSSOError
Customer account not found or SSO is not set up properly.
Definition: PODTypes.h:83
eCannotBeActivatedNow
Current date is behind license start date.
Definition: PODTypes.h:82
eLicenseSpringInternalError
Internal SDK error, please contact support or try to update SDK.
Definition: PODTypes.h:71
LicenseSpring::ProductMismatchException::ProductMismatchException
ProductMismatchException(const std::string &message)
Definition: Exceptions.h:191
eLocalLicenseError
SDK could not read or write license to the storage.
Definition: PODTypes.h:68
LicenseSpring::LicenseNotFoundException
Throws in case license not found on the server.
Definition: Exceptions.h:96
LicenseSpring::LicenseNotFoundException::LicenseNotFoundException
LicenseNotFoundException(const std::string &message)
Definition: Exceptions.h:99
LicenseSpring
Definition: BaseManager.h:15
eSignatureMismatchError
Server signature is not valid.
Definition: PODTypes.h:67
LicenseSpring::ApiKeyException::ApiKeyException
ApiKeyException(const std::string &message, LSErrorCode errorCode)
Definition: Exceptions.h:361
LicenseSpring::BorrowLicenseException
This exception can arise if provided borrowing period bigger than max possible. Or if license borrowi...
Definition: Exceptions.h:350
eInvalidConfirmationCode
Air gap confirmation code is invalid.
Definition: PODTypes.h:95
LicenseSpring::NetworkTimeoutException
This exception means that network operation timed out.
Definition: Exceptions.h:42
APIDef.h
LicenseSpring::ProductVersionException::ProductVersionException
ProductVersionException(const std::string &message)
Definition: Exceptions.h:117
LicenseSpring::ProductMismatchException
This exceptions means that license product code doesn&#39;t correspond to configuration product code...
Definition: Exceptions.h:188
eLicenseNoAvailableActivations
The license has already been activated maximum number of times.
Definition: PODTypes.h:75
eActivationFailed
Internal server error.
Definition: PODTypes.h:58
eLicenseNotFound
License not found.
Definition: PODTypes.h:54
eInvalidCredential
Username does not exist or wrong password provided.
Definition: PODTypes.h:70
LicenseSpring::UnknownLicenseSpringException
In case LicenseSpring backend returns unexpected error or something went wrong.
Definition: Exceptions.h:270
LicenseSpring::InvalidCredentialException
This exception means that user or password is wrong.
Definition: Exceptions.h:224
eInvalidOrderIDError
Order with specified ID already exists and ShouldAppend flag set to false.
Definition: PODTypes.h:73
eFloatingTimeoutExpired
Floating license borrowing period or floating timeout expired.
Definition: PODTypes.h:93
LicenseSpring::InvalidLicenseFeatureException::InvalidLicenseFeatureException
InvalidLicenseFeatureException(const std::string &message)
Definition: Exceptions.h:254
eNoInternetError
Problems with Internet connection.
Definition: PODTypes.h:63
LicenseSpring::LicenseNoAvailableActivationsException::LicenseNoAvailableActivationsException
LicenseNoAvailableActivationsException(const std::string &message)
Definition: Exceptions.h:138
LicenseSpring::MissingEmailException::MissingEmailException
MissingEmailException(const std::string &message)
Definition: Exceptions.h:236
LicenseSpring::DeviceNotLicensedException
Throws in case computer hardware configuration has been changed or license does not belong to this co...
Definition: Exceptions.h:87
LicenseSpring::InvalidCredentialException::InvalidCredentialException
InvalidCredentialException(const std::string &message)
Definition: Exceptions.h:227
eClockTamperedError
Detected that system clock has been set back.
Definition: PODTypes.h:69
LicenseSpring::LicenseSpringInternalException::LicenseSpringInternalException
LicenseSpringInternalException(const std::string &message)
Definition: Exceptions.h:263
LicenseSpring::VMDNotAvailableException
Windows only. In case VM detection dll not found, tempered or detection failed.
Definition: Exceptions.h:287
LicenseSpring::SignatureMismatchException::SignatureMismatchException
SignatureMismatchException(const std::string &message)
Definition: Exceptions.h:200
eMissingEmailError
Missing email in API call for user-based product, probably attempt to get trial license with empty em...
Definition: PODTypes.h:72
eNetworkTimeoutError
Request to the backend has timed out.
Definition: PODTypes.h:64
LicenseSpring::MaxFloatingReachedException::MaxFloatingReachedException
MaxFloatingReachedException(const std::string &message)
Definition: Exceptions.h:300
LicenseSpring::LicenseStateException
Throws in case license is in invalid state (disabled, epired or inactive).
Definition: Exceptions.h:69
LicenseSpring::LocalLicenseException
This exception means that SDK could not read or write license to the storage.
Definition: Exceptions.h:206
LicenseSpring::InvalidLicenseFeatureException
Throws when product feature does not exist or wrong feature type.
Definition: Exceptions.h:251
eVMDNotAvailable
Windows only, in case VM detection dll not found or tempered.
Definition: PODTypes.h:88
ePasswordChangeNotAllowed
Password change is restricted by product policy.
Definition: PODTypes.h:80
eWatchdogError
Failed to set license watchdog.
Definition: PODTypes.h:94
LicenseSpring::DeviceBlacklistedException::DeviceBlacklistedException
DeviceBlacklistedException(const std::string &message)
Definition: Exceptions.h:318
LicenseSpring::CannotBeActivatedNowException
Can be thrown if start date field is set for the license and current date is behind start date...
Definition: Exceptions.h:154
LicenseSpring::LicenseSpringException::getCode
LSErrorCode getCode() const
Definition: Exceptions.h:25
LicenseSpring::ClockTamperedException
This exception means that detected that system clock has been set back.
Definition: Exceptions.h:215
LicenseSpring::PasswordChangeNotAllowedException::PasswordChangeNotAllowedException
PasswordChangeNotAllowedException(const std::string &message)
Definition: Exceptions.h:327
LicenseSpring::MaxFloatingReachedException
This exception can arise during online check of floating license if reached maximum users count for t...
Definition: Exceptions.h:297
LicenseSpring::ConfigurationException::ConfigurationException
ConfigurationException(const std::string &message)
Definition: Exceptions.h:54
LicenseSpring::VMDNotAvailableException::VMDNotAvailableException
VMDNotAvailableException(const std::string &message)
Definition: Exceptions.h:290
eInitializationError
Invalid Configuration settings.
Definition: PODTypes.h:53
LicenseSpring::WatchdogException
This exception can arise if setting license watchdog failed.
Definition: Exceptions.h:366
eDeviceBlacklisted
Device has been added to the blacklist by admin on LicenseSpring platform.
Definition: PODTypes.h:79
LicenseSpring::LicenseServerException::LicenseServerException
LicenseServerException(const std::string &message)
Definition: Exceptions.h:165
LicenseSpring::VMIsNotAllowedException::VMIsNotAllowedException
VMIsNotAllowedException(const std::string &message)
Definition: Exceptions.h:282
LicenseSpring::SignatureMismatchException
Throws in case signature returned by LicenseSpring server is not valid.
Definition: Exceptions.h:197
LicenseSpring::LicenseSpringException::m_errorCode
LSErrorCode m_errorCode
Definition: Exceptions.h:27
LicenseSpring::LicenseSpringInternalException
Please, contact support or try to update SDK if you got this exception. Normally should never happen...
Definition: Exceptions.h:260
LicenseSpring::AuthorizationException
Authorization failed, please check your proxy settings.
Definition: Exceptions.h:170
LicenseSpring::RequestDateInvalidException::RequestDateInvalidException
RequestDateInvalidException(const std::string &message)
Definition: Exceptions.h:378
eMaxFloatingReached
Reached max users count for floating license.
Definition: PODTypes.h:77
eInvalidLicenseFeatureError
Feature does not exist or wrong feature type.
Definition: PODTypes.h:74
LicenseSpring::CannotBeActivatedNowException::CannotBeActivatedNowException
CannotBeActivatedNowException(const std::string &message)
Definition: Exceptions.h:157
LicenseSpring::ProductNotFoundException::ProductNotFoundException
ProductNotFoundException(const std::string &message)
Definition: Exceptions.h:108
LicenseSpring::LicenseSpringException
Base class for all LicenseSpring exceptions.
Definition: Exceptions.h:18
LicenseSpring::NoInternetException
This exception means that SDK cannot reach the server. Because of no internet connection, DNS issues, etc.
Definition: Exceptions.h:32
LicenseSpring::FloatingTimeoutExpiredException::FloatingTimeoutExpiredException
FloatingTimeoutExpiredException(const std::string &message)
Definition: Exceptions.h:81
LicenseSpring::LicenseNoAvailableActivationsException
Throws when license has already been activated maximum number of times.
Definition: Exceptions.h:135
eLicenseNotFloating
The license is not floating.
Definition: PODTypes.h:78
LicenseSpring::AirGapActivationException::AirGapActivationException
AirGapActivationException(const std::string &message)
Definition: Exceptions.h:147
LicenseSpring::LicenseServerException
Indicates internal server error, please contact support if you face this exception.
Definition: Exceptions.h:162
LicenseSpring::NotEnoughConsumptionException
This exceptions means that Consumption license or feature ran out of resources.
Definition: Exceptions.h:179
LicenseSpring::SSOTokenException
This exception can arise if token for Single sign-on (SSO) is invalid or expired. ...
Definition: Exceptions.h:341
LicenseSpring::TrialNotAllowedException::TrialNotAllowedException
TrialNotAllowedException(const std::string &message)
Definition: Exceptions.h:63
LicenseSpring::LicenseActivationException::LicenseActivationException
LicenseActivationException(const std::string &message)
Definition: Exceptions.h:129
LicenseSpring::InvalidOrderIDException::InvalidOrderIDException
InvalidOrderIDException(const std::string &message)
Definition: Exceptions.h:245
LicenseSpring::InvalidOrderIDException
Throws when order with specified ID already exists and ShouldAppend flag set to false.
Definition: Exceptions.h:242
LicenseSpring::MissingEmailException
Throws when email is missing in API call for user-based product, probably attempt to get trial licens...
Definition: Exceptions.h:233
LicenseSpring::LicenseNotFloatingException::LicenseNotFloatingException
LicenseNotFloatingException(const std::string &message)
Definition: Exceptions.h:309
LicenseSpring::TrialNotAllowedException
Can be thrown in case getting trial licenses is restricted by product license policy.
Definition: Exceptions.h:60
eGeneralLSError
General LicenseSpring error.
Definition: PODTypes.h:52
LicenseSpring::VMIsNotAllowedException
This exception can arise on virtual machine when VM detection is enabled but product policy prohibits...
Definition: Exceptions.h:279
LicenseSpring::ProductVersionException
Throws in case installation file not found for requested app version.
Definition: Exceptions.h:114
eVersionError
App version not found on the backend.
Definition: PODTypes.h:61
LicenseSpring::ConfigurationException
Throws in case of something wrong with Configuration. E.g. wrong API or Shared key.
Definition: Exceptions.h:51
LicenseSpring::LicenseSpringException::LicenseSpringException
LicenseSpringException(const std::string &message, LSErrorCode errorCode=LSErrorCode::eGeneralLSError)
Definition: Exceptions.h:21
LicenseSpring::SSOTokenException::SSOTokenException
SSOTokenException(const std::string &message)
Definition: Exceptions.h:344
LicenseSpring::AuthorizationException::AuthorizationException
AuthorizationException(const std::string &message)
Definition: Exceptions.h:173
eNotEnoughConsumptionError
Consumption license or feature run out of resources.
Definition: PODTypes.h:65
LicenseSpring::SSOException::SSOException
SSOException(const std::string &message)
Definition: Exceptions.h:336
LicenseSpring::NetworkTimeoutException::NetworkTimeoutException
NetworkTimeoutException(const std::string &message)
Definition: Exceptions.h:45
eDeviceError
Device from which the call is made is not licensed (Hardware ID mismatch)
Definition: PODTypes.h:60
LicenseSpring::LicenseStateException::LicenseStateException
LicenseStateException(const std::string &message, LSErrorCode errorCode)
Definition: Exceptions.h:72
LicenseSpring::SSOException
This exception can arise if the backend cannot create URL for Single sign-on (SSO) ...
Definition: Exceptions.h:333
LicenseSpring::ProductNotFoundException
Throws in case product not found on the server.
Definition: Exceptions.h:105
LicenseSpring::NoInternetException::NoInternetException
NoInternetException(const std::string &message)
Definition: Exceptions.h:35
eVMNotAllowed
Running on Virtual machine not allowed.
Definition: PODTypes.h:76
eProductMismatchError
License product code doesn&#39;t correspond to configuration product code.
Definition: PODTypes.h:66
eProductError
Product not found on the backend.
Definition: PODTypes.h:62
LicenseSpring::BorrowLicenseException::BorrowLicenseException
BorrowLicenseException(const std::string &message, LSErrorCode errorCode)
Definition: Exceptions.h:353
eSSOTokenError
Token for SSO is not valid or expired.
Definition: PODTypes.h:84
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
LicenseSpring::FloatingTimeoutExpiredException
Throws in case floating license timeout or borrowing period is expired and it needs to be registered...
Definition: Exceptions.h:78
LicenseSpring::ClockTamperedException::ClockTamperedException
ClockTamperedException(const std::string &message)
Definition: Exceptions.h:218
PODTypes.h
LicenseSpring::LicenseActivationException
Rare exception, can arise if activation is limited to some device count or license transfer is prohib...
Definition: Exceptions.h:126
LicenseSpring::PasswordChangeNotAllowedException
This exception can arise if password change is restricted by company policy.
Definition: Exceptions.h:324
LicenseSpring::WatchdogException::WatchdogException
WatchdogException(const std::string &message)
Definition: Exceptions.h:369
LicenseSpring::DeviceBlacklistedException
This exception can arise during license check if device has been blacklisted by Product manager...
Definition: Exceptions.h:315
LicenseSpring::NotEnoughConsumptionException::NotEnoughConsumptionException
NotEnoughConsumptionException(const std::string &message)
Definition: Exceptions.h:182
LicenseSpring::RequestDateInvalidException
This exception can arise if system date time on the current device is incorrectly set...
Definition: Exceptions.h:375
LicenseSpring::LocalLicenseException::LocalLicenseException
LocalLicenseException(const std::string &message)
Definition: Exceptions.h:209
LicenseSpring::ApiKeyException
This exception can arise if provided api key cannot be used for the request.
Definition: Exceptions.h:358
eAuthorizationError
Authorization failed.
Definition: PODTypes.h:87
eServerError
Internal server error.
Definition: PODTypes.h:59