geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [19/52] [partial] geode-native git commit: GEODE-3165: Reogranized sources relative to the root for better CMake IDE integration.
Date Fri, 11 Aug 2017 23:52:35 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/ExceptionTypes.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/ExceptionTypes.cpp b/clicache/src/ExceptionTypes.cpp
new file mode 100644
index 0000000..e8eeb0c
--- /dev/null
+++ b/clicache/src/ExceptionTypes.cpp
@@ -0,0 +1,159 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ExceptionTypes.hpp"
+#include <cstdlib>
+
+using namespace System;
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+
+#define _GF_MG_EXCEPTION_ADD3(x) { "apache::geode::client::" #x, gcnew CreateException2( x::Create ) }
+#define _GF_MG_EXCEPTION_ADD4(x,y) { "apache::geode::client::" #y, gcnew CreateException2( x::Create ) }
+
+      Dictionary<String^, CreateException2^>^ GeodeException::Init( )
+      {
+        if (Native2ManagedExMap != nullptr)
+        {
+          return Native2ManagedExMap;
+        }
+        array<NameDelegatePair>^ exNamesDelegates = gcnew array<NameDelegatePair> {
+          _GF_MG_EXCEPTION_ADD3( AssertionException ),
+          _GF_MG_EXCEPTION_ADD3( IllegalArgumentException ),
+          _GF_MG_EXCEPTION_ADD3( IllegalStateException ),
+          _GF_MG_EXCEPTION_ADD3( CacheExistsException ),
+          _GF_MG_EXCEPTION_ADD3( CacheXmlException ),
+          _GF_MG_EXCEPTION_ADD3( TimeoutException ),
+          _GF_MG_EXCEPTION_ADD3( CacheWriterException ),
+          _GF_MG_EXCEPTION_ADD3( CacheListenerException ),
+          _GF_MG_EXCEPTION_ADD3( RegionExistsException ),
+          _GF_MG_EXCEPTION_ADD3( CacheClosedException ),
+          _GF_MG_EXCEPTION_ADD3( LeaseExpiredException ),
+          _GF_MG_EXCEPTION_ADD3( CacheLoaderException ),
+          _GF_MG_EXCEPTION_ADD3( RegionDestroyedException ),
+          _GF_MG_EXCEPTION_ADD3( EntryDestroyedException ),
+          _GF_MG_EXCEPTION_ADD3( NoSystemException ),
+          _GF_MG_EXCEPTION_ADD3( AlreadyConnectedException ),
+          _GF_MG_EXCEPTION_ADD3( FileNotFoundException ),          
+          _GF_MG_EXCEPTION_ADD3( InterruptedException ),
+          _GF_MG_EXCEPTION_ADD3( UnsupportedOperationException ),
+          _GF_MG_EXCEPTION_ADD3( StatisticsDisabledException ),
+          _GF_MG_EXCEPTION_ADD3( ConcurrentModificationException ),
+          _GF_MG_EXCEPTION_ADD3( UnknownException ),
+          _GF_MG_EXCEPTION_ADD3( ClassCastException ),
+          _GF_MG_EXCEPTION_ADD3( EntryNotFoundException ),
+          _GF_MG_EXCEPTION_ADD4( GeodeIOException, GeodeIOException ),
+          _GF_MG_EXCEPTION_ADD4( GeodeConfigException, GeodeConfigException ),
+          _GF_MG_EXCEPTION_ADD3( NullPointerException ),
+          _GF_MG_EXCEPTION_ADD3( EntryExistsException ),
+          _GF_MG_EXCEPTION_ADD3( NotConnectedException ),
+          _GF_MG_EXCEPTION_ADD3( CacheProxyException ),
+          _GF_MG_EXCEPTION_ADD3( OutOfMemoryException ),
+          _GF_MG_EXCEPTION_ADD3( NotOwnerException ),
+          _GF_MG_EXCEPTION_ADD3( WrongRegionScopeException ),
+          _GF_MG_EXCEPTION_ADD3( BufferSizeExceededException ),
+          _GF_MG_EXCEPTION_ADD3( RegionCreationFailedException ),
+          _GF_MG_EXCEPTION_ADD3( FatalInternalException ),
+          _GF_MG_EXCEPTION_ADD3( DiskFailureException ),
+          _GF_MG_EXCEPTION_ADD3( DiskCorruptException ),
+          _GF_MG_EXCEPTION_ADD3( InitFailedException ),
+          _GF_MG_EXCEPTION_ADD3( ShutdownFailedException ),
+          _GF_MG_EXCEPTION_ADD3( CacheServerException ),
+          _GF_MG_EXCEPTION_ADD3( OutOfRangeException ),
+          _GF_MG_EXCEPTION_ADD3( QueryException ),
+          _GF_MG_EXCEPTION_ADD3( MessageException ),
+          _GF_MG_EXCEPTION_ADD3( NotAuthorizedException ),
+          _GF_MG_EXCEPTION_ADD3( AuthenticationFailedException ),
+          _GF_MG_EXCEPTION_ADD3( AuthenticationRequiredException ),
+          _GF_MG_EXCEPTION_ADD3( DuplicateDurableClientException ),
+          _GF_MG_EXCEPTION_ADD3( NoAvailableLocatorsException ),
+          _GF_MG_EXCEPTION_ADD3( FunctionExecutionException ),
+          _GF_MG_EXCEPTION_ADD3( CqInvalidException ),
+          _GF_MG_EXCEPTION_ADD3( CqExistsException ),
+          _GF_MG_EXCEPTION_ADD3( CqQueryException ),
+          _GF_MG_EXCEPTION_ADD3( CqClosedException ),
+          _GF_MG_EXCEPTION_ADD3( CqException ),
+          _GF_MG_EXCEPTION_ADD3( AllConnectionsInUseException ),
+          _GF_MG_EXCEPTION_ADD3( InvalidDeltaException ),
+          _GF_MG_EXCEPTION_ADD3( KeyNotFoundException ),
+          _GF_MG_EXCEPTION_ADD3( CommitConflictException ),
+		  _GF_MG_EXCEPTION_ADD3( TransactionDataNodeHasDepartedException ),
+		  _GF_MG_EXCEPTION_ADD3( TransactionDataRebalancedException )
+        };
+
+        Native2ManagedExMap = gcnew Dictionary<String^, CreateException2^>( );
+        for (System::Int32 index = 0; index < exNamesDelegates->Length; index++)
+        {
+          Native2ManagedExMap[ exNamesDelegates[ index ].m_name ] =
+            exNamesDelegates[ index ].m_delegate;
+        }
+        return Native2ManagedExMap;
+      }
+
+      System::Exception^ GeodeException::Get(const apache::geode::client::Exception& nativeEx)
+      {
+        Exception^ innerException = nullptr;
+        const apache::geode::client::ExceptionPtr& cause = nativeEx.getCause();
+        if (cause != nullptr) {
+          innerException = GeodeException::Get(*cause);
+        }
+        String^ exName = gcnew String( nativeEx.getName( ) );
+        CreateException2^ exDelegate;
+        if (Native2ManagedExMap->TryGetValue(exName, exDelegate)) {
+          return exDelegate(nativeEx, innerException);
+        }
+        String^ exMsg = ManagedString::Get( nativeEx.getMessage( ) );
+        if ( exMsg->StartsWith( GeodeException::MgSysExPrefix ) ) {
+          // Get the exception type
+          String^ mgExStr = exMsg->Substring(
+            GeodeException::MgSysExPrefix->Length );
+          System::Int32 colonIndex = mgExStr->IndexOf( ':' );
+          if ( colonIndex > 0 ) {
+            String^ mgExName = mgExStr->Substring( 0, colonIndex )->Trim( );
+            // Try to load this class by reflection
+            Type^ mgExType = Type::GetType( mgExName, false, true );
+            if ( mgExType != nullptr ) {
+              System::Reflection::ConstructorInfo^ cInfo = mgExType->
+                GetConstructor(gcnew array<Type^>{ String::typeid, Exception::typeid });
+              if ( cInfo != nullptr ) {
+                String^ mgMsg = mgExStr->Substring( colonIndex + 1 );
+                Exception^ mgEx = dynamic_cast<Exception^>(cInfo->Invoke(
+                      gcnew array<Object^>{ mgMsg, innerException }));
+                if ( mgEx != nullptr ) {
+                  return mgEx;
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
+        }
+        if (innerException == nullptr) {
+          return gcnew GeodeException(exName + ": " + exMsg,
+              gcnew GeodeException(GetStackTrace(nativeEx)));
+        }
+        else {
+          return gcnew GeodeException(exName + ": " + exMsg, innerException);
+        }
+      }
+      } // end namespace generic
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/ExceptionTypes.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/ExceptionTypes.hpp b/clicache/src/ExceptionTypes.hpp
new file mode 100644
index 0000000..491dfcb
--- /dev/null
+++ b/clicache/src/ExceptionTypes.hpp
@@ -0,0 +1,686 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "geode_defs.hpp"
+#include "begin_native.hpp"
+#include <geode/ExceptionTypes.hpp>
+#include "end_native.hpp"
+
+#include "impl/ManagedString.hpp"
+
+
+using namespace System;
+using namespace System::Collections::Generic;
+using namespace System::Runtime::Serialization;
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+
+      ref class GeodeException;
+
+      /// <summary>
+      /// Factory delegate to create a managed Geode exception.
+      /// </summary>
+      /// <remarks>
+      /// For each managed exception class, its factory delegate is registered
+      /// and maintained in a static dictionary mapped to its corresponding
+      /// native Geode C++ exception name.
+      /// </remarks>
+      delegate GeodeException^ CreateException2(
+        const apache::geode::client::Exception& nativeEx, System::Exception^ innerException);
+
+      /// <summary>
+      /// The base exception class of all managed Geode exceptions.
+      /// </summary>
+      [Serializable]
+      public ref class GeodeException
+        : public System::Exception
+      {
+      private:
+
+        /// <summary>
+        /// Prefix for distiguishing managed system exceptions
+        /// </summary>
+        literal String^ MgSysExPrefix = "GFCLI_EXCEPTION:";
+
+        /// <summary>
+        /// This contains a mapping of the native Geode exception class
+        /// name to the factory delegate of the corresponding managed Geode
+        /// exception class.
+        /// </summary>
+        static Dictionary<String^, CreateException2^>^ Native2ManagedExMap =
+          Init( );
+
+        /// <summary>
+        /// Name and delegate pair class. The Native2ManagedExMap dictionary
+        /// is populated from a static array of this class.
+        /// </summary>
+        value class NameDelegatePair
+        {
+        public:
+
+          /// <summary>
+          /// The name of the native Geode exception class.
+          /// </summary>
+          String^ m_name;
+
+          /// <summary>
+          /// The factory delegate of the managed Geode exception class
+          /// corresponding to <c>m_name</c>
+          /// </summary>
+          CreateException2^ m_delegate;
+        };
+
+
+      internal:
+
+        /// <summary>
+        /// Static method to associate the native exception names with
+        /// the corresponding managed exception factory delegates.
+        /// </summary>
+        /// <remarks>
+        /// This method is not thread-safe and should be called in a single thread.
+        /// </remarks>
+        static Dictionary<String^, CreateException2^>^ Init( );
+
+        /// <summary>
+        /// Create the managed Geode exception for a given native Geode exception.
+        /// As a special case normal system exceptions are also created when the
+        /// native exception is a wrapper of a managed system exception.
+        /// </summary>
+        /// <remarks>
+        /// Wherever the native Geode C++ code raises a <c>apache::geode::client::Exception</c>,
+        /// the CLI wrapper code should have a catch-all for those and use
+        /// this function to create the corresponding managed Geode exception.
+        /// If no managed Geode exception has been defined (or has not been
+        /// added using _GF_MG_EXCEPTION_ADD3 in ExceptionTypesMN.cpp) then a
+        /// generic <c>GeodeException</c> exception is returned.
+        /// </remarks>
+        /// <param name="nativeEx">The native Geode exception object</param>
+        /// <returns>
+        /// The managed Geode exception object corresponding to the provided
+        /// native Geode exception object.
+        /// </returns>
+        static Exception^ Get(const apache::geode::client::Exception& nativeEx);
+
+        /// <summary>
+        /// Get the stack trace for the given native exception.
+        /// </summary>
+        /// <param name="nativeEx">The native Geode exception object</param>
+        /// <returns>The stack trace of the native exception.</returns>
+        inline static String^ GetStackTrace(
+          const apache::geode::client::Exception& nativeEx )
+        {
+          char nativeExStack[2048] = { '\0' };
+#ifndef _WIN64
+          nativeEx.getStackTrace(nativeExStack, 2047);
+#endif
+          return ManagedString::Get(nativeExStack);
+        }
+
+        /// <summary>
+        /// Gets the C++ native exception object for a given managed exception.
+        /// </summary>
+        /// <remarks>
+        /// This method is to handle conversion of managed exceptions to
+        /// C++ exception for those thrown by managed callbacks.
+        /// For non-Geode .NET exceptions we wrap it inside the generic
+        /// <c>GeodeException</c> with a special prefix in message.
+        /// While converting the exception back from C++ to .NET if the
+        /// prefix is found in the message, then it tries to construct
+        /// the original exception by reflection on the name of exception
+        /// contained in the message. Note that in this process the
+        /// original stacktrace is appended to the message of the exception.
+        /// </remarks>
+        inline static apache::geode::client::ExceptionPtr GetNative(Exception^ ex)
+        {
+          if (ex != nullptr) {
+            GeodeException^ gfEx = dynamic_cast<GeodeException^>(ex);
+            if (gfEx != nullptr) {
+              return gfEx->GetNative();
+            }
+            else {
+              apache::geode::client::ExceptionPtr cause;
+              if (ex->InnerException != nullptr) {
+                cause = GeodeException::GetNative(ex->InnerException);
+              }
+              ManagedString mg_exStr(MgSysExPrefix + ex->ToString());
+              return std::make_shared<apache::geode::client::Exception>(
+                  mg_exStr.CharPtr, __nullptr, false, cause);
+            }
+          }
+          return nullptr;
+        }
+
+        /// <summary>
+        /// Gets the C++ native exception object for this managed
+        /// <c>GeodeException</c>.
+        /// </summary>
+        virtual apache::geode::client::ExceptionPtr GetNative()
+        {
+          String^ msg = this->Message + ": " + this->StackTrace;
+          ManagedString mg_msg(msg);
+          apache::geode::client::ExceptionPtr cause;
+          if (this->InnerException != nullptr) {
+            cause = GeodeException::GetNative(this->InnerException);
+          }
+          return std::make_shared<apache::geode::client::Exception>(mg_msg.CharPtr,
+              __nullptr, false, cause);
+        }
+
+        /// <summary>
+        /// Throws the C++ native exception object for the given .NET exception.
+        /// </summary>
+        /// <remarks>
+        /// This method is to handle conversion of managed exceptions to
+        /// C++ exception for those thrown by managed callbacks.
+        /// For non-Geode .NET exceptions we wrap it inside the generic
+        /// <c>GeodeException</c> with a special prefix in message.
+        /// While converting the exception back from C++ to .NET if the
+        /// prefix is found in the message, then it tries to construct
+        /// the original exception by reflection on the name of exception
+        /// contained in the message. Note that in this process the
+        /// original stacktrace is appended to the message of the exception.
+        /// </remarks>
+        inline static void ThrowNative(Exception^ ex)
+        {
+          if (ex != nullptr) {
+            apache::geode::client::ExceptionPtr cause;
+            if (ex->InnerException != nullptr) {
+              cause = GeodeException::GetNative(ex->InnerException);
+            }
+            ManagedString mg_exStr(MgSysExPrefix + ex->ToString());
+            throw apache::geode::client::Exception(mg_exStr.CharPtr, NULL, false, cause);
+          }
+        }
+
+        /// <summary>
+        /// Throws the C++ native exception object for this managed
+        /// <c>GeodeException</c>.
+        /// </summary>
+        inline void ThrowNative()
+        {
+          GetNative()->raise();
+        }
+
+
+      public:
+
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        inline GeodeException( )
+          : Exception( ) { }
+
+        /// <summary>
+        /// Constructor to create an exception object with the given message.
+        /// </summary>
+        /// <param name="message">The exception message.</param>
+        inline GeodeException( String^ message )
+          : Exception( 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>
+        inline GeodeException( String^ message, System::Exception^ innerException )
+          : Exception( message, innerException ) { }
+
+      protected:
+
+        /// <summary>
+        /// Initializes a new instance of the <c>GeodeException</c> 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>
+        inline GeodeException( SerializationInfo^ info, StreamingContext context )
+          : Exception( info, context ) { }
+      };
+
+/// Handle geode exceptions from native layer and convert to managed
+/// exceptions.
+#define _GF_MG_EXCEPTION_TRY2        \
+      try {
+#define _GF_MG_EXCEPTION_CATCH_ALL2  \
+      } \
+      catch (const apache::geode::client::Exception& ex) { \
+      throw Apache::Geode::Client::GeodeException::Get(ex); \
+      } \
+      catch (System::AccessViolationException^ ex) { \
+        throw ex; \
+      }
+
+
+/// 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(ManagedString::Get(nativeEx.getMessage()), \
+              gcnew GeodeException(GeodeException::GetStackTrace( \
+                nativeEx))) { } \
+        \
+        x(const apache::geode::client::y& nativeEx, Exception^ innerException) \
+          : GeodeException(ManagedString::Get(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 apache::geode::client::ExceptionPtr GetNative() override \
+        { \
+          String^ msg = this->Message + ": " + this->StackTrace; \
+          ManagedString mg_msg(msg); \
+          apache::geode::client::ExceptionPtr cause; \
+          if (this->InnerException != nullptr) { \
+            cause = GeodeException::GetNative(this->InnerException); \
+          } \
+          return std::make_shared<apache::geode::client::y>(mg_msg.CharPtr, \
+              __nullptr, false, cause); \
+        } \
+      }
+
+/// 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
+      // should be added below *AND* it should also be added to the static array
+      // in ExceptionTypesMN.cpp using _GF_MG_EXCEPTION_ADD3( x )
+
+      /// <summary>
+      /// A geode assertion exception.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( AssertionException );
+
+      /// <summary>
+      /// Thrown when an argument to a method is illegal.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( IllegalArgumentException );
+
+      /// <summary>
+      /// Thrown when the state of cache is manipulated to be illegal.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( IllegalStateException );
+
+      /// <summary>
+      /// Thrown when an attempt is made to create an existing cache.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CacheExistsException );
+
+      /// <summary>
+      /// Thrown when the cache xml is incorrect.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CacheXmlException );
+
+      /// <summary>
+      /// Thrown when a timout occurs.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( TimeoutException );
+
+      /// <summary>
+      /// Thrown when the cache writer aborts the operation.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CacheWriterException );
+
+      /// <summary>
+      /// Thrown when the cache listener throws an exception.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CacheListenerException );
+
+      /// <summary>
+      /// Thrown when an attempt is made to create an existing region.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( RegionExistsException );
+
+      /// <summary>
+      /// Thrown when an operation is attempted on a closed cache.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CacheClosedException );
+
+      /// <summary>
+      /// Thrown when lease of cache proxy has expired.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( LeaseExpiredException );
+
+      /// <summary>
+      /// Thrown when the cache loader aborts the operation.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CacheLoaderException );
+
+      /// <summary>
+      /// Thrown when an operation is attempted on a destroyed region.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( RegionDestroyedException );
+
+      /// <summary>
+      /// Thrown when an operation is attempted on a destroyed entry.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( EntryDestroyedException );
+
+      /// <summary>
+      /// Thrown when the connecting target is not running.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( NoSystemException );
+
+      /// <summary>
+      /// Thrown when an attempt is made to connect to
+      /// DistributedSystem second time.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( AlreadyConnectedException );
+
+      /// <summary>
+      /// Thrown when a non-existing file is accessed.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( FileNotFoundException );
+
+      /// <summary>
+      /// Thrown when an operation is interrupted.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( InterruptedException );
+
+      /// <summary>
+      /// Thrown when an operation unsupported by the
+      /// current configuration is attempted.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( UnsupportedOperationException );
+
+      /// <summary>
+      /// Thrown when statistics are invoked for a region where
+      /// they are disabled.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( StatisticsDisabledException );
+
+      /// <summary>
+      /// Thrown when a concurrent operation fails.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( ConcurrentModificationException );
+
+      /// <summary>
+      /// An unknown exception occurred.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( UnknownException );
+
+      /// <summary>
+      /// Thrown when a cast operation fails.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( ClassCastException );
+
+      /// <summary>
+      /// Thrown when an operation is attempted on a non-existent entry.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( EntryNotFoundException );
+
+      /// <summary>
+      /// Thrown when there is an input/output error.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF4( GeodeIOException, GeodeIOException );
+
+      /// <summary>
+      /// Thrown when geode configuration file is incorrect.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF4( GeodeConfigException, GeodeConfigException );
+
+      /// <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 );
+
+      /// <summary>
+      /// Thrown when attempt is made to create an existing entry.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( EntryExistsException );
+
+      /// <summary>
+      /// Thrown when an operation is attempted before connecting
+      /// to the distributed system.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( NotConnectedException );
+
+      /// <summary>
+      /// Thrown when there is an error in the cache proxy.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CacheProxyException );
+
+      /// <summary>
+      /// Thrown when the system cannot allocate any more memory.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( OutOfMemoryException );
+
+      /// <summary>
+      /// Thrown when an attempt is made to release a lock not
+      /// owned by the thread.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( NotOwnerException );
+
+      /// <summary>
+      /// Thrown when a region is created in an incorrect scope.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( WrongRegionScopeException );
+
+      /// <summary>
+      /// Thrown when the internal buffer size is exceeded.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( BufferSizeExceededException );
+
+      /// <summary>
+      /// Thrown when a region creation operation fails.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( RegionCreationFailedException );
+
+      /// <summary>
+      /// Thrown when there is a fatal internal exception in Geode.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( FatalInternalException );
+
+      /// <summary>
+      /// Thrown by the persistence manager when a write
+      /// fails due to disk failure.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( DiskFailureException );
+
+      /// <summary>
+      /// Thrown by the persistence manager when the data
+      /// to be read from disk is corrupt.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( DiskCorruptException );
+
+      /// <summary>
+      /// Thrown when persistence manager fails to initialize.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( InitFailedException );
+
+      /// <summary>
+      /// Thrown when persistence manager fails to close properly.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( ShutdownFailedException );
+
+      /// <summary>
+      /// Thrown when an exception occurs on the cache server.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CacheServerException );
+
+      /// <summary>
+      /// Thrown when bound of array/vector etc. is exceeded.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( OutOfRangeException );
+
+      /// <summary>
+      /// Thrown when query exception occurs at the server.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( QueryException );
+
+      /// <summary>
+      /// Thrown when an unknown message is received from the server.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( MessageException );
+
+      /// <summary>
+      /// Thrown when a client operation is not authorized on the server.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( NotAuthorizedException );
+
+      /// <summary>
+      /// Thrown when authentication to the server fails.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( AuthenticationFailedException );
+
+      /// <summary>
+      /// Thrown when credentials are not provided to a server which expects them.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( AuthenticationRequiredException );
+
+      /// <summary>
+      /// Thrown when a duplicate durable client id is provided to the server.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( DuplicateDurableClientException );
+
+      /// <summary>
+      /// Thrown when a client is unable to contact any locators.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( NoAvailableLocatorsException );
+
+      /// <summary>
+      /// Thrown when all connections in a pool are in use..
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( AllConnectionsInUseException );
+
+      /// <summary>
+      /// Thrown when cq is invalid
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CqInvalidException );
+
+      /// <summary>
+      /// Thrown when function execution failed
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( FunctionExecutionException );
+
+      /// <summary>
+      /// Thrown during continuous query execution time.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CqException );
+
+      /// <summary>
+      /// Thrown if the Cq on which the operaion performed is closed
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CqClosedException );
+
+      /// <summary>
+      /// Thrown if the Cq Query failed
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CqQueryException );
+
+      /// <summary>
+      /// Thrown if a Cq by this name already exists on this client
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CqExistsException );
+
+      _GF_MG_EXCEPTION_DEF3( InvalidDeltaException );
+
+      /// <summary>
+      /// Thrown if a Key is not present in the region.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( KeyNotFoundException );
+
+      /// <summary>
+      /// Thrown if commit fails.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( CommitConflictException );
+
+	        /// <summary>
+      /// Thrown if transaction delegate went down.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( TransactionDataNodeHasDepartedException );
+
+	        /// <summary>
+      /// Thrown if commit rebalance happens during a transaction.
+      /// </summary>
+      _GF_MG_EXCEPTION_DEF3( TransactionDataRebalancedException );
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/Execution.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/Execution.cpp b/clicache/src/Execution.cpp
new file mode 100644
index 0000000..2ba9187
--- /dev/null
+++ b/clicache/src/Execution.cpp
@@ -0,0 +1,135 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+//#include "geode_includes.hpp"
+#include "Execution.hpp"
+#include "begin_native.hpp"
+#include <geode/Execution.hpp>
+#include "end_native.hpp"
+
+#include "ResultCollector.hpp"
+#include "impl/ManagedResultCollector.hpp"
+
+#include "impl/ManagedString.hpp"
+#include "ExceptionTypes.hpp"
+#include "impl/SafeConvert.hpp"
+
+using namespace System;
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+      namespace native = apache::geode::client;
+
+      generic<class TResult>
+      generic<class TFilter>
+      Execution<TResult>^ Execution<TResult>::WithFilter(System::Collections::Generic::ICollection<TFilter>^ routingObj)
+      {
+        if (routingObj != nullptr) {
+          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+          auto rsptr = native::CacheableVector::create();
+        
+          for each(TFilter item in routingObj)
+          {
+            rsptr->push_back(Serializable::GetUnmanagedValueGeneric<TFilter>( item, nullptr ));
+          }
+          
+          try
+          {
+            return Execution<TResult>::Create(m_nativeptr->get()->withFilter(rsptr), this->m_rc);
+          }
+          finally
+          {
+            GC::KeepAlive(m_nativeptr);
+          }
+          _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+        }
+        else {
+          throw gcnew IllegalArgumentException("Execution<TResult>::WithFilter: null TFilter provided");
+        }
+      }
+
+      generic<class TResult>
+      generic<class TArgs>
+      Execution<TResult>^ Execution<TResult>::WithArgs( TArgs args )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+          try
+          {
+            auto argsptr = Serializable::GetUnmanagedValueGeneric<TArgs>( args, nullptr );
+            return Execution<TResult>::Create(m_nativeptr->get()->withArgs(argsptr), this->m_rc);
+          }
+          finally
+          {
+            GC::KeepAlive(m_nativeptr);
+          }
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic<class TResult>
+      Execution<TResult>^ Execution<TResult>::WithCollector(Client::IResultCollector<TResult>^ rc)
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+          native::ResultCollectorPtr rcptr;
+        if ( rc != nullptr ) {
+          auto rcg = gcnew ResultCollectorGeneric<TResult>();
+          rcg->SetResultCollector(rc); 
+          rcptr = std::shared_ptr<native::ManagedResultCollectorGeneric>(new native::ManagedResultCollectorGeneric(rcg));
+        }
+        try
+        {
+          return Execution<TResult>::Create( m_nativeptr->get()->withCollector(rcptr), rc);
+        }
+        finally
+        {
+          GC::KeepAlive(m_nativeptr);
+        }
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic<class TResult>
+      IResultCollector<TResult>^ Execution<TResult>::Execute(String^ func, UInt32 timeout)
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+        try
+        {
+          ManagedString mg_function(func);
+          auto rc = m_nativeptr->get()->execute(mg_function.CharPtr, timeout);
+          if (m_rc == nullptr)
+            return gcnew ResultCollector<TResult>(rc);
+          else
+            return m_rc;
+        }
+        finally
+        {
+          GC::KeepAlive(m_nativeptr);
+        }
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic<class TResult>
+      IResultCollector<TResult>^ Execution<TResult>::Execute(String^ func)
+      {
+        return Execute(func, DEFAULT_QUERY_RESPONSE_TIMEOUT);
+      }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/Execution.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/Execution.hpp b/clicache/src/Execution.hpp
new file mode 100644
index 0000000..44fcf44
--- /dev/null
+++ b/clicache/src/Execution.hpp
@@ -0,0 +1,116 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "geode_defs.hpp"
+#include "begin_native.hpp"
+#include <geode/Execution.hpp>
+#include "end_native.hpp"
+
+#include "native_shared_ptr.hpp"
+
+using namespace System;
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+      namespace native = apache::geode::client;
+
+      generic<class TResult>
+      interface class IResultCollector;
+
+      generic<class TResult>
+      ref class ResultCollector;
+
+      /// <summary>
+      /// This class encapsulates events that occur for cq.
+      /// </summary>
+      generic<class TResult>
+      public ref class Execution sealed
+      {
+      public:
+        /// <summary>
+		/// Add a routing object, 
+        /// Return self.
+        /// </summary>
+		generic<class TFilter>
+    Execution<TResult>^ WithFilter(System::Collections::Generic::ICollection<TFilter>^ routingObj);
+
+        /// <summary>
+		/// Add an argument, 
+        /// Return self.
+        /// </summary>
+    generic<class TArgs>
+		Execution<TResult>^ WithArgs(TArgs args);
+
+        /// <summary>
+		/// Add a result collector, 
+        /// Return self.
+        /// </summary>
+		Execution<TResult>^ WithCollector(IResultCollector<TResult>^ rc);
+
+        /// <summary>
+        /// Execute a function, 
+        /// Return resultCollector.
+        /// </summary>
+		/// <param name="timeout"> Value to wait for the operation to finish before timing out.</param> 
+        IResultCollector<TResult>^ Execute(String^ func, UInt32 timeout);
+
+        /// <summary>
+        /// Execute a function, 
+        /// Return resultCollector.
+        /// </summary>
+        IResultCollector<TResult>^ Execute(String^ func);
+
+      internal:
+
+        /// <summary>
+        /// Internal factory function to wrap a native object pointer inside
+        /// this managed class with null pointer check.
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        /// <returns>
+        /// The managed wrapper object; null if the native pointer is null.
+        /// </returns>
+        inline static Execution<TResult>^ Create( native::ExecutionPtr nativeptr, IResultCollector<TResult>^ rc )
+        {
+          return __nullptr == nativeptr ? nullptr :
+            gcnew Execution<TResult>( nativeptr, rc );
+	      }
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer.
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline Execution( native::ExecutionPtr nativeptr, IResultCollector<TResult>^ rc )
+        {
+          m_rc = rc;
+          m_nativeptr = gcnew native_shared_ptr<native::Execution>(nativeptr);
+        }
+      private:
+        IResultCollector<TResult>^ m_rc;
+
+        native_shared_ptr<native::Execution>^ m_nativeptr;
+      };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/ExpirationAction.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/ExpirationAction.hpp b/clicache/src/ExpirationAction.hpp
new file mode 100644
index 0000000..c8a12bf
--- /dev/null
+++ b/clicache/src/ExpirationAction.hpp
@@ -0,0 +1,138 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+#pragma once
+
+#include "geode_defs.hpp"
+#include "begin_native.hpp"
+#include <geode/ExpirationAction.hpp>
+#include "end_native.hpp"
+
+
+
+using namespace System;
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+
+      /// <summary>
+      /// Enumerated type for expiration (LRU) actions.
+      /// Contains values for setting an action type.
+      /// </summary>
+      public enum class ExpirationAction
+      {
+        /// <summary>
+        /// When the region or cached object expires, it is invalidated.
+        /// </summary>
+        Invalidate = 0,
+
+        /// <summary>
+        /// When expired, invalidated locally only.
+        /// </summary>
+        LocalInvalidate,
+
+        /// <summary>
+        /// When the region or cached object expires, it is destroyed.
+        /// </summary>
+        Destroy,
+
+        /// <summary>
+        /// When expired, destroyed locally only.
+        /// </summary>
+        LocalDestroy,
+
+        /// <summary>Invalid action type.</summary>
+        InvalidAction
+      };
+
+
+      /// <summary>
+      /// Static class containing convenience methods for <c>ExpirationAction</c>.
+      /// </summary>
+      public ref class Expiration STATICCLASS
+      {
+      public:
+
+        /// <summary>
+        /// Returns true if this action is distributed invalidate.
+        /// </summary>
+        /// <returns>true if this an <c>Invalidate</c></returns>
+        inline static bool IsInvalidate( ExpirationAction type ) 
+        {
+          return (type == ExpirationAction::Invalidate);
+        }
+
+        /// <summary>
+        /// Returns true if this action is local invalidate.
+        /// </summary>
+        /// <returns>true if this is a <c>LocalInvalidate</c></returns>
+        inline static bool IsLocalInvalidate( ExpirationAction type ) 
+        {
+          return (type == ExpirationAction::LocalInvalidate);
+        }
+
+        /// <summary>
+        /// Returns true if this action is distributed destroy.
+        /// </summary>
+        /// <returns>true if this is <c>Destroy</c></returns>
+        inline static bool IsDestroy( ExpirationAction type ) 
+        {
+          return (type == ExpirationAction::Destroy);
+        }
+
+        /// <summary>
+        /// Returns true if this action is local destroy.
+        /// </summary>
+        /// <returns>true if this is <c>LocalDestroy</c></returns>
+        inline static bool IsLocalDestroy( ExpirationAction type )
+        {
+          return (type == ExpirationAction::LocalDestroy);
+        }
+
+        /// <summary>
+        /// Returns true if this action is local.
+        /// </summary>
+        /// <returns>true if this is <c>LocalInvalidate</c> or
+        /// <c>LocalDestroy</c></returns>
+        inline static bool IsLocal( ExpirationAction type )
+        {
+          return (type == ExpirationAction::LocalInvalidate) ||
+            (type == ExpirationAction::LocalDestroy);
+        }
+
+        /// <summary>
+        /// Returns true if this action is distributed.
+        /// </summary>
+        /// <returns>true if this is an <c>Invalidate</c> or
+        /// a <c>Destroy</c></returns>
+        inline static bool IsDistributed( ExpirationAction type ) 
+        {
+          return (type == ExpirationAction::Invalidate) ||
+            (type == ExpirationAction::Destroy);
+        }
+      };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/FunctionService.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/FunctionService.cpp b/clicache/src/FunctionService.cpp
new file mode 100644
index 0000000..456f2e5
--- /dev/null
+++ b/clicache/src/FunctionService.cpp
@@ -0,0 +1,115 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "begin_native.hpp"
+#include <geode/RegionService.hpp>
+#include "end_native.hpp"
+
+#include "FunctionService.hpp"
+#include "Pool.hpp"
+#include "Region.hpp"
+#include "Execution.hpp"
+
+#include "impl/AuthenticatedCache.hpp"
+
+using namespace System;
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+      namespace native = apache::geode::client;
+
+      generic <class TResult>
+      generic <class TKey, class TValue>
+      Execution<TResult>^ FunctionService<TResult>::OnRegion( IRegion<TKey, TValue>^ rg )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+          
+          auto nativeRegion = ((Region<TKey, TValue>^)rg)->GetNative();
+          auto execution = native::FunctionService::onRegion(nativeRegion);
+          return Execution<TResult>::Create( execution, nullptr );
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic <class TResult>
+      Execution<TResult>^ FunctionService<TResult>::OnServer( Pool^ pl )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          auto nativeptr = native::FunctionService::onServer(pl->GetNative());
+          return Execution<TResult>::Create( nativeptr , nullptr);
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+      
+      generic <class TResult>
+      Execution<TResult>^ FunctionService<TResult>::OnServers( Pool^ pl )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          auto nativeptr = native::FunctionService::onServers(pl->GetNative());
+          return Execution<TResult>::Create( nativeptr , nullptr);
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic<class TResult>
+      Execution<TResult>^ FunctionService<TResult>::OnServer( IRegionService^ cache )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          if(auto realCache = dynamic_cast<Cache^>(cache))
+          {
+            auto nativeptr = native::FunctionService::onServer(realCache->GetNative());
+            return Execution<TResult>::Create( nativeptr, nullptr );
+          }
+          else
+          {
+            auto authCache = dynamic_cast<AuthenticatedCache^>(cache);
+            auto nativeptr = native::FunctionService::onServer(authCache->GetNative());
+            return Execution<TResult>::Create( nativeptr, nullptr );
+          }
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic<class TResult>
+      Execution<TResult>^ FunctionService<TResult>::OnServers( IRegionService^ cache )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          if(auto realCache = dynamic_cast<Cache^>(cache))
+          {
+            auto nativeptr = native::FunctionService::onServers(realCache->GetNative());
+            return Execution<TResult>::Create( nativeptr, nullptr );
+          }
+          else
+          {
+            auto authCache = dynamic_cast<AuthenticatedCache^>(cache);
+            auto nativeptr = native::FunctionService::onServers(authCache->GetNative());
+            return Execution<TResult>::Create( nativeptr, nullptr );
+          }
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/FunctionService.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/FunctionService.hpp b/clicache/src/FunctionService.hpp
new file mode 100644
index 0000000..7af9bc8
--- /dev/null
+++ b/clicache/src/FunctionService.hpp
@@ -0,0 +1,96 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "geode_defs.hpp"
+#include "begin_native.hpp"
+#include <geode/FunctionService.hpp>
+#include "end_native.hpp"
+
+#include "Cache.hpp"
+
+using namespace System;
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+
+    //  generic<class TKey, class TValue>
+      ref class Pool;
+     
+      generic<class TResult>
+      ref class Execution;
+
+      /// <summary>
+      /// A factory class used to create Execute object for function execution
+      /// </summary>
+      /// <remarks>
+      generic<class TResult>
+      public ref class FunctionService
+      {
+      public:
+
+        /// <summary>
+        /// Creates a new region Execution object
+        /// </summary>
+        /// <remarks>
+        /// If Pool is multiusersecure mode then one need to pass logical instance of Region Pool->CreateSecureUserCache(<credentials>)->getRegion(<regionPath>).
+        /// </remarks>
+        generic <class TKey, class TValue>
+        static Execution<TResult>^ OnRegion( IRegion<TKey, TValue>^ rg );
+
+        /// <summary>
+        /// Creates a new Execution object on one server
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <exception cref="UnsupportedOperationException">unsupported operation exception, when Pool is in multiusersecure mode.</exception>
+        static Execution<TResult>^ OnServer( Pool^ pl );
+
+        /// <summary>
+        /// Creates a new Execution object on all servers in the pool
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <exception cref="UnsupportedOperationException">unsupported operation exception, when Pool is in multiusersecure mode.</exception>
+        static Execution<TResult>^ OnServers( Pool^ pl );
+
+        /// <summary>
+        /// Creates a new Execution object on one server.
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <exception cref="IllegalStateException">when Pool has been closed.</exception>
+        static Execution<TResult>^ OnServer( IRegionService^ cache );
+
+        /// <summary>
+        /// Creates a new Execution object on all servers in the pool.
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <exception cref="IllegalStateException">when Pool has been closed.</exception>
+        static Execution<TResult>^ OnServers( IRegionService^ cache );
+        
+      };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/GeodeClassIds.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/GeodeClassIds.hpp b/clicache/src/GeodeClassIds.hpp
new file mode 100644
index 0000000..9d6eebd
--- /dev/null
+++ b/clicache/src/GeodeClassIds.hpp
@@ -0,0 +1,372 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+
+
+#include "geode_defs.hpp"
+#include "begin_native.hpp"
+#include <geode/GeodeTypeIds.hpp>
+#include "end_native.hpp"
+
+
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+
+      struct PdxTypes
+      {
+        enum PdxTypesInternal
+        {
+          BOOLEAN,
+          BYTE,
+          CHAR,
+          SHORT,
+          INT,
+          LONG,
+          FLOAT,
+          DOUBLE,
+          DATE,
+          STRING,
+          OBJECT,
+          BOOLEAN_ARRAY,
+          CHAR_ARRAY,
+          BYTE_ARRAY,
+          SHORT_ARRAY,
+          INT_ARRAY,
+          LONG_ARRAY,
+          FLOAT_ARRAY,
+          DOUBLE_ARRAY,
+          STRING_ARRAY,
+          OBJECT_ARRAY,
+          ARRAY_OF_BYTE_ARRAYS
+        };
+      };
+
+      /// <summary>
+      /// Static class containing the classIds of the built-in cacheable types.
+      /// </summary>
+      public ref class GeodeClassIds
+      {
+      public:
+
+        /// <summary>
+        /// ClassId of <c>Properties</c> class
+        /// </summary>
+        literal System::UInt32 Properties =
+          apache::geode::client::GeodeTypeIds::Properties + 0x80000000;
+
+        /// <summary>        
+        /// ClassId of <c>CharArray</c> class
+        /// </summary>
+        literal System::UInt32 CharArray =
+          apache::geode::client::GeodeTypeIds::CharArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>BooleanArray</c> class
+        /// </summary>
+        literal System::UInt32 BooleanArray =
+          apache::geode::client::GeodeTypeIds::BooleanArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>RegionAttributes</c> class
+        /// </summary>
+        literal System::UInt32 RegionAttributes =
+          apache::geode::client::GeodeTypeIds::RegionAttributes + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableUndefined</c> class
+        /// Implementation note: this has DSFID of FixedIDByte hence a
+        /// different increment.
+        /// </summary>
+        literal System::UInt32 CacheableUndefined =
+          apache::geode::client::GeodeTypeIds::CacheableUndefined + 0xa0000000;
+
+        literal System::UInt32 EnumInfo =
+          apache::geode::client::GeodeTypeIds::EnumInfo + 0xa0000000;
+
+        /// <summary>
+        /// ClassId of <c>Struct</c> class
+        /// </summary>
+        literal System::UInt32 Struct =
+          apache::geode::client::GeodeTypeIds::Struct + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class
+        /// </summary>
+        literal System::UInt32 CacheableString =
+          apache::geode::client::GeodeTypeIds::CacheableString + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class for huge strings
+        /// </summary>
+        literal System::UInt32 CacheableStringHuge =
+          apache::geode::client::GeodeTypeIds::CacheableStringHuge + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableBytes</c> class
+        /// </summary>
+        literal System::UInt32 CacheableBytes =
+          apache::geode::client::GeodeTypeIds::CacheableBytes + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt16Array</c> class
+        /// </summary>
+        literal System::UInt32 CacheableInt16Array =
+          apache::geode::client::GeodeTypeIds::CacheableInt16Array + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt32Array</c> class
+        /// </summary>
+        literal System::UInt32 CacheableInt32Array =
+          apache::geode::client::GeodeTypeIds::CacheableInt32Array + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt64Array</c> class
+        /// </summary>
+        literal System::UInt32 CacheableInt64Array =
+          apache::geode::client::GeodeTypeIds::CacheableInt64Array + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableFloatArray</c> class
+        /// </summary>
+        literal System::UInt32 CacheableFloatArray =
+          apache::geode::client::GeodeTypeIds::CacheableFloatArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableDoubleArray</c> class
+        /// </summary>
+        literal System::UInt32 CacheableDoubleArray =
+          apache::geode::client::GeodeTypeIds::CacheableDoubleArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableVector</c> class for object arrays
+        /// </summary>
+        literal System::UInt32 CacheableObjectArray =
+          apache::geode::client::GeodeTypeIds::CacheableObjectArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableBoolean</c> class
+        /// </summary>
+        literal System::UInt32 CacheableBoolean =
+          apache::geode::client::GeodeTypeIds::CacheableBoolean + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt16</c> class for wide-characters
+        /// </summary>
+        literal System::UInt32 CacheableCharacter =
+          apache::geode::client::GeodeTypeIds::CacheableWideChar + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableByte</c> class
+        /// </summary>
+        literal System::UInt32 CacheableByte =
+          apache::geode::client::GeodeTypeIds::CacheableByte + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt16</c> class
+        /// </summary>
+        literal System::UInt32 CacheableInt16 =
+          apache::geode::client::GeodeTypeIds::CacheableInt16 + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt32</c> class
+        /// </summary>
+        literal System::UInt32 CacheableInt32 =
+          apache::geode::client::GeodeTypeIds::CacheableInt32 + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt64</c> class
+        /// </summary>
+        literal System::UInt32 CacheableInt64 =
+          apache::geode::client::GeodeTypeIds::CacheableInt64 + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableFloat</c> class
+        /// </summary>
+        literal System::UInt32 CacheableFloat =
+          apache::geode::client::GeodeTypeIds::CacheableFloat + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableDouble</c> class
+        /// </summary>
+        literal System::UInt32 CacheableDouble =
+          apache::geode::client::GeodeTypeIds::CacheableDouble + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableDate</c> class
+        /// </summary>
+        literal System::UInt32 CacheableDate =
+          apache::geode::client::GeodeTypeIds::CacheableDate + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableFileName</c> class
+        /// </summary>
+        literal System::UInt32 CacheableFileName =
+          apache::geode::client::GeodeTypeIds::CacheableFileName + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableStringArray</c> class
+        /// </summary>
+        literal System::UInt32 CacheableStringArray =
+          apache::geode::client::GeodeTypeIds::CacheableStringArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableVector</c> class
+        /// </summary>
+        literal System::UInt32 CacheableVector =
+          apache::geode::client::GeodeTypeIds::CacheableVector + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableStack</c> class
+        /// </summary>
+        literal System::UInt32 CacheableStack =
+          apache::geode::client::GeodeTypeIds::CacheableStack + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableArrayList</c> class
+        /// </summary>
+        literal System::UInt32 CacheableArrayList =
+          apache::geode::client::GeodeTypeIds::CacheableArrayList + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableArrayList</c> class
+        /// </summary>
+        literal System::UInt32 CacheableLinkedList =
+          apache::geode::client::GeodeTypeIds::CacheableLinkedList + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableHashSet</c> class
+        /// </summary>
+        literal System::UInt32 CacheableHashSet =
+          apache::geode::client::GeodeTypeIds::CacheableHashSet + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableLinkedHashSet</c> class
+        /// </summary>
+        literal System::UInt32 CacheableLinkedHashSet =
+          apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableHashMap</c> class
+        /// </summary>
+        literal System::UInt32 CacheableHashMap =
+          apache::geode::client::GeodeTypeIds::CacheableHashMap + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableHashTable</c> class
+        /// </summary>
+        literal System::UInt32 CacheableHashTable =
+          apache::geode::client::GeodeTypeIds::CacheableHashTable + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableIdentityHashMap</c> class
+        /// </summary>
+        literal System::UInt32 CacheableIdentityHashMap =
+          apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap + 0x80000000;
+
+        /// <summary>
+        /// Not used.
+        /// </summary>
+        literal System::UInt32 CacheableTimeUnit =
+          apache::geode::client::GeodeTypeIds::CacheableTimeUnit + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class for null strings
+        /// </summary>
+        literal System::UInt32 CacheableNullString =
+          apache::geode::client::GeodeTypeIds::CacheableNullString + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class for ASCII strings
+        /// </summary>
+        literal System::UInt32 CacheableASCIIString =
+          apache::geode::client::GeodeTypeIds::CacheableASCIIString + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class for huge ASCII strings
+        /// </summary>
+        literal System::UInt32 CacheableASCIIStringHuge =
+          apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge + 0x80000000;
+
+
+        // Built-in managed types.
+
+        /// <summary>
+        /// ClassId of <c>CacheableObject</c> class
+        /// </summary>
+        literal System::UInt32 CacheableManagedObject = 7 + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableObjectXml</c> class
+        /// </summary>
+        literal System::UInt32 CacheableManagedObjectXml = 8 + 0x80000000;
+      internal:
+
+        literal System::UInt32 PdxType = apache::geode::client::GeodeTypeIds::PdxType + 0x80000000;
+
+        literal System::UInt32 DATA_SERIALIZABLE = 45;
+        literal System::UInt32 JAVA_CLASS = 43;
+
+        //internal geode typeids..
+        /*  literal Byte USERCLASS = 40;
+          literal Byte USERMAP = 94;
+          literal Byte USERCOLLECTION = 95;
+          literal Byte ARRAYOFBYTEARRAYS = 91;
+          literal Byte GEODEREGION =  98;
+
+          literal Byte BOOLEAN_TYPE = 17;
+          literal Byte CHARACTER_TYPE = 18;
+          literal Byte BYTE_TYPE = 19;
+          literal Byte SHORT_TYPE = 20;
+          literal Byte INTEGER_TYPE = 21;
+          literal Byte LONG_TYPE = 22;
+          literal Byte FLOAT_TYPE = 23;
+          literal Byte DOUBLE_TYPE = 24;
+          literal Byte VOID_TYPE = 25;   */
+
+        literal Byte PDX = 93;
+        literal Byte PDX_ENUM = 94;
+
+        literal Byte BYTE_SIZE = 1;
+
+        literal Byte BOOLEAN_SIZE = 1;
+
+        literal Byte CHAR_SIZE = 2;
+
+        literal Byte SHORT_SIZE = 2;
+
+        literal Byte INTEGER_SIZE = 4;
+
+        literal Byte FLOAT_SIZE = 4;
+
+        literal Byte LONG_SIZE = 8;
+
+        literal Byte DOUBLE_SIZE = 8;
+
+        literal Byte DATE_SIZE = 8;
+      };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/IAuthInitialize.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/IAuthInitialize.hpp b/clicache/src/IAuthInitialize.hpp
new file mode 100644
index 0000000..1b7decc
--- /dev/null
+++ b/clicache/src/IAuthInitialize.hpp
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "geode_defs.hpp"
+
+#include "Properties.hpp"
+
+using namespace System;
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+
+      /// <summary>
+      /// Specifies the mechanism to obtain credentials for a client.
+      /// It is mandantory for clients when the server is running in secure
+      /// mode having a <c>security-client-authenticator</c> module specified.
+      /// Implementations should register the library path as
+      /// <c>security-client-auth-library</c> system property and factory
+      /// function (a zero argument function returning pointer to an
+      /// AuthInitialize object) as the <c>security-client-auth-factory</c>
+      /// system property.
+      ///
+      /// For a managed class implementing <c>IAuthInitialize</c> the fully
+      /// qualified name of the factory function should be provided in the
+      /// form {Namespace}.{Class Name}.{Method Name} as the
+      /// <c>security-client-auth-factory</c> property.
+      /// </summary>
+      public interface class IAuthInitialize
+      {
+      public:
+
+        /// <summary>
+        /// Initialize with the given set of security properties
+        /// return the credentials for the client as properties.
+        /// </summary>
+        /// <param name="props">
+        /// the set of <c>security-*</c> properties provided to the
+        /// <see cref="DistributedSystem.connect"/> method
+        /// </param>
+        /// <param name="server">
+        /// the ID of the current endpoint in the format "host:port"
+        /// </param>
+        /// <returns>
+        /// the credentials to be used for the given server
+        /// </returns>
+        /// <remarks>
+        /// This method can modify the given set of properties. For
+        /// example it may invoke external agents or even interact with
+        /// the user.
+        /// </remarks>
+        //generic <class TPropKey, class TPropValue>
+        Properties<String^, Object^>^ GetCredentials(Properties<String^, String^>^ props, String^ server);
+
+        /// <summary>
+        /// Invoked before the cache goes down.
+        /// </summary>
+        void Close();
+
+        delegate Properties<String^, Object^>^ GetCredentialsDelegate(Properties<String^, String^>^ props, String^ server);
+        delegate void CloseDelegate();
+      };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/ICacheListener.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/ICacheListener.hpp b/clicache/src/ICacheListener.hpp
new file mode 100644
index 0000000..a61632e
--- /dev/null
+++ b/clicache/src/ICacheListener.hpp
@@ -0,0 +1,210 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "geode_defs.hpp"
+#include "IRegion.hpp"
+//#include "Region.hpp"
+
+#include "EntryEvent.hpp"
+#include "RegionEvent.hpp"
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+
+      /// <summary>
+      /// An application plug-in that can be installed on a region.
+      /// </summary>
+      /// <remarks>
+      /// Listeners are change notifications that are invoked
+      /// AFTER the change has occured for region update operations on a client.
+      /// Listeners also receive notifications when entries in a region are modified.
+      /// Multiple events can cause concurrent invocation
+      /// of <c>ICacheListener</c> methods.  If event A occurs before event B,
+      /// there is no guarantee that their corresponding <c>ICacheListener</c>
+      /// method invocations will occur in the same order. Any exceptions thrown by
+      /// the listener are caught by Geode and logged. If the exception is due to
+      /// listener invocation on the same thread where a region operation has been
+      /// performed, then a <c>CacheListenerException</c> is thrown back to
+      /// the application. If the exception is for a notification received from
+      /// server then that is logged and the notification thread moves on to
+      /// receiving other notifications.
+      /// <para>
+      /// A cache listener is defined in the <see cref="RegionAttributes" />.
+      /// </para>
+      ///
+      /// There are two cases in which listeners are invoked. The first is when a
+      /// region modification operation (e.g. put, create, destroy, invalidate)
+      /// is performed. For this case it is important to ensure that minimal work is
+      /// done in the listener before returning control back to Geode since the
+      /// operation will block till the listener has not completed. For example,
+      /// a listener implementation may choose to hand off the event to a thread pool
+      /// that then processes the event on its thread rather than the listener thread.
+      /// The second is when notifications are received from java server as a result
+      /// of region register interest calls (<c>Region.RegisterKeys</c> etc),
+      /// or invalidate notifications when notify-by-subscription is false on the
+      /// server. In this case the methods of <c>ICacheListener</c> are invoked
+      /// asynchronously (i.e. does not block the thread that receives notification
+      /// messages). Additionally for the latter case of notifications from server,
+      /// listener is always invoked whether or not local operation is successful
+      /// e.g. if a destroy notification is received and key does not exist in the
+      /// region, the listener will still be invoked. This is different from the
+      /// first case where listeners are invoked only when the region update
+      /// operation succeeds.
+      /// </remarks>
+      /// <seealso cref="AttributesFactory.SetCacheListener" />
+      /// <seealso cref="RegionAttributes.CacheListener" />
+      /// <seealso cref="ICacheLoader" />
+      /// <seealso cref="ICacheWriter" />
+      /// <seealso cref="CacheListenerException" />
+      generic<class TKey, class TValue>
+      public interface class ICacheListener
+      {
+        public:
+
+        /// <summary>
+        /// Handles the event of a new key being added to a region.
+        /// </summary>
+        /// <remarks>
+        /// The entry did not previously exist in this region in the local cache
+        /// (even with a null value).
+        /// <para>
+        /// This function does not throw any exception.
+        /// </para>
+        /// </remarks>
+        /// <param name="ev">
+        /// Denotes the event object associated with the entry creation.
+        /// </param>
+        /// <seealso cref="Region.Create" />
+        /// <seealso cref="Region.Put" />
+        /// <seealso cref="Region.Get" />
+        void AfterCreate(EntryEvent<TKey, TValue>^ ev);
+
+        /// <summary>
+        /// Handles the event of an entry's value being modified in a region.
+        /// </summary>
+        /// <remarks>
+        /// This entry previously existed in this region in the local cache,
+        /// but its previous value may have been null.
+        /// </remarks>
+        /// <param name="ev">
+        /// EntryEvent denotes the event object associated with updating the entry.
+        /// </param>
+        /// <seealso cref="Region.Put" />
+        void AfterUpdate(EntryEvent<TKey, TValue>^ ev);
+
+        /// <summary>
+        /// Handles the event of an entry's value being invalidated.
+        /// </summary>
+        /// <param name="ev">
+        /// EntryEvent denotes the event object associated with the entry invalidation.
+        /// </param>
+        void AfterInvalidate(EntryEvent<TKey, TValue>^ ev);
+
+        /// <summary>
+        /// Handles the event of an entry being destroyed.
+        /// </summary>
+        /// <param name="ev">
+        /// EntryEvent denotes the event object associated with the entry destruction.
+        /// </param>
+        /// <seealso cref="Region.Destroy" />
+        void AfterDestroy(EntryEvent<TKey, TValue>^ ev);
+
+        /// <summary>
+        /// Handles the event of a region being cleared.
+        /// </summary>
+        void AfterRegionClear(RegionEvent<TKey, TValue>^ ev);
+
+        /// <summary>
+        /// Handles the event of a region being invalidated.
+        /// </summary>
+        /// <remarks>
+        /// Events are not invoked for each individual value that is invalidated
+        /// as a result of the region being invalidated. Each subregion, however,
+        /// gets its own <c>RegionInvalidated</c> event invoked on its listener.
+        /// </remarks>
+        /// <param name="ev">
+        /// RegionEvent denotes the event object associated with the region invalidation.
+        /// </param>
+        /// <seealso cref="Region.InvalidateRegion" />
+        void AfterRegionInvalidate(RegionEvent<TKey, TValue>^ ev);
+
+        /// <summary>
+        /// Handles the event of a region being destroyed.
+        /// </summary>
+        /// <remarks>
+        /// Events are not invoked for each individual entry that is destroyed
+        /// as a result of the region being destroyed. Each subregion, however,
+        /// gets its own <c>AfterRegionDestroyed</c> event invoked on its listener.
+        /// </remarks>
+        /// <param name="ev">
+        /// RegionEvent denotes the event object associated with the region destruction.
+        /// </param>
+        /// <seealso cref="Region.DestroyRegion" />
+        void AfterRegionDestroy(RegionEvent<TKey, TValue>^ ev);
+
+        /// <summary>
+        /// Handles the event of a region going live.
+        /// </summary>
+        /// <remarks>
+        /// Each subregion gets its own <c>AfterRegionLive</c> event invoked on its listener.
+        /// </remarks>
+        /// <param name="ev">
+        /// RegionEvent denotes the event object associated with the region going live.
+        /// </param>
+        /// <seealso cref="Cache.ReadyForEvents" />
+        void AfterRegionLive(RegionEvent<TKey, TValue>^ ev);
+
+        /// <summary>
+        /// Called when the region containing this callback is destroyed, when
+        /// the cache is closed.
+        /// </summary>
+        /// <remarks>
+        /// Implementations should clean up any external resources,
+        /// such as database connections. Any runtime exceptions this method
+        /// throws will be logged.
+        /// </remarks>
+        /// <param>
+        /// It is possible for this method to be called multiple times on a single
+        /// callback instance, so implementations must be tolerant of this.
+        /// </param>
+        /// <seealso cref="Cache.Close" />
+        /// <seealso cref="Region.DestroyRegion" />
+        void Close(IRegion<TKey, TValue>^ region);
+
+        ///<summary>
+        ///Called when all the endpoints associated with region are down.
+        ///This will be called when all the endpoints are down for the first time.
+        ///If endpoints come up and again go down it will be called again.
+        ///This will also be called when all endpoints are down and region is attached to the pool.
+        ///</summary>
+        ///<remarks>
+        ///</remark>
+        ///<param>
+        ///region Region^ denotes the assosiated region.
+        ///</param>
+        void AfterRegionDisconnected(IRegion<TKey, TValue>^ region);
+      };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/ICacheLoader.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/ICacheLoader.hpp b/clicache/src/ICacheLoader.hpp
new file mode 100644
index 0000000..e5b1a8e
--- /dev/null
+++ b/clicache/src/ICacheLoader.hpp
@@ -0,0 +1,118 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "geode_defs.hpp"
+#include "begin_native.hpp"
+#include <geode/CacheLoader.hpp>
+#include "end_native.hpp"
+
+#include "IRegion.hpp"
+//#include "Region.hpp"
+//#include "ICacheableKey.hpp"
+
+namespace Apache
+{
+  namespace Geode
+  {
+    namespace Client
+    {
+
+      //interface class ICacheableKey;
+
+      /// <summary>
+      /// CacheLoader
+      /// </summary>
+      /// <remarks>
+      /// CacheLoader
+      /// </remarks>
+      public ref class CacheLoader STATICCLASS
+      {
+      };
+
+      /// <summary>
+      /// A data-loading application plug-in that can be installed on a region.
+      /// </summary>
+      /// <remarks>
+      /// Loaders facilitate loading of data into the cache from a third-party data source. 
+      /// When an application does a
+      /// lookup for a key in a region and it does not exist, Geode checks to
+      /// see if any loaders are available for the region in the system and
+      /// invokes them to get the value for the key into the cache.
+      /// <para>
+      /// A cache loader is defined in the <see cref="RegionAttributes" />.
+      /// </para>
+      /// When <see cref="Region.Get" /> is called for a region
+      /// entry that has a null value, the <see cref="ICacheLoader.Load" />
+      /// method of the region's cache loader is invoked.  The <c>Load</c> method
+      /// creates the value for the desired key by performing an operation such
+      /// as a database query. 
+      /// </remarks>
+      /// <seealso cref="AttributesFactory.SetCacheLoader" />
+      /// <seealso cref="RegionAttributes.CacheLoader" />
+      /// <seealso cref="ICacheListener" />
+      /// <seealso cref="ICacheWriter" />
+      generic<class TKey, class TValue>
+      public interface class ICacheLoader
+      {
+      public:
+
+        /// <summary>
+        /// Loads a value. Application writers should implement this
+        /// method to customize the loading of a value.
+        /// </summary>
+        /// <remarks>
+        /// This method is called
+        /// by the caching service when the requested value is not in the cache.
+        /// Any exception thrown by this method is propagated back to and thrown
+        /// by the invocation of <see cref="Region.Get" /> that triggered this load.
+        /// </remarks>
+        /// <param name="region">a Region for which this is called.</param>
+        /// <param name="key">the key for the cacheable</param>
+        /// <param name="callbackArgument">
+        /// </param>
+        /// <returns>
+        /// the value supplied for this key, or null if no value can be
+        /// supplied. 
+        /// If every available loader returns
+        /// a null value, <see cref="Region.Get" /> will return null.
+        /// </returns>
+        /// <seealso cref="Region.Get" />
+        TValue Load(IRegion<TKey, TValue>^ region, TKey key,
+                    Object^ callbackArgument);
+
+        /// <summary>
+        /// Called when the region containing this callback is destroyed, when
+        /// the cache is closed.
+        /// </summary>
+        /// <remarks>
+        /// Implementations should clean up any external resources, such as
+        /// database connections. Any runtime exceptions this method throws will be logged.
+        /// <para>
+        /// It is possible for this method to be called multiple times on a single
+        /// callback instance, so implementations must be tolerant of this.
+        /// </para>
+        /// </remarks>
+        /// <seealso cref="Cache.Close" />
+        /// <seealso cref="Region.DestroyRegion" />
+        void Close(IRegion<TKey, TValue>^ region);
+      };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+


Mime
View raw message