text: /*
   * 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 "RegionFactory.hpp"
  #include "RegionAttributes.hpp"
  #include "impl/SafeConvert.hpp"
  #include "impl/ManagedCacheLoader.hpp"
  #include "impl/ManagedCacheWriter.hpp"
  #include "impl/ManagedCacheListener.hpp"
  #include "impl/ManagedPartitionResolver.hpp"
  #include "impl/ManagedFixedPartitionResolver.hpp"
  #include "impl/ManagedFixedPartitionResolver.hpp"
  #include "impl/ManagedPersistenceManager.hpp"
  #include "impl/CacheLoader.hpp"
  #include "impl/CacheWriter.hpp"
  #include "impl/CacheListener.hpp"
  #include "impl/PartitionResolver.hpp"
  #include "impl/FixedPartitionResolver.hpp"
  #include "impl/FixedPartitionResolver.hpp"
  #include "impl/PersistenceManagerProxy.hpp"
  #include "TimeUtils.hpp"
  
  namespace Apache
  {
    namespace Geode
    {
      namespace Client
      {
        using namespace System;
        using namespace System::Collections::Generic;
  
        namespace native = apache::geode::client;
  
        RegionFactory^ RegionFactory::SetCacheLoader( String^ libPath, String^ factoryFunctionName )
        {
          throw gcnew System::NotSupportedException;
  
          try
          {
            m_nativeptr->get()->setCacheLoader( marshal_as<std::string>(libPath),
              marshal_as<std::string>(factoryFunctionName) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetCacheWriter( String^ libPath, String^ factoryFunctionName )
        {
          throw gcnew System::NotSupportedException;
  
          try
          {
            m_nativeptr->get()->setCacheWriter( marshal_as<std::string>(libPath),
              marshal_as<std::string>(factoryFunctionName) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetCacheListener( String^ libPath, String^ factoryFunctionName )
        {
          throw gcnew System::NotSupportedException;
  
          try
          {
            m_nativeptr->get()->setCacheListener( marshal_as<std::string>(libPath),
              marshal_as<std::string>(factoryFunctionName) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetPartitionResolver( String^ libPath, String^ factoryFunctionName )
        {
          throw gcnew System::NotSupportedException;
  
          try
          {
            m_nativeptr->get()->setPartitionResolver( marshal_as<std::string>(libPath),
              marshal_as<std::string>(factoryFunctionName) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        // EXPIRATION ATTRIBUTES
  
        RegionFactory^ RegionFactory::SetEntryIdleTimeout( ExpirationAction action, TimeSpan idleTimeout )
        {
          try
          {
            m_nativeptr->get()->setEntryIdleTimeout( static_cast<native::ExpirationAction>( action ), TimeUtils::TimeSpanToDurationCeil<std::chrono::seconds>(idleTimeout) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetEntryTimeToLive( ExpirationAction action, TimeSpan timeToLive )
        {
          try
          {
            m_nativeptr->get()->setEntryTimeToLive(static_cast<native::ExpirationAction>( action ), TimeUtils::TimeSpanToDurationCeil<std::chrono::seconds>(timeToLive) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetRegionIdleTimeout( ExpirationAction action, TimeSpan idleTimeout )
        {
          try
          {
            m_nativeptr->get()->setRegionIdleTimeout(static_cast<native::ExpirationAction>( action ), TimeUtils::TimeSpanToDurationCeil<std::chrono::seconds>(idleTimeout) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetRegionTimeToLive( ExpirationAction action, TimeSpan timeToLive )
        {
          try
          {
            m_nativeptr->get()->setRegionTimeToLive(static_cast<native::ExpirationAction>( action ), TimeUtils::TimeSpanToDurationCeil<std::chrono::seconds>(timeToLive) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        // PERSISTENCE
  
         generic <class TKey, class TValue>
        RegionFactory^ RegionFactory::SetPersistenceManager( Client::IPersistenceManager<TKey, TValue>^ persistenceManager, 
            Properties<String^, String^>^ config)
        {
          std::shared_ptr<native::PersistenceManager> persistenceManagerptr;
          if ( persistenceManager != nullptr ) {
            PersistenceManagerGeneric<TKey, TValue>^ clg = gcnew PersistenceManagerGeneric<TKey, TValue>();
            clg->SetPersistenceManager(persistenceManager);
            persistenceManagerptr = std::shared_ptr<native::ManagedPersistenceManagerGeneric>(new native::ManagedPersistenceManagerGeneric(persistenceManager));
            ((native::ManagedPersistenceManagerGeneric*)persistenceManagerptr.get())->setptr(clg);
          }
          try
          {
            m_nativeptr->get()->setPersistenceManager( persistenceManagerptr, config->GetNative() );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        generic <class TKey, class TValue>
        RegionFactory^ RegionFactory::SetPersistenceManager( Client::IPersistenceManager<TKey, TValue>^ persistenceManager )
        {
          return SetPersistenceManager(persistenceManager, nullptr);
        }
  
        RegionFactory^ RegionFactory::SetPersistenceManager( String^ libPath,
          String^ factoryFunctionName )
        {        
          SetPersistenceManager( libPath, factoryFunctionName, nullptr );
          return this;
        }
  
        RegionFactory^ RegionFactory::SetPersistenceManager( String^ libPath,
          String^ factoryFunctionName, /*Dictionary<Object^, Object^>*/Properties<String^, String^>^ config )
        {        
          try
          {
            m_nativeptr->get()->setPersistenceManager( marshal_as<std::string>(libPath),
              marshal_as<std::string>(factoryFunctionName), config->GetNative() );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetPoolName( String^ poolName )
        {
  
          try
          {
            m_nativeptr->get()->setPoolName( marshal_as<std::string>(poolName) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        // MAP ATTRIBUTES
  
        RegionFactory^ RegionFactory::SetInitialCapacity( System::Int32 initialCapacity )
        {
          _GF_MG_EXCEPTION_TRY2
  
            try
            {
              m_nativeptr->get()->setInitialCapacity( initialCapacity );
            }
            finally
            {
              GC::KeepAlive(m_nativeptr);
            }
            return this;
  
          _GF_MG_EXCEPTION_CATCH_ALL2
        }
  
        RegionFactory^ RegionFactory::SetLoadFactor( Single loadFactor )
        {
          _GF_MG_EXCEPTION_TRY2
  
            try
            {
              m_nativeptr->get()->setLoadFactor( loadFactor );
            }
            finally
            {
              GC::KeepAlive(m_nativeptr);
            }
            return this;
  
          _GF_MG_EXCEPTION_CATCH_ALL2
        }
  
        RegionFactory^ RegionFactory::SetConcurrencyLevel( System::Int32 concurrencyLevel )
        {
          _GF_MG_EXCEPTION_TRY2
  
            try
            {
              m_nativeptr->get()->setConcurrencyLevel( concurrencyLevel );
            }
            finally
            {
              GC::KeepAlive(m_nativeptr);
            }
            return this;
  
          _GF_MG_EXCEPTION_CATCH_ALL2
        }
  
        RegionFactory^ RegionFactory::SetLruEntriesLimit( System::UInt32 entriesLimit )
        {
          try
          {
            m_nativeptr->get()->setLruEntriesLimit( entriesLimit );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetDiskPolicy( DiskPolicyType diskPolicy )
        {
          try
          {
            m_nativeptr->get()->setDiskPolicy(static_cast<native::DiskPolicyType>( diskPolicy ) );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetCachingEnabled( bool cachingEnabled )
        {
          try
          {
            m_nativeptr->get()->setCachingEnabled( cachingEnabled );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetCloningEnabled( bool cloningEnabled )
        {
          try
          {
            m_nativeptr->get()->setCloningEnabled( cloningEnabled );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        RegionFactory^ RegionFactory::SetConcurrencyChecksEnabled( bool concurrencyChecksEnabled )
        {
          try
          {
            m_nativeptr->get()->setConcurrencyChecksEnabled( concurrencyChecksEnabled );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
        // NEW GENERIC APIs:
  
        generic <class TKey, class TValue>
        IRegion<TKey,TValue>^ RegionFactory::Create(String^ regionName)
        {
          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
  
            try
            {
              auto nativeptr = m_nativeptr->get()->create( marshal_as<std::string>(regionName) );
              return Client::Region<TKey,TValue>::Create( nativeptr );
            }
            finally
            {
              GC::KeepAlive(m_nativeptr);
            }
  
          _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
        }
  
        generic <class TKey, class TValue>
        RegionFactory^ RegionFactory::SetCacheLoader( Client::ICacheLoader<TKey, TValue>^ cacheLoader )
        {
          std::shared_ptr<native::CacheLoader> loaderptr;
          if ( cacheLoader != nullptr ) {
            CacheLoaderGeneric<TKey, TValue>^ clg = gcnew CacheLoaderGeneric<TKey, TValue>();
            clg->SetCacheLoader(cacheLoader);
            loaderptr = std::shared_ptr<native::ManagedCacheLoaderGeneric>(new native::ManagedCacheLoaderGeneric(cacheLoader));
            ((native::ManagedCacheLoaderGeneric*)loaderptr.get())->setptr(clg);
          }
          try
          {
            m_nativeptr->get()->setCacheLoader( loaderptr );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        generic <class TKey, class TValue>
        RegionFactory^ RegionFactory::SetCacheWriter( Client::ICacheWriter<TKey, TValue>^ cacheWriter )
        {
          std::shared_ptr<native::CacheWriter> writerptr;
          if ( cacheWriter != nullptr ) {
            CacheWriterGeneric<TKey, TValue>^ cwg = gcnew CacheWriterGeneric<TKey, TValue>();
            cwg->SetCacheWriter(cacheWriter);
            writerptr = std::shared_ptr<native::ManagedCacheWriterGeneric>(new native::ManagedCacheWriterGeneric(cacheWriter));
            ((native::ManagedCacheWriterGeneric*)writerptr.get())->setptr(cwg);
          }
          try
          {
            m_nativeptr->get()->setCacheWriter( writerptr );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        generic <class TKey, class TValue>
        RegionFactory^ RegionFactory::SetCacheListener( Client::ICacheListener<TKey, TValue>^ cacheListener )
        {
          std::shared_ptr<native::CacheListener> listenerptr;
          if ( cacheListener != nullptr ) {
            CacheListenerGeneric<TKey, TValue>^ clg = gcnew CacheListenerGeneric<TKey, TValue>();
            clg->SetCacheListener(cacheListener);
            listenerptr = std::shared_ptr<native::ManagedCacheListenerGeneric>(new native::ManagedCacheListenerGeneric(cacheListener));
            ((native::ManagedCacheListenerGeneric*)listenerptr.get())->setptr(clg);
            /*
            listenerptr = new native::ManagedCacheListenerGeneric(
              (Client::ICacheListener<Object^, Object^>^)cacheListener);
              */
          }
          try
          {
            m_nativeptr->get()->setCacheListener( listenerptr );
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
  
        generic <class TKey, class TValue>
        RegionFactory^ RegionFactory::SetPartitionResolver(Client::IPartitionResolver<TKey, TValue>^ partitionresolver)
        {
          std::shared_ptr<native::PartitionResolver> resolverptr;
          if (partitionresolver != nullptr) {
            Client::IFixedPartitionResolver<TKey, TValue>^ resolver =
              dynamic_cast<Client::IFixedPartitionResolver<TKey, TValue>^>(partitionresolver);
            if (resolver != nullptr) {
              FixedPartitionResolverGeneric<TKey, TValue>^ prg = gcnew FixedPartitionResolverGeneric<TKey, TValue>();
              prg->SetPartitionResolver(resolver);
              resolverptr = std::shared_ptr<native::ManagedFixedPartitionResolverGeneric>(new native::ManagedFixedPartitionResolverGeneric(resolver));
              ((native::ManagedFixedPartitionResolverGeneric*)resolverptr.get())->setptr(prg);
            }
            else {
              PartitionResolverGeneric<TKey, TValue>^ prg = gcnew PartitionResolverGeneric<TKey, TValue>();
              prg->SetPartitionResolver(partitionresolver);
              resolverptr = std::shared_ptr<native::ManagedPartitionResolverGeneric>(new native::ManagedPartitionResolverGeneric(partitionresolver));
              ((native::ManagedPartitionResolverGeneric*)resolverptr.get())->setptr(prg);
            }
          }
          try
          {
            m_nativeptr->get()->setPartitionResolver(resolverptr);
          }
          finally
          {
            GC::KeepAlive(m_nativeptr);
          }
          return this;
        }
      }  // namespace Client
    }  // namespace Geode
  }  // namespace Apache
  
  