VMware Tanzu GemFire Native C++ Reference  10.1.5
ExceptionTypes.hpp
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #pragma once
19 
20 #ifndef GEODE_EXCEPTIONTYPES_H_
21 #define GEODE_EXCEPTIONTYPES_H_
22 
23 #include "geode/Exception.hpp"
24 #include "internal/geode_globals.hpp"
25 
26 namespace apache {
27 namespace geode {
28 namespace client {
29 
30 /*
31  *
32  * This is the list of exceptions directly derived from
33  * apache::geode::client::Exception.
34  *
35  */
36 
40 class APACHE_GEODE_EXPORT AssertionException : public Exception {
41  public:
42  using Exception::Exception;
43  ~AssertionException() noexcept override {}
44  std::string getName() const override {
45  return "apache::geode::client::AssertionException";
46  }
47 };
48 
52 class APACHE_GEODE_EXPORT IllegalArgumentException : public Exception {
53  public:
54  using Exception::Exception;
55  ~IllegalArgumentException() noexcept override {}
56  std::string getName() const override {
57  return "apache::geode::client::IllegalArgumentException";
58  }
59 };
60 
64 class APACHE_GEODE_EXPORT IllegalStateException : public Exception {
65  public:
66  using Exception::Exception;
67  ~IllegalStateException() noexcept override {}
68  std::string getName() const override {
69  return "apache::geode::client::IllegalStateException";
70  }
71 };
72 
76 class APACHE_GEODE_EXPORT CacheExistsException : public Exception {
77  public:
78  using Exception::Exception;
79  ~CacheExistsException() noexcept override {}
80  std::string getName() const override {
81  return "apache::geode::client::CacheExistsException";
82  }
83 };
84 
88 class APACHE_GEODE_EXPORT CacheXmlException : public Exception {
89  public:
90  using Exception::Exception;
91  ~CacheXmlException() noexcept override {}
92  std::string getName() const override {
93  return "apache::geode::client::CacheXmlException";
94  }
95 };
99 class APACHE_GEODE_EXPORT TimeoutException : public Exception {
100  public:
101  using Exception::Exception;
102  ~TimeoutException() noexcept override {}
103  std::string getName() const override {
104  return "apache::geode::client::TimeoutException";
105  }
106 };
107 
111 class APACHE_GEODE_EXPORT CacheWriterException : public Exception {
112  public:
113  using Exception::Exception;
114  ~CacheWriterException() noexcept override {}
115  std::string getName() const override {
116  return "apache::geode::client::CacheWriterException";
117  }
118 };
119 
123 class APACHE_GEODE_EXPORT RegionExistsException : public Exception {
124  public:
125  using Exception::Exception;
126  ~RegionExistsException() noexcept override {}
127  std::string getName() const override {
128  return "apache::geode::client::RegionExistsException";
129  }
130 };
131 
135 class APACHE_GEODE_EXPORT CacheClosedException : public Exception {
136  public:
137  using Exception::Exception;
138  ~CacheClosedException() noexcept override {}
139  std::string getName() const override {
140  return "apache::geode::client::CacheClosedException";
141  }
142 };
143 
147 class APACHE_GEODE_EXPORT LeaseExpiredException : public Exception {
148  public:
149  using Exception::Exception;
150  ~LeaseExpiredException() noexcept override {}
151  std::string getName() const override {
152  return "apache::geode::client::LeaseExpiredException";
153  }
154 };
155 
159 class APACHE_GEODE_EXPORT CacheLoaderException : public Exception {
160  public:
161  using Exception::Exception;
162  ~CacheLoaderException() noexcept override {}
163  std::string getName() const override {
164  return "apache::geode::client::CacheLoaderException";
165  }
166 };
167 
171 class APACHE_GEODE_EXPORT RegionDestroyedException : public Exception {
172  public:
173  using Exception::Exception;
174  ~RegionDestroyedException() noexcept override {}
175  std::string getName() const override {
176  return "apache::geode::client::RegionDestroyedException";
177  }
178 };
179 
183 class APACHE_GEODE_EXPORT EntryDestroyedException : public Exception {
184  public:
185  using Exception::Exception;
186  ~EntryDestroyedException() noexcept override {}
187  std::string getName() const override {
188  return "apache::geode::client::EntryDestroyedException";
189  }
190 };
191 
195 class APACHE_GEODE_EXPORT NoSystemException : public Exception {
196  public:
197  using Exception::Exception;
198  ~NoSystemException() noexcept override {}
199  std::string getName() const override {
200  return "apache::geode::client::NoSystemException";
201  }
202 };
203 
208 class APACHE_GEODE_EXPORT AlreadyConnectedException : public Exception {
209  public:
210  using Exception::Exception;
211  ~AlreadyConnectedException() noexcept override {}
212  std::string getName() const override {
213  return "apache::geode::client::AlreadyConnectedException";
214  }
215 };
216 
220 class APACHE_GEODE_EXPORT FileNotFoundException : public Exception {
221  public:
222  using Exception::Exception;
223  ~FileNotFoundException() noexcept override {}
224  std::string getName() const override {
225  return "apache::geode::client::FileNotFoundException";
226  }
227 };
228 
232 class APACHE_GEODE_EXPORT InterruptedException : public Exception {
233  public:
234  using Exception::Exception;
235  ~InterruptedException() noexcept override {}
236  std::string getName() const override {
237  return "apache::geode::client::InterruptedException";
238  }
239 };
240 
245 class APACHE_GEODE_EXPORT UnsupportedOperationException : public Exception {
246  public:
247  using Exception::Exception;
248  ~UnsupportedOperationException() noexcept override {}
249  std::string getName() const override {
250  return "apache::geode::client::UnsupportedOperationException";
251  }
252 };
253 
258 class APACHE_GEODE_EXPORT StatisticsDisabledException : public Exception {
259  public:
260  using Exception::Exception;
261  ~StatisticsDisabledException() noexcept override {}
262  std::string getName() const override {
263  return "apache::geode::client::StatisticsDisabledException";
264  }
265 };
266 
270 class APACHE_GEODE_EXPORT ConcurrentModificationException : public Exception {
271  public:
272  using Exception::Exception;
273  ~ConcurrentModificationException() noexcept override {}
274  std::string getName() const override {
275  return "apache::geode::client::ConcurrentModificationException";
276  }
277 };
278 
282 class APACHE_GEODE_EXPORT UnknownException : public Exception {
283  public:
284  using Exception::Exception;
285  ~UnknownException() noexcept override {}
286  std::string getName() const override {
287  return "apache::geode::client::UnknownException";
288  }
289 };
290 
294 class APACHE_GEODE_EXPORT ClassCastException : public Exception {
295  public:
296  using Exception::Exception;
297  ~ClassCastException() noexcept override {}
298  std::string getName() const override {
299  return "apache::geode::client::ClassCastException";
300  }
301 };
302 
306 class APACHE_GEODE_EXPORT EntryNotFoundException : public Exception {
307  public:
308  using Exception::Exception;
309  ~EntryNotFoundException() noexcept override {}
310  std::string getName() const override {
311  return "apache::geode::client::EntryNotFoundException";
312  }
313 };
314 
318 class APACHE_GEODE_EXPORT GeodeIOException : public Exception {
319  public:
320  using Exception::Exception;
321  ~GeodeIOException() noexcept override {}
322  std::string getName() const override {
323  return "apache::geode::client::GeodeIOException";
324  }
325 };
326 
330 class APACHE_GEODE_EXPORT GeodeConfigException : public Exception {
331  public:
332  using Exception::Exception;
333  ~GeodeConfigException() noexcept override {}
334  std::string getName() const override {
335  return "apache::geode::client::GeodeConfigException";
336  }
337 };
338 
343 class APACHE_GEODE_EXPORT NullPointerException : public Exception {
344  public:
345  using Exception::Exception;
346  ~NullPointerException() noexcept override {}
347  std::string getName() const override {
348  return "apache::geode::client::NullPointerException";
349  }
350 };
351 
355 class APACHE_GEODE_EXPORT EntryExistsException : public Exception {
356  public:
357  using Exception::Exception;
358  ~EntryExistsException() noexcept override {}
359  std::string getName() const override {
360  return "apache::geode::client::EntryExistsException";
361  }
362 };
363 
368 class APACHE_GEODE_EXPORT NotConnectedException : public Exception {
369  public:
370  using Exception::Exception;
371  ~NotConnectedException() noexcept override {}
372  std::string getName() const override {
373  return "apache::geode::client::NotConnectedException";
374  }
375 };
376 
380 class APACHE_GEODE_EXPORT CacheProxyException : public Exception {
381  public:
382  using Exception::Exception;
383  ~CacheProxyException() noexcept override {}
384  std::string getName() const override {
385  return "apache::geode::client::CacheProxyException";
386  }
387 };
388 
392 class APACHE_GEODE_EXPORT OutOfMemoryException : public Exception {
393  public:
394  using Exception::Exception;
395  ~OutOfMemoryException() noexcept override {}
396  std::string getName() const override {
397  return "apache::geode::client::OutOfMemoryException";
398  }
399 };
400 
405 class APACHE_GEODE_EXPORT NotOwnerException : public Exception {
406  public:
407  using Exception::Exception;
408  ~NotOwnerException() noexcept override {}
409  std::string getName() const override {
410  return "apache::geode::client::NotOwnerException";
411  }
412 };
413 
417 class APACHE_GEODE_EXPORT WrongRegionScopeException : public Exception {
418  public:
419  using Exception::Exception;
420  ~WrongRegionScopeException() noexcept override {}
421  std::string getName() const override {
422  return "apache::geode::client::WrongRegionScopeException";
423  }
424 };
425 
429 class APACHE_GEODE_EXPORT BufferSizeExceededException : public Exception {
430  public:
431  using Exception::Exception;
432  ~BufferSizeExceededException() noexcept override {}
433  std::string getName() const override {
434  return "apache::geode::client::BufferSizeExceededException";
435  }
436 };
437 
441 class APACHE_GEODE_EXPORT RegionCreationFailedException : public Exception {
442  public:
443  using Exception::Exception;
444  ~RegionCreationFailedException() noexcept override {}
445  std::string getName() const override {
446  return "apache::geode::client::RegionCreationFailedException";
447  }
448 };
449 
453 class APACHE_GEODE_EXPORT FatalInternalException : public Exception {
454  public:
455  using Exception::Exception;
456  ~FatalInternalException() noexcept override {}
457  std::string getName() const override {
458  return "apache::geode::client::FatalInternalException";
459  }
460 };
461 
466 class APACHE_GEODE_EXPORT DiskFailureException : public Exception {
467  public:
468  using Exception::Exception;
469  ~DiskFailureException() noexcept override {}
470  std::string getName() const override {
471  return "apache::geode::client::DiskFailureException";
472  }
473 };
474 
479 class APACHE_GEODE_EXPORT DiskCorruptException : public Exception {
480  public:
481  using Exception::Exception;
482  ~DiskCorruptException() noexcept override {}
483  std::string getName() const override {
484  return "apache::geode::client::DiskCorruptException";
485  }
486 };
487 
491 class APACHE_GEODE_EXPORT InitFailedException : public Exception {
492  public:
493  using Exception::Exception;
494  ~InitFailedException() noexcept override {}
495  std::string getName() const override {
496  return "apache::geode::client::InitFailedException";
497  }
498 };
499 
503 class APACHE_GEODE_EXPORT ShutdownFailedException : public Exception {
504  public:
505  using Exception::Exception;
506  ~ShutdownFailedException() noexcept override {}
507  std::string getName() const override {
508  return "apache::geode::client::ShutdownFailedException";
509  }
510 };
511 
515 class APACHE_GEODE_EXPORT CacheServerException : public Exception {
516  public:
517  using Exception::Exception;
518  ~CacheServerException() noexcept override {}
519  std::string getName() const override {
520  return "apache::geode::client::CacheServerException";
521  }
522 };
523 
527 class APACHE_GEODE_EXPORT OutOfRangeException : public Exception {
528  public:
529  using Exception::Exception;
530  ~OutOfRangeException() noexcept override {}
531  std::string getName() const override {
532  return "apache::geode::client::OutOfRangeException";
533  }
534 };
535 
539 class APACHE_GEODE_EXPORT QueryException : public Exception {
540  public:
541  using Exception::Exception;
542  ~QueryException() noexcept override {}
543  std::string getName() const override {
544  return "apache::geode::client::QueryException";
545  }
546 };
547 
551 class APACHE_GEODE_EXPORT MessageException : public Exception {
552  public:
553  using Exception::Exception;
554  ~MessageException() noexcept override {}
555  std::string getName() const override {
556  return "apache::geode::client::MessageException";
557  }
558 };
559 
563 class APACHE_GEODE_EXPORT NotAuthorizedException : public Exception {
564  public:
565  using Exception::Exception;
566  ~NotAuthorizedException() noexcept override {}
567  std::string getName() const override {
568  return "apache::geode::client::NotAuthorizedException";
569  }
570 };
571 
575 class APACHE_GEODE_EXPORT AuthenticationFailedException : public Exception {
576  public:
577  using Exception::Exception;
578  ~AuthenticationFailedException() noexcept override {}
579  std::string getName() const override {
580  return "apache::geode::client::AuthenticationFailedException";
581  }
582 };
583 
587 class APACHE_GEODE_EXPORT AuthenticationRequiredException : public Exception {
588  public:
589  using Exception::Exception;
590  ~AuthenticationRequiredException() noexcept override {}
591  std::string getName() const override {
592  return "apache::geode::client::AuthenticationRequiredException";
593  }
594 };
595 
599 class APACHE_GEODE_EXPORT DuplicateDurableClientException : public Exception {
600  public:
601  using Exception::Exception;
602  ~DuplicateDurableClientException() noexcept override {}
603  std::string getName() const override {
604  return "apache::geode::client::DuplicateDurableClientException";
605  }
606 };
607 
611 class APACHE_GEODE_EXPORT CacheListenerException : public Exception {
612  public:
613  using Exception::Exception;
614  ~CacheListenerException() noexcept override {}
615  std::string getName() const override {
616  return "apache::geode::client::CacheListenerException";
617  }
618 };
622 class APACHE_GEODE_EXPORT CqException : public Exception {
623  public:
624  using Exception::Exception;
625  ~CqException() noexcept override {}
626  std::string getName() const override {
627  return "apache::geode::client::CqException";
628  }
629 };
633 class APACHE_GEODE_EXPORT CqClosedException : public Exception {
634  public:
635  using Exception::Exception;
636  ~CqClosedException() noexcept override {}
637  std::string getName() const override {
638  return "apache::geode::client::CqClosedException";
639  }
640 };
644 class APACHE_GEODE_EXPORT CqQueryException : public Exception {
645  public:
646  using Exception::Exception;
647  ~CqQueryException() noexcept override {}
648  std::string getName() const override {
649  return "apache::geode::client::CqQueryException";
650  }
651 };
655 class APACHE_GEODE_EXPORT CqExistsException : public Exception {
656  public:
657  using Exception::Exception;
658  ~CqExistsException() noexcept override {}
659  std::string getName() const override {
660  return "apache::geode::client::CqExistsException";
661  }
662 };
673 class APACHE_GEODE_EXPORT CqInvalidException : public Exception {
674  public:
675  using Exception::Exception;
676  ~CqInvalidException() noexcept override {}
677  std::string getName() const override {
678  return "apache::geode::client::CqInvalidException";
679  }
680 };
684 class APACHE_GEODE_EXPORT FunctionExecutionException : public Exception {
685  public:
686  using Exception::Exception;
687  ~FunctionExecutionException() noexcept override {}
688  std::string getName() const override {
689  return "apache::geode::client::FunctionExecutionException";
690  }
691 };
695 class APACHE_GEODE_EXPORT NoAvailableLocatorsException : public Exception {
696  public:
697  using Exception::Exception;
698  ~NoAvailableLocatorsException() noexcept override {}
699  std::string getName() const override {
700  return "apache::geode::client::NoAvailableLocatorsException";
701  }
702 };
706 class APACHE_GEODE_EXPORT AllConnectionsInUseException : public Exception {
707  public:
708  using Exception::Exception;
709  ~AllConnectionsInUseException() noexcept override {}
710  std::string getName() const override {
711  return "apache::geode::client::AllConnectionsInUseException";
712  }
713 };
717 class APACHE_GEODE_EXPORT InvalidDeltaException : public Exception {
718  public:
719  using Exception::Exception;
720  ~InvalidDeltaException() noexcept override {}
721  std::string getName() const override {
722  return "apache::geode::client::InvalidDeltaException";
723  }
724 };
728 class APACHE_GEODE_EXPORT KeyNotFoundException : public Exception {
729  public:
730  using Exception::Exception;
731  ~KeyNotFoundException() noexcept override {}
732  std::string getName() const override {
733  return "apache::geode::client::KeyNotFoundException";
734  }
735 };
740 class APACHE_GEODE_EXPORT TransactionException : public Exception {
741  public:
742  using Exception::Exception;
743  ~TransactionException() noexcept override {}
744  std::string getName() const override {
745  return "apache::geode::client::TransactionException";
746  }
747 };
753 class APACHE_GEODE_EXPORT RollbackException : public Exception {
754  public:
755  using Exception::Exception;
756  ~RollbackException() noexcept override {}
757  std::string getName() const override {
758  return "apache::geode::client::RollbackException";
759  }
760 };
765 class APACHE_GEODE_EXPORT CommitConflictException : public Exception {
766  public:
767  using Exception::Exception;
768  ~CommitConflictException() noexcept override {}
769  std::string getName() const override {
770  return "apache::geode::client::CommitConflictException";
771  }
772 };
780  : public Exception {
781  public:
782  using Exception::Exception;
783  ~TransactionDataNodeHasDepartedException() noexcept override {}
784  std::string getName() const override {
785  return "apache::geode::client::TransactionDataNodeHasDepartedException";
786  }
787 };
793 class APACHE_GEODE_EXPORT TransactionDataRebalancedException
794  : public Exception {
795  public:
796  using Exception::Exception;
797  ~TransactionDataRebalancedException() noexcept override {}
798  std::string getName() const override {
799  return "apache::geode::client::TransactionDataRebalancedException";
800  }
801 };
802 
806 class APACHE_GEODE_EXPORT PutAllPartialResultException : public Exception {
807  public:
808  using Exception::Exception;
809  ~PutAllPartialResultException() noexcept override {}
810  std::string getName() const override {
811  return "apache::geode::client::PutAllPartialResultException";
812  }
813 };
814 
818 class APACHE_GEODE_EXPORT SslException : public Exception {
819  public:
820  using Exception::Exception;
821  ~SslException() noexcept override {}
822  std::string getName() const override {
823  return "apache::geode::client::SslException";
824  }
825 };
826 
827 } // namespace client
828 } // namespace geode
829 } // namespace apache
830 
831 #endif // GEODE_EXCEPTIONTYPES_H_
apache::geode::client::RollbackException
The RollbackException exception indicates that either the transaction has been rolled back or an oper...
Definition: ExceptionTypes.hpp:753
apache::geode::client::FatalInternalException
Thrown when there is a fatal internal exception in geode.
Definition: ExceptionTypes.hpp:453
apache::geode::client::LeaseExpiredException
Thrown when lease of cache proxy has expired.
Definition: ExceptionTypes.hpp:147
apache::geode::client::CacheServerException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:519
apache::geode::client::CacheClosedException
Thrown when an operation is attempted on a closed cache.
Definition: ExceptionTypes.hpp:135
apache::geode::client::TransactionException
This is for all Exceptions that may be thrown by a Geode transaction.
Definition: ExceptionTypes.hpp:740
apache::geode::client::RegionCreationFailedException
Thrown when a region creation operation fails.
Definition: ExceptionTypes.hpp:441
apache::geode::client::CacheWriterException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:115
apache::geode::client::FatalInternalException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:457
apache::geode::client::WrongRegionScopeException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:421
apache::geode::client::NoSystemException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:199
apache::geode::client::NotConnectedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:372
apache::geode::client::CacheExistsException
Thrown when an attempt is made to create an existing cache.
Definition: ExceptionTypes.hpp:76
apache::geode::client::InitFailedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:495
apache::geode::client::AlreadyConnectedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:212
apache::geode::client::FunctionExecutionException
Thrown if function execution failed.
Definition: ExceptionTypes.hpp:684
apache::geode::client::CacheProxyException
Thrown when there is an error in the cache proxy.
Definition: ExceptionTypes.hpp:380
apache::geode::client::SslException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:822
apache::geode::client::InterruptedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:236
apache::geode::client::RegionExistsException
Thrown when an attempt is made to create an existing region.
Definition: ExceptionTypes.hpp:123
apache::geode::client::KeyNotFoundException
Thrown if a Key is not present in the region.
Definition: ExceptionTypes.hpp:728
apache::geode::client::BufferSizeExceededException
Thrown when the internal buffer size is exceeded.
Definition: ExceptionTypes.hpp:429
apache::geode::client::InvalidDeltaException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:721
apache::geode::client::CqQueryException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:648
apache::geode::client::CqException
Thrown during continuous query execution time.
Definition: ExceptionTypes.hpp:622
apache::geode::client::GeodeIOException
Thrown when there is an input/output error.
Definition: ExceptionTypes.hpp:318
apache::geode::client::TimeoutException
Thrown when a timout occurs.
Definition: ExceptionTypes.hpp:99
apache::geode::client::CacheLoaderException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:163
apache::geode::client::TransactionException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:744
apache::geode::client::AllConnectionsInUseException
Thrown if all connections in the pool are in use.
Definition: ExceptionTypes.hpp:706
apache::geode::client::NotOwnerException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:409
apache::geode::client::NotOwnerException
Thrown when an attempt is made to release a lock not owned by the thread.
Definition: ExceptionTypes.hpp:405
apache::geode::client::AssertionException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:44
apache::geode::client::IllegalStateException
Thrown when the state of cache is manipulated to be illegal.
Definition: ExceptionTypes.hpp:64
apache::geode::client::ClassCastException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:298
apache::geode::client::CqInvalidException
Thrown if the query doesnot meet the CQ constraints.
Definition: ExceptionTypes.hpp:673
apache::geode::client::PutAllPartialResultException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:810
apache::geode::client::NotConnectedException
Thrown when an operation is attempted before connecting to the distributed system.
Definition: ExceptionTypes.hpp:368
apache::geode::client::QueryException
Thrown when query exception occurs at the server.
Definition: ExceptionTypes.hpp:539
apache::geode::client::InterruptedException
Thrown when an operation is interrupted.
Definition: ExceptionTypes.hpp:232
apache::geode::client::AssertionException
A geode assertion exception.
Definition: ExceptionTypes.hpp:40
apache::geode::client::CqQueryException
Thrown if the Cq Query failed.
Definition: ExceptionTypes.hpp:644
apache::geode::client::NullPointerException
Thrown when a null argument is provided to a method where it is expected to be non-null.
Definition: ExceptionTypes.hpp:343
apache::geode::client::KeyNotFoundException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:732
apache::geode::client::CqExistsException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:659
apache::geode::client::CacheListenerException
Thrown when the cache listener throws an exception.
Definition: ExceptionTypes.hpp:611
apache::geode::client::EntryNotFoundException
Thrown when an operation is attempted on a non-existent entry.
Definition: ExceptionTypes.hpp:306
apache::geode::client::CacheXmlException
Thrown when the cache xml is incorrect.
Definition: ExceptionTypes.hpp:88
apache::geode::client::TransactionDataNodeHasDepartedException
Thrown when the transactional data host has shutdown or no longer has the data being modified by the ...
Definition: ExceptionTypes.hpp:780
apache::geode::client::FunctionExecutionException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:688
apache::geode::client::DiskCorruptException
Thrown by the persistence manager when the data.
Definition: ExceptionTypes.hpp:479
apache::geode::client::IllegalArgumentException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:56
apache::geode::client::RegionDestroyedException
Thrown when an operation is attempted on a destroyed region.
Definition: ExceptionTypes.hpp:171
apache::geode::client::ShutdownFailedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:507
apache::geode::client::NoAvailableLocatorsException
Thrown if the No locators are active to reply for new connection.
Definition: ExceptionTypes.hpp:695
apache::geode::client::OutOfMemoryException
Thrown when the system cannot allocate any more memory.
Definition: ExceptionTypes.hpp:392
apache::geode::client::NotAuthorizedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:567
apache::geode::client::TransactionDataRebalancedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:798
apache::geode::client::AllConnectionsInUseException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:710
apache::geode::client::CacheXmlException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:92
apache::geode::client::StatisticsDisabledException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:262
apache::geode::client::LeaseExpiredException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:151
apache::geode::client::CacheProxyException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:384
apache::geode::client::DuplicateDurableClientException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:603
apache::geode::client::CommitConflictException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:769
apache::geode::client::BufferSizeExceededException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:433
apache::geode::client::UnsupportedOperationException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:249
apache::geode::client::NullPointerException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:347
apache::geode::client::TimeoutException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:103
apache::geode::client::CqClosedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:637
apache::geode::client::RollbackException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:757
apache::geode::client::CacheClosedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:139
apache::geode::client::NotAuthorizedException
Thrown when a non authorized operation is done.
Definition: ExceptionTypes.hpp:563
apache::geode::client::StatisticsDisabledException
Thrown when statistics are invoked for a region where they are disabled.
Definition: ExceptionTypes.hpp:258
apache::geode::client::CacheListenerException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:615
apache::geode::client::EntryDestroyedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:187
apache::geode::client::OutOfRangeException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:531
apache::geode::client::ConcurrentModificationException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:274
apache::geode::client::NoAvailableLocatorsException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:699
apache::geode::client::PutAllPartialResultException
Thrown if putAll operation with single hop succeeded partially.
Definition: ExceptionTypes.hpp:806
apache::geode::client::ShutdownFailedException
Thrown when persistence manager fails to close properly.
Definition: ExceptionTypes.hpp:503
apache::geode::client::GeodeConfigException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:334
apache::geode::client::NoSystemException
Thrown when the connecting target is not running.
Definition: ExceptionTypes.hpp:195
apache::geode::client::OutOfMemoryException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:396
apache::geode::client::CqInvalidException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:677
apache::geode::client::AuthenticationRequiredException
Thrown when no credentials are provided by client when server expects.
Definition: ExceptionTypes.hpp:587
apache::geode::client::UnknownException
An unknown exception occurred.
Definition: ExceptionTypes.hpp:282
apache::geode::client::GeodeIOException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:322
apache::geode::client::MessageException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:555
apache::geode::client::MessageException
Thrown when an unknown message is received from the server.
Definition: ExceptionTypes.hpp:551
apache::geode::client::UnsupportedOperationException
Thrown when an operation unsupported by the current configuration is attempted.
Definition: ExceptionTypes.hpp:245
apache::geode::client::UnknownException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:286
apache::geode::client::CqClosedException
Thrown if the Cq on which the operaion performed is closed.
Definition: ExceptionTypes.hpp:633
apache::geode::client::IllegalStateException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:68
apache::geode::client::GeodeConfigException
Thrown when geode configuration file is incorrect.
Definition: ExceptionTypes.hpp:330
apache::geode::client::Exception
A description of an exception that occurred during a cache operation.
Definition: Exception.hpp:45
apache::geode::client::CacheWriterException
Thrown when the cache writer aborts the operation.
Definition: ExceptionTypes.hpp:111
apache::geode::client::EntryExistsException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:359
apache::geode::client::InvalidDeltaException
Thrown if Delta could not be applied.
Definition: ExceptionTypes.hpp:717
apache::geode::client::EntryNotFoundException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:310
apache::geode::client::WrongRegionScopeException
Thrown when a region is created in an incorrect scope.
Definition: ExceptionTypes.hpp:417
apache::geode::client::OutOfRangeException
Thrown when bound of array/vector etc.
Definition: ExceptionTypes.hpp:527
apache::geode::client::FileNotFoundException
Thrown when a non-existing file is accessed.
Definition: ExceptionTypes.hpp:220
apache::geode::client::TransactionDataRebalancedException
Thrown when a RebalanceOperation occurs concurrently with a transaction.
Definition: ExceptionTypes.hpp:794
apache::geode::client::InitFailedException
Thrown when persistence manager fails to initialize.
Definition: ExceptionTypes.hpp:491
apache::geode::client::EntryDestroyedException
Thrown when an operation is attempted on a destroyed entry.
Definition: ExceptionTypes.hpp:183
apache::geode::client::AuthenticationFailedException
Thrown when authentication fails.
Definition: ExceptionTypes.hpp:575
apache::geode::client::ConcurrentModificationException
Thrown when a concurrent operation fails.
Definition: ExceptionTypes.hpp:270
apache::geode::client::RegionCreationFailedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:445
apache::geode::client::IllegalArgumentException
Thrown when an argument to a method is illegal.
Definition: ExceptionTypes.hpp:52
apache::geode::client::CqExistsException
Thrown if a Cq by this name already exists on this client.
Definition: ExceptionTypes.hpp:655
apache::geode::client::EntryExistsException
Thrown when attempt is made to create an existing entry.
Definition: ExceptionTypes.hpp:355
apache::geode::client::CommitConflictException
Thrown when a commit fails due to a write conflict.
Definition: ExceptionTypes.hpp:765
apache::geode::client::DiskFailureException
Thrown by the persistence manager when a write fails due to disk failure.
Definition: ExceptionTypes.hpp:466
apache::geode::client::QueryException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:543
apache::geode::client::CacheLoaderException
Thrown when the cache loader aborts the operation.
Definition: ExceptionTypes.hpp:159
apache::geode::client::SslException
Thrown when an error is encountered during an SSL operation.
Definition: ExceptionTypes.hpp:818
apache::geode::client::DiskFailureException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:470
apache::geode::client::CacheServerException
Thrown when an exception occurs on the cache server.
Definition: ExceptionTypes.hpp:515
apache::geode::client::AlreadyConnectedException
Thrown when an attempt is made to connect to DistributedSystem second time.
Definition: ExceptionTypes.hpp:208
apache::geode::client::FileNotFoundException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:224
apache::geode::client::RegionDestroyedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:175
apache::geode::client::AuthenticationFailedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:579
apache::geode::client::RegionExistsException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:127
apache::geode::client::DiskCorruptException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:483
apache::geode::client::DuplicateDurableClientException
Thrown when two durable connect with same Id.
Definition: ExceptionTypes.hpp:599
apache::geode::client::CqException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:626
apache::geode::client::AuthenticationRequiredException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:591
apache::geode::client::ClassCastException
Thrown when a cast operation fails.
Definition: ExceptionTypes.hpp:294
apache::geode::client::CacheExistsException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:80
apache::geode::client::TransactionDataNodeHasDepartedException::getName
std::string getName() const override
Return the name of this exception type.
Definition: ExceptionTypes.hpp:784

Apache Geode C++ Cache API Documentation