This is an automated email from the ASF dual-hosted git repository.
mmartell pushed a commit to branch GEODE-9559-demacroize-clicache
in repository https://gitbox.apache.org/repos/asf/geode-native.git
commit 6b2a668b36d254507c6a80e9cccf726147b779b2
Author: Mike Martell <mmart...@pivotal.io>
AuthorDate: Sat Aug 28 08:51:44 2021 -0700
Demacroize: DEF3 and DEF4
---
clicache/src/ExceptionTypes.hpp | 285 ++++++++++++++++++++--------------------
1 file changed, 143 insertions(+), 142 deletions(-)
diff --git a/clicache/src/ExceptionTypes.hpp b/clicache/src/ExceptionTypes.hpp
index 00a9716..83181b8 100644
--- a/clicache/src/ExceptionTypes.hpp
+++ b/clicache/src/ExceptionTypes.hpp
@@ -267,87 +267,87 @@ namespace Apache
};
/// Creates a class <c>x</c> named for each exception <c>y</c>.
-#define _GF_MG_EXCEPTION_DEF4(x,y) \
- [Serializable] \
- public ref class x: public GeodeException \
- { \
- public: \
- \
- /** <summary>Default constructor</summary> */ \
- x( ) \
- : GeodeException( ) { } \
- \
- /** <summary>
- * Constructor to create an exception object with the given message.
- * </summary>
- * <param name="message">The exception message.</param>
- */ \
- x( String^ message ) \
- : GeodeException( message ) { } \
- \
- /** <summary>
- * Constructor to create an exception object with the given message
- * and with the given inner exception.
- * </summary>
- * <param name="message">The exception message.</param>
- * <param name="innerException">The inner exception object.</param>
- */ \
- x( String^ message, System::Exception^ innerException ) \
- : GeodeException( message, innerException ) { } \
- \
- protected: \
- \
- /** <summary>
- * Initializes a new instance of the class with serialized data.
- * This allows deserialization of this exception in .NET remoting.
- * </summary>
- * <param name="info">
- * holds the serialized object data about the exception being thrown
- * </param>
- * <param name="context">
- * contains contextual information about the source or destination
- * </param>
- */ \
- x( SerializationInfo^ info, StreamingContext context ) \
- : GeodeException( info, context ) { } \
- \
- internal: \
- x(const apache::geode::client::y& nativeEx) \
- : GeodeException(marshal_as<String^>(nativeEx.getMessage()), \
- gcnew GeodeException(GeodeException::GetStackTrace( \
- nativeEx))) { } \
- \
- x(const apache::geode::client::y& nativeEx, Exception^ innerException)
\
- : GeodeException(marshal_as<String^>(nativeEx.getMessage()), \
- innerException) { } \
- \
- static GeodeException^ Create(const apache::geode::client::Exception&
ex, \
- Exception^ innerException) \
- { \
- const apache::geode::client::y* nativeEx = dynamic_cast<const
apache::geode::client::y*>( &ex ); \
- if (nativeEx != nullptr) { \
- if (innerException == nullptr) { \
- return gcnew x(*nativeEx); \
- } \
- else { \
- return gcnew x(*nativeEx, innerException); \
- } \
- } \
- return nullptr; \
- } \
- virtual std::shared_ptr<apache::geode::client::Exception> GetNative()
override \
- { \
- auto message = marshal_as<std::string>(this->Message + ": " +
this->StackTrace); \
- if (this->InnerException != nullptr) { \
- auto cause = GeodeException::GetNative(this->InnerException); \
- message += "Caused by: " + cause->getMessage(); \
- } \
- return std::make_shared<apache::geode::client::y>(message); \
- } \
- }
-
-/// Creates a class named for each exception <c>x</c>.
-#define _GF_MG_EXCEPTION_DEF3(x) _GF_MG_EXCEPTION_DEF4(x,x)
+//#define _GF_MG_EXCEPTION_DEF4(x,y) \
+// [Serializable] \
+// public ref class x: public GeodeException \
+// { \
+// public: \
+// \
+// /** <summary>Default constructor</summary> */ \
+// x( ) \
+// : GeodeException( ) { } \
+// \
+// /** <summary>
+// * Constructor to create an exception object with the given message.
+// * </summary>
+// * <param name="message">The exception message.</param>
+// */ \
+// x( String^ message ) \
+// : GeodeException( message ) { } \
+// \
+// /** <summary>
+// * Constructor to create an exception object with the given message
+// * and with the given inner exception.
+// * </summary>
+// * <param name="message">The exception message.</param>
+// * <param name="innerException">The inner exception object.</param>
+// */ \
+// x( String^ message, System::Exception^ innerException ) \
+// : GeodeException( message, innerException ) { } \
+// \
+// protected: \
+// \
+// /** <summary>
+// * Initializes a new instance of the class with serialized data.
+// * This allows deserialization of this exception in .NET remoting.
+// * </summary>
+// * <param name="info">
+// * holds the serialized object data about the exception being thrown
+// * </param>
+// * <param name="context">
+// * contains contextual information about the source or destination
+// * </param>
+// */ \
+// x( SerializationInfo^ info, StreamingContext context ) \
+// : GeodeException( info, context ) { } \
+// \
+// internal: \
+// x(const apache::geode::client::y& nativeEx) \
+// : GeodeException(marshal_as<String^>(nativeEx.getMessage()), \
+// gcnew GeodeException(GeodeException::GetStackTrace( \
+// nativeEx))) { } \
+// \
+// x(const apache::geode::client::y& nativeEx, Exception^
innerException) \
+// : GeodeException(marshal_as<String^>(nativeEx.getMessage()), \
+// innerException) { } \
+// \
+// static GeodeException^ Create(const
apache::geode::client::Exception& ex, \
+// Exception^ innerException) \
+// { \
+// const apache::geode::client::y* nativeEx = dynamic_cast<const
apache::geode::client::y*>( &ex ); \
+// if (nativeEx != nullptr) { \
+// if (innerException == nullptr) { \
+// return gcnew x(*nativeEx); \
+// } \
+// else { \
+// return gcnew x(*nativeEx, innerException); \
+// } \
+// } \
+// return nullptr; \
+// } \
+// virtual std::shared_ptr<apache::geode::client::Exception>
GetNative() override \
+// { \
+// auto message = marshal_as<std::string>(this->Message + ": " +
this->StackTrace); \
+// if (this->InnerException != nullptr) { \
+// auto cause = GeodeException::GetNative(this->InnerException); \
+// message += "Caused by: " + cause->getMessage(); \
+// } \
+// return std::make_shared<apache::geode::client::y>(message); \
+// } \
+// }
+//
+///// Creates a class named for each exception <c>x</c>.
+//#define _GF_MG_EXCEPTION_DEF3(x) _GF_MG_EXCEPTION_DEF4(x,x)
// For all the native Geode C++ exceptions, a corresponding definition
@@ -357,312 +357,313 @@ namespace Apache
/// <summary>
/// A geode assertion exception.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( AssertionException );
+ [Serializable] public ref class AssertionException: public
GeodeException { public: AssertionException( ) : GeodeException( ) { }
AssertionException( String^ message ) : GeodeException( message ) { }
AssertionException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: AssertionException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: AssertionException(const apache::g [...]
/// <summary>
/// Thrown when an argument to a method is illegal.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( IllegalArgumentException );
+ [Serializable] public ref class IllegalArgumentException: public
GeodeException { public: IllegalArgumentException( ) : GeodeException( ) { }
IllegalArgumentException( String^ message ) : GeodeException( message ) { }
IllegalArgumentException( String^ message, System::Exception^ innerException )
: GeodeException( message, innerException ) { } protected:
IllegalArgumentException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: Ille [...]
/// <summary>
/// Thrown when the state of cache is manipulated to be illegal.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( IllegalStateException );
+ [Serializable] public ref class IllegalStateException: public
GeodeException { public: IllegalStateException( ) : GeodeException( ) { }
IllegalStateException( String^ message ) : GeodeException( message ) { }
IllegalStateException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: IllegalStateException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: IllegalStateExcepti [...]
/// <summary>
/// Thrown when an attempt is made to create an existing cache.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CacheExistsException );
+ [Serializable] public ref class CacheExistsException: public
GeodeException { public: CacheExistsException( ) : GeodeException( ) { }
CacheExistsException( String^ message ) : GeodeException( message ) { }
CacheExistsException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: CacheExistsException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: CacheExistsException(con [...]
/// <summary>
/// Thrown when the cache xml is incorrect.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CacheXmlException );
+ [Serializable] public ref class CacheXmlException: public GeodeException
{ public: CacheXmlException( ) : GeodeException( ) { } CacheXmlException(
String^ message ) : GeodeException( message ) { } CacheXmlException( String^
message, System::Exception^ innerException ) : GeodeException( message,
innerException ) { } protected: CacheXmlException( SerializationInfo^ info,
StreamingContext context ) : GeodeException( info, context ) { } internal:
CacheXmlException(const apache::geode:: [...]
/// <summary>
/// Thrown when a timout occurs.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( TimeoutException );
+ [Serializable] public ref class TimeoutException: public GeodeException
{ public: TimeoutException( ) : GeodeException( ) { } TimeoutException( String^
message ) : GeodeException( message ) { } TimeoutException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: TimeoutException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, context ) { } internal:
TimeoutException(const apache::geode::client [...]
/// <summary>
/// Thrown when the cache writer aborts the operation.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CacheWriterException );
+ [Serializable] public ref class CacheWriterException: public
GeodeException { public: CacheWriterException( ) : GeodeException( ) { }
CacheWriterException( String^ message ) : GeodeException( message ) { }
CacheWriterException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: CacheWriterException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: CacheWriterException(con [...]
/// <summary>
/// Thrown when the cache listener throws an exception.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CacheListenerException );
+ [Serializable] public ref class CacheListenerException: public
GeodeException { public: CacheListenerException( ) : GeodeException( ) { }
CacheListenerException( String^ message ) : GeodeException( message ) { }
CacheListenerException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected:
CacheListenerException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: CacheListenerE [...]
/// <summary>
/// Thrown when an attempt is made to create an existing region.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( RegionExistsException );
+ [Serializable] public ref class RegionExistsException: public
GeodeException { public: RegionExistsException( ) : GeodeException( ) { }
RegionExistsException( String^ message ) : GeodeException( message ) { }
RegionExistsException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: RegionExistsException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: RegionExistsExcepti [...]
/// <summary>
/// Thrown when an operation is attempted on a closed cache.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CacheClosedException );
+ [Serializable] public ref class CacheClosedException: public
GeodeException { public: CacheClosedException( ) : GeodeException( ) { }
CacheClosedException( String^ message ) : GeodeException( message ) { }
CacheClosedException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: CacheClosedException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: CacheClosedException(con [...]
/// <summary>
/// Thrown when lease of cache proxy has expired.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( LeaseExpiredException );
+ [Serializable] public ref class LeaseExpiredException: public
GeodeException { public: LeaseExpiredException( ) : GeodeException( ) { }
LeaseExpiredException( String^ message ) : GeodeException( message ) { }
LeaseExpiredException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: LeaseExpiredException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: LeaseExpiredExcepti [...]
/// <summary>
/// Thrown when the cache loader aborts the operation.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CacheLoaderException );
+ [Serializable] public ref class CacheLoaderException: public
GeodeException { public: CacheLoaderException( ) : GeodeException( ) { }
CacheLoaderException( String^ message ) : GeodeException( message ) { }
CacheLoaderException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: CacheLoaderException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: CacheLoaderException(con [...]
/// <summary>
/// Thrown when an operation is attempted on a destroyed region.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( RegionDestroyedException );
+ [Serializable] public ref class RegionDestroyedException: public
GeodeException { public: RegionDestroyedException( ) : GeodeException( ) { }
RegionDestroyedException( String^ message ) : GeodeException( message ) { }
RegionDestroyedException( String^ message, System::Exception^ innerException )
: GeodeException( message, innerException ) { } protected:
RegionDestroyedException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: Regi [...]
/// <summary>
/// Thrown when an operation is attempted on a destroyed entry.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( EntryDestroyedException );
+ [Serializable] public ref class EntryDestroyedException: public
GeodeException { public: EntryDestroyedException( ) : GeodeException( ) { }
EntryDestroyedException( String^ message ) : GeodeException( message ) { }
EntryDestroyedException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected:
EntryDestroyedException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: EntryDest [...]
/// <summary>
/// Thrown when the connecting target is not running.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( NoSystemException );
+ [Serializable] public ref class NoSystemException: public GeodeException
{ public: NoSystemException( ) : GeodeException( ) { } NoSystemException(
String^ message ) : GeodeException( message ) { } NoSystemException( String^
message, System::Exception^ innerException ) : GeodeException( message,
innerException ) { } protected: NoSystemException( SerializationInfo^ info,
StreamingContext context ) : GeodeException( info, context ) { } internal:
NoSystemException(const apache::geode:: [...]
/// <summary>
/// Thrown when an attempt is made to connect to
/// DistributedSystem second time.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( AlreadyConnectedException );
+ [Serializable] public ref class AlreadyConnectedException: public
GeodeException { public: AlreadyConnectedException( ) : GeodeException( ) { }
AlreadyConnectedException( String^ message ) : GeodeException( message ) { }
AlreadyConnectedException( String^ message, System::Exception^ innerException )
: GeodeException( message, innerException ) { } protected:
AlreadyConnectedException( SerializationInfo^ info, StreamingContext context )
: GeodeException( info, context ) { } internal: [...]
/// <summary>
/// Thrown when a non-existing file is accessed.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( FileNotFoundException );
+ [Serializable] public ref class FileNotFoundException: public
GeodeException { public: FileNotFoundException( ) : GeodeException( ) { }
FileNotFoundException( String^ message ) : GeodeException( message ) { }
FileNotFoundException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: FileNotFoundException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: FileNotFoundExcepti [...]
/// <summary>
/// Thrown when an operation is interrupted.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( InterruptedException );
+ [Serializable] public ref class InterruptedException: public
GeodeException { public: InterruptedException( ) : GeodeException( ) { }
InterruptedException( String^ message ) : GeodeException( message ) { }
InterruptedException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: InterruptedException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: InterruptedException(con [...]
/// <summary>
/// Thrown when an operation unsupported by the
/// current configuration is attempted.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( UnsupportedOperationException );
+ [Serializable] public ref class UnsupportedOperationException: public
GeodeException { public: UnsupportedOperationException( ) : GeodeException( ) {
} UnsupportedOperationException( String^ message ) : GeodeException( message )
{ } UnsupportedOperationException( String^ message, System::Exception^
innerException ) : GeodeException( message, innerException ) { } protected:
UnsupportedOperationException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, con [...]
/// <summary>
/// Thrown when statistics are invoked for a region where
/// they are disabled.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( StatisticsDisabledException );
+ [Serializable] public ref class StatisticsDisabledException: public
GeodeException { public: StatisticsDisabledException( ) : GeodeException( ) { }
StatisticsDisabledException( String^ message ) : GeodeException( message ) { }
StatisticsDisabledException( String^ message, System::Exception^ innerException
) : GeodeException( message, innerException ) { } protected:
StatisticsDisabledException( SerializationInfo^ info, StreamingContext context
) : GeodeException( info, context ) { } [...]
/// <summary>
/// Thrown when a concurrent operation fails.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( ConcurrentModificationException );
+ [Serializable] public ref class ConcurrentModificationException: public
GeodeException { public: ConcurrentModificationException( ) : GeodeException( )
{ } ConcurrentModificationException( String^ message ) : GeodeException(
message ) { } ConcurrentModificationException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: ConcurrentModificationException( SerializationInfo^ info,
StreamingContext context ) : GeodeException( [...]
/// <summary>
/// An unknown exception occurred.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( UnknownException );
+ [Serializable] public ref class UnknownException: public GeodeException
{ public: UnknownException( ) : GeodeException( ) { } UnknownException( String^
message ) : GeodeException( message ) { } UnknownException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: UnknownException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, context ) { } internal:
UnknownException(const apache::geode::client [...]
/// <summary>
/// Thrown when a cast operation fails.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( ClassCastException );
+ [Serializable] public ref class ClassCastException: public
GeodeException { public: ClassCastException( ) : GeodeException( ) { }
ClassCastException( String^ message ) : GeodeException( message ) { }
ClassCastException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: ClassCastException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: ClassCastException(const apache::g [...]
/// <summary>
/// Thrown when an operation is attempted on a non-existent entry.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( EntryNotFoundException );
+ [Serializable] public ref class EntryNotFoundException: public
GeodeException { public: EntryNotFoundException( ) : GeodeException( ) { }
EntryNotFoundException( String^ message ) : GeodeException( message ) { }
EntryNotFoundException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected:
EntryNotFoundException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: EntryNotFoundE [...]
/// <summary>
/// Thrown when there is an input/output error.
/// </summary>
- _GF_MG_EXCEPTION_DEF4( GeodeIOException, GeodeIOException );
+ [Serializable] public ref class GeodeIOException: public GeodeException
{ public: GeodeIOException( ) : GeodeException( ) { } GeodeIOException( String^
message ) : GeodeException( message ) { } GeodeIOException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: GeodeIOException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, context ) { } internal:
GeodeIOException(const apache::geode::client [...]
/// <summary>
/// Thrown when geode configuration file is incorrect.
/// </summary>
- _GF_MG_EXCEPTION_DEF4( GeodeConfigException, GeodeConfigException );
+ [Serializable] public ref class GeodeConfigException: public
GeodeException { public: GeodeConfigException( ) : GeodeException( ) { }
GeodeConfigException( String^ message ) : GeodeException( message ) { }
GeodeConfigException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: GeodeConfigException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: GeodeConfigException(con [...]
/// <summary>
/// Thrown when a null argument is provided to a method
/// where it is expected to be non-null.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( NullPointerException );
+ [Serializable] public ref class NullPointerException: public
GeodeException { public: NullPointerException( ) : GeodeException( ) { }
NullPointerException( String^ message ) : GeodeException( message ) { }
NullPointerException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: NullPointerException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: NullPointerException(con [...]
/// <summary>
/// Thrown when attempt is made to create an existing entry.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( EntryExistsException );
+ [Serializable] public ref class EntryExistsException: public
GeodeException { public: EntryExistsException( ) : GeodeException( ) { }
EntryExistsException( String^ message ) : GeodeException( message ) { }
EntryExistsException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: EntryExistsException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: EntryExistsException(con [...]
/// <summary>
/// Thrown when an operation is attempted before connecting
/// to the distributed system.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( NotConnectedException );
+ [Serializable] public ref class NotConnectedException: public
GeodeException { public: NotConnectedException( ) : GeodeException( ) { }
NotConnectedException( String^ message ) : GeodeException( message ) { }
NotConnectedException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: NotConnectedException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: NotConnectedExcepti [...]
/// <summary>
/// Thrown when there is an error in the cache proxy.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CacheProxyException );
+ [Serializable] public ref class CacheProxyException: public
GeodeException { public: CacheProxyException( ) : GeodeException( ) { }
CacheProxyException( String^ message ) : GeodeException( message ) { }
CacheProxyException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: CacheProxyException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: CacheProxyException(const apa [...]
/// <summary>
/// Thrown when the system cannot allocate any more memory.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( OutOfMemoryException );
+ [Serializable] public ref class OutOfMemoryException: public
GeodeException { public: OutOfMemoryException( ) : GeodeException( ) { }
OutOfMemoryException( String^ message ) : GeodeException( message ) { }
OutOfMemoryException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: OutOfMemoryException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: OutOfMemoryException(con [...]
/// <summary>
/// Thrown when an attempt is made to release a lock not
/// owned by the thread.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( NotOwnerException );
+ [Serializable] public ref class NotOwnerException: public GeodeException
{ public: NotOwnerException( ) : GeodeException( ) { } NotOwnerException(
String^ message ) : GeodeException( message ) { } NotOwnerException( String^
message, System::Exception^ innerException ) : GeodeException( message,
innerException ) { } protected: NotOwnerException( SerializationInfo^ info,
StreamingContext context ) : GeodeException( info, context ) { } internal:
NotOwnerException(const apache::geode:: [...]
/// <summary>
/// Thrown when a region is created in an incorrect scope.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( WrongRegionScopeException );
+ [Serializable] public ref class WrongRegionScopeException: public
GeodeException { public: WrongRegionScopeException( ) : GeodeException( ) { }
WrongRegionScopeException( String^ message ) : GeodeException( message ) { }
WrongRegionScopeException( String^ message, System::Exception^ innerException )
: GeodeException( message, innerException ) { } protected:
WrongRegionScopeException( SerializationInfo^ info, StreamingContext context )
: GeodeException( info, context ) { } internal: [...]
/// <summary>
/// Thrown when the internal buffer size is exceeded.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( BufferSizeExceededException );
+ [Serializable] public ref class BufferSizeExceededException: public
GeodeException { public: BufferSizeExceededException( ) : GeodeException( ) { }
BufferSizeExceededException( String^ message ) : GeodeException( message ) { }
BufferSizeExceededException( String^ message, System::Exception^ innerException
) : GeodeException( message, innerException ) { } protected:
BufferSizeExceededException( SerializationInfo^ info, StreamingContext context
) : GeodeException( info, context ) { } [...]
/// <summary>
/// Thrown when a region creation operation fails.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( RegionCreationFailedException );
+ [Serializable] public ref class RegionCreationFailedException: public
GeodeException { public: RegionCreationFailedException( ) : GeodeException( ) {
} RegionCreationFailedException( String^ message ) : GeodeException( message )
{ } RegionCreationFailedException( String^ message, System::Exception^
innerException ) : GeodeException( message, innerException ) { } protected:
RegionCreationFailedException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, con [...]
/// <summary>
/// Thrown when there is a fatal internal exception in Geode.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( FatalInternalException );
+ [Serializable] public ref class FatalInternalException: public
GeodeException { public: FatalInternalException( ) : GeodeException( ) { }
FatalInternalException( String^ message ) : GeodeException( message ) { }
FatalInternalException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected:
FatalInternalException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: FatalInternalE [...]
/// <summary>
/// Thrown by the persistence manager when a write
/// fails due to disk failure.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( DiskFailureException );
+ [Serializable] public ref class DiskFailureException: public
GeodeException { public: DiskFailureException( ) : GeodeException( ) { }
DiskFailureException( String^ message ) : GeodeException( message ) { }
DiskFailureException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: DiskFailureException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: DiskFailureException(con [...]
/// <summary>
/// Thrown by the persistence manager when the data
/// to be read from disk is corrupt.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( DiskCorruptException );
+ [Serializable] public ref class DiskCorruptException: public
GeodeException { public: DiskCorruptException( ) : GeodeException( ) { }
DiskCorruptException( String^ message ) : GeodeException( message ) { }
DiskCorruptException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: DiskCorruptException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: DiskCorruptException(con [...]
/// <summary>
/// Thrown when persistence manager fails to initialize.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( InitFailedException );
+ [Serializable] public ref class InitFailedException: public
GeodeException { public: InitFailedException( ) : GeodeException( ) { }
InitFailedException( String^ message ) : GeodeException( message ) { }
InitFailedException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: InitFailedException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: InitFailedException(const apa [...]
/// <summary>
/// Thrown when persistence manager fails to close properly.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( ShutdownFailedException );
+ [Serializable] public ref class ShutdownFailedException: public
GeodeException { public: ShutdownFailedException( ) : GeodeException( ) { }
ShutdownFailedException( String^ message ) : GeodeException( message ) { }
ShutdownFailedException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected:
ShutdownFailedException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: ShutdownF [...]
/// <summary>
/// Thrown when an exception occurs on the cache server.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CacheServerException );
+ [Serializable] public ref class CacheServerException: public
GeodeException { public: CacheServerException( ) : GeodeException( ) { }
CacheServerException( String^ message ) : GeodeException( message ) { }
CacheServerException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: CacheServerException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: CacheServerException(con [...]
/// <summary>
/// Thrown when bound of array/vector etc. is exceeded.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( OutOfRangeException );
+ [Serializable] public ref class OutOfRangeException: public
GeodeException { public: OutOfRangeException( ) : GeodeException( ) { }
OutOfRangeException( String^ message ) : GeodeException( message ) { }
OutOfRangeException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: OutOfRangeException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: OutOfRangeException(const apa [...]
/// <summary>
/// Thrown when query exception occurs at the server.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( QueryException );
+ [Serializable] public ref class QueryException: public GeodeException {
public: QueryException( ) : GeodeException( ) { } QueryException( String^
message ) : GeodeException( message ) { } QueryException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: QueryException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, context ) { } internal: QueryException(const
apache::geode::client::QueryExcep [...]
/// <summary>
/// Thrown when an unknown message is received from the server.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( MessageException );
+ [Serializable] public ref class MessageException: public GeodeException
{ public: MessageException( ) : GeodeException( ) { } MessageException( String^
message ) : GeodeException( message ) { } MessageException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: MessageException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, context ) { } internal:
MessageException(const apache::geode::client [...]
/// <summary>
/// Thrown when a client operation is not authorized on the server.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( NotAuthorizedException );
+ [Serializable] public ref class NotAuthorizedException: public
GeodeException { public: NotAuthorizedException( ) : GeodeException( ) { }
NotAuthorizedException( String^ message ) : GeodeException( message ) { }
NotAuthorizedException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected:
NotAuthorizedException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: NotAuthorizedE [...]
/// <summary>
/// Thrown when authentication to the server fails.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( AuthenticationFailedException );
+ [Serializable] public ref class AuthenticationFailedException: public
GeodeException { public: AuthenticationFailedException( ) : GeodeException( ) {
} AuthenticationFailedException( String^ message ) : GeodeException( message )
{ } AuthenticationFailedException( String^ message, System::Exception^
innerException ) : GeodeException( message, innerException ) { } protected:
AuthenticationFailedException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, con [...]
/// <summary>
/// Thrown when credentials are not provided to a server which expects
them.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( AuthenticationRequiredException );
+ [Serializable] public ref class AuthenticationRequiredException: public
GeodeException { public: AuthenticationRequiredException( ) : GeodeException( )
{ } AuthenticationRequiredException( String^ message ) : GeodeException(
message ) { } AuthenticationRequiredException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: AuthenticationRequiredException( SerializationInfo^ info,
StreamingContext context ) : GeodeException( [...]
/// <summary>
/// Thrown when a duplicate durable client id is provided to the server.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( DuplicateDurableClientException );
+ [Serializable] public ref class DuplicateDurableClientException: public
GeodeException { public: DuplicateDurableClientException( ) : GeodeException( )
{ } DuplicateDurableClientException( String^ message ) : GeodeException(
message ) { } DuplicateDurableClientException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: DuplicateDurableClientException( SerializationInfo^ info,
StreamingContext context ) : GeodeException( [...]
/// <summary>
/// Thrown when a client is unable to contact any locators.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( NoAvailableLocatorsException );
+ [Serializable] public ref class NoAvailableLocatorsException: public
GeodeException { public: NoAvailableLocatorsException( ) : GeodeException( ) {
} NoAvailableLocatorsException( String^ message ) : GeodeException( message ) {
} NoAvailableLocatorsException( String^ message, System::Exception^
innerException ) : GeodeException( message, innerException ) { } protected:
NoAvailableLocatorsException( SerializationInfo^ info, StreamingContext context
) : GeodeException( info, context [...]
/// <summary>
/// Thrown when all connections in a pool are in use..
/// </summary>
- _GF_MG_EXCEPTION_DEF3( AllConnectionsInUseException );
+ [Serializable] public ref class AllConnectionsInUseException: public
GeodeException { public: AllConnectionsInUseException( ) : GeodeException( ) {
} AllConnectionsInUseException( String^ message ) : GeodeException( message ) {
} AllConnectionsInUseException( String^ message, System::Exception^
innerException ) : GeodeException( message, innerException ) { } protected:
AllConnectionsInUseException( SerializationInfo^ info, StreamingContext context
) : GeodeException( info, context [...]
/// <summary>
/// Thrown when cq is invalid
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CqInvalidException );
+ [Serializable] public ref class CqInvalidException: public
GeodeException { public: CqInvalidException( ) : GeodeException( ) { }
CqInvalidException( String^ message ) : GeodeException( message ) { }
CqInvalidException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: CqInvalidException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: CqInvalidException(const apache::g [...]
/// <summary>
/// Thrown when function execution failed
/// </summary>
- _GF_MG_EXCEPTION_DEF3( FunctionExecutionException );
+ [Serializable] public ref class FunctionExecutionException: public
GeodeException { public: FunctionExecutionException( ) : GeodeException( ) { }
FunctionExecutionException( String^ message ) : GeodeException( message ) { }
FunctionExecutionException( String^ message, System::Exception^ innerException
) : GeodeException( message, innerException ) { } protected:
FunctionExecutionException( SerializationInfo^ info, StreamingContext context )
: GeodeException( info, context ) { } inte [...]
/// <summary>
/// Thrown during continuous query execution time.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CqException );
+ [Serializable] public ref class CqException: public GeodeException {
public: CqException( ) : GeodeException( ) { } CqException( String^ message ) :
GeodeException( message ) { } CqException( String^ message, System::Exception^
innerException ) : GeodeException( message, innerException ) { } protected:
CqException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: CqException(const
apache::geode::client::CqException& nativeEx) : Geo [...]
/// <summary>
/// Thrown if the Cq on which the operaion performed is closed
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CqClosedException );
+ [Serializable] public ref class CqClosedException: public GeodeException
{ public: CqClosedException( ) : GeodeException( ) { } CqClosedException(
String^ message ) : GeodeException( message ) { } CqClosedException( String^
message, System::Exception^ innerException ) : GeodeException( message,
innerException ) { } protected: CqClosedException( SerializationInfo^ info,
StreamingContext context ) : GeodeException( info, context ) { } internal:
CqClosedException(const apache::geode:: [...]
/// <summary>
/// Thrown if the Cq Query failed
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CqQueryException );
+ [Serializable] public ref class CqQueryException: public GeodeException
{ public: CqQueryException( ) : GeodeException( ) { } CqQueryException( String^
message ) : GeodeException( message ) { } CqQueryException( String^ message,
System::Exception^ innerException ) : GeodeException( message, innerException )
{ } protected: CqQueryException( SerializationInfo^ info, StreamingContext
context ) : GeodeException( info, context ) { } internal:
CqQueryException(const apache::geode::client [...]
/// <summary>
/// Thrown if a Cq by this name already exists on this client
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CqExistsException );
+ [Serializable] public ref class CqExistsException: public GeodeException
{ public: CqExistsException( ) : GeodeException( ) { } CqExistsException(
String^ message ) : GeodeException( message ) { } CqExistsException( String^
message, System::Exception^ innerException ) : GeodeException( message,
innerException ) { } protected: CqExistsException( SerializationInfo^ info,
StreamingContext context ) : GeodeException( info, context ) { } internal:
CqExistsException(const apache::geode:: [...]
- _GF_MG_EXCEPTION_DEF3( InvalidDeltaException );
+ [Serializable] public ref class InvalidDeltaException: public
GeodeException { public: InvalidDeltaException( ) : GeodeException( ) { }
InvalidDeltaException( String^ message ) : GeodeException( message ) { }
InvalidDeltaException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: InvalidDeltaException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: InvalidDeltaExcepti [...]
/// <summary>
/// Thrown if a Key is not present in the region.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( KeyNotFoundException );
+ [Serializable] public ref class KeyNotFoundException: public
GeodeException { public: KeyNotFoundException( ) : GeodeException( ) { }
KeyNotFoundException( String^ message ) : GeodeException( message ) { }
KeyNotFoundException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected: KeyNotFoundException(
SerializationInfo^ info, StreamingContext context ) : GeodeException( info,
context ) { } internal: KeyNotFoundException(con [...]
/// <summary>
/// Thrown if commit fails.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( CommitConflictException );
+ [Serializable] public ref class CommitConflictException: public
GeodeException { public: CommitConflictException( ) : GeodeException( ) { }
CommitConflictException( String^ message ) : GeodeException( message ) { }
CommitConflictException( String^ message, System::Exception^ innerException ) :
GeodeException( message, innerException ) { } protected:
CommitConflictException( SerializationInfo^ info, StreamingContext context ) :
GeodeException( info, context ) { } internal: CommitCon [...]
/// <summary>
/// Thrown if transaction delegate went down.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( TransactionDataNodeHasDepartedException );
+ [Serializable] public ref class TransactionDataNodeHasDepartedException:
public GeodeException { public: TransactionDataNodeHasDepartedException( ) :
GeodeException( ) { } TransactionDataNodeHasDepartedException( String^ message
) : GeodeException( message ) { } TransactionDataNodeHasDepartedException(
String^ message, System::Exception^ innerException ) : GeodeException( message,
innerException ) { } protected: TransactionDataNodeHasDepartedException(
SerializationInfo^ info, Stre [...]
/// <summary>
/// Thrown if commit rebalance happens during a transaction.
/// </summary>
- _GF_MG_EXCEPTION_DEF3( TransactionDataRebalancedException );
+ [Serializable] public ref class TransactionDataRebalancedException:
public GeodeException { public: TransactionDataRebalancedException( ) :
GeodeException( ) { } TransactionDataRebalancedException( String^ message ) :
GeodeException( message ) { } TransactionDataRebalancedException( String^
message, System::Exception^ innerException ) : GeodeException( message,
innerException ) { } protected: TransactionDataRebalancedException(
SerializationInfo^ info, StreamingContext context ) : [...]
+
} // namespace Client
} // namespace Geode
} // namespace Apache
