http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/StatisticsFactory.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/StatisticsFactory.hpp b/clicache/src/StatisticsFactory.hpp new file mode 100644 index 0000000..efce9c5 --- /dev/null +++ b/clicache/src/StatisticsFactory.hpp @@ -0,0 +1,273 @@ +/* + * 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/statistics/StatisticsFactory.hpp> +#include <geode/statistics/StatisticsType.hpp> +#include <geode/statistics/StatisticDescriptor.hpp> +#include <geode/statistics/Statistics.hpp> +#include "end_native.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + ref class StatisticDescriptor; + ref class StatisticsType; + ref class Statistics; + + /// <summary> + /// Instances of this interface provide methods that create instances + /// of <see cref="StatisticDescriptor" /> and <see cref="StatisticsType" />. + /// Every <see cref="StatisticsFactory" /> is also a type factory. + /// </summary> + /// <para> + /// A <c>StatisticsFactory</c> can create a <see cref="StatisticDescriptor" /> + /// statistic of three numeric types: + /// <c>int</c>, <c>long</c>, and <c>double</c>. A + /// statistic (<c>StatisticDescriptor</c>) can either be a + /// <I>gauge</I> meaning that its value can increase and decrease or a + /// <I>counter</I> meaning that its value is strictly increasing. + /// Marking a statistic as a counter allows the Geode Manager Console + /// to properly display a statistics whose value "wraps around" (that + /// is, exceeds its maximum value). + /// </para> + public ref class StatisticsFactory sealed + { + protected: + StatisticsFactory(){} + StatisticsFactory(StatisticsFactory^){} + public: + /// <summary> + /// Return a pre-existing statistics factory. Typically configured through + /// creation of a distributed system. + /// </summary> + //static StatisticsFactory^ GetExistingInstance(); + + /// <summary> + /// Creates and returns an int counter <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>, and with larger values indicating better performance. + /// </summary> + virtual StatisticDescriptor^ CreateIntCounter(String^ name, String^ description, String^ units, bool largerBetter); + + /// <summary> + /// Creates and returns an int counter <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>. + /// </summary> + virtual StatisticDescriptor^ CreateIntCounter(String^ name, String^ description, String^ units); + + /// <summary> + /// Creates and returns an long counter <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>, and with larger values indicating better performance. + /// </summary> + virtual StatisticDescriptor^ CreateLongCounter(String^ name, String^ description, String^ units, bool largerBetter); + + /// <summary> + /// Creates and returns an long counter <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>. + /// </summary> + virtual StatisticDescriptor^ CreateLongCounter(String^ name, String^ description, String^ units); + + /// <summary> + /// Creates and returns an double counter <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>, and with larger values indicating better performance. + /// </summary> + + virtual StatisticDescriptor^ CreateDoubleCounter(String^ name, String^ description, String^ units, bool largerBetter); + + /// <summary> + /// Creates and returns an double counter <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>. + /// </summary> + virtual StatisticDescriptor^ CreateDoubleCounter(String^ name, String^ description, String^ units); + + /// <summary> + /// Creates and returns an int gauge <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>, and with smaller values indicating better performance. + /// </summary> + virtual StatisticDescriptor^ CreateIntGauge(String^ name, String^ description, String^ units, bool largerBetter); + + /// <summary> + /// Creates and returns an int gauge <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>. + /// </summary> + virtual StatisticDescriptor^ CreateIntGauge(String^ name, String^ description, String^ units); + + /// <summary> + /// Creates and returns an long gauge <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>, and with smaller values indicating better performance. + /// </summary> + virtual StatisticDescriptor^ CreateLongGauge(String^ name, String^ description, String^ units, bool largerBetter); + + /// <summary> + /// Creates and returns an long gauge <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>. + /// </summary> + virtual StatisticDescriptor^ CreateLongGauge(String^ name, String^ description, String^ units); + + /// <summary> + /// Creates and returns an double gauge <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>, and with smaller values indicating better performance. + /// </summary> + virtual StatisticDescriptor^ CreateDoubleGauge(String^ name, String^ description, String^ units, bool largerBetter); + + /// <summary> + /// Creates and returns an double gauge <see cref="StatisticDescriptor" /> + /// with the given <c>name</c>, <c>description</c>, + /// <c>units</c>. + /// </summary> + virtual StatisticDescriptor^ CreateDoubleGauge(String^ name, String^ description, String^ units); + + /// <summary> + /// Creates and returns a <see cref="StatisticsType" /> + /// with the given <c>name</c>, <c>description</c>,and <see cref="StatisticDescriptor" /> + /// </summary> + /// <exception cref="IllegalArgumentException"> + /// if a type with the given <c>name</c> already exists. + /// </exception> + virtual StatisticsType^ CreateType(String^ name, String^ description, + array<StatisticDescriptor^>^ stats, System::Int32 statsLength); + + /// <summary> + /// Finds and returns an already created <see cref="StatisticsType" /> + /// with the given <c>name</c>. Returns <c>null</c> if the type does not exist. + /// </summary> + virtual StatisticsType^ FindType(String^ name); + + /// <summary> + /// Creates and returns a <see cref="Statistics" /> instance of the given <see cref="StatisticsType" /> type, <c>textId</c>, and with default ids. + /// </summary> + /// <para> + /// The created instance may not be <see cref="Statistics#isAtomic" /> atomic. + /// </para> + virtual Statistics^ CreateStatistics(StatisticsType^ type); + + /// <summary> + /// Creates and returns a <see cref="Statistics" /> instance of the given <see cref="StatisticsType" /> type, <c>textId</c>, and with a default numeric id. + /// </summary> + /// <para> + /// The created instance may not be <see cref="Statistics#isAtomic" /> atomic. + /// </para> + virtual Statistics^ CreateStatistics(StatisticsType^ type, String^ textId); + + /// <summary> + /// Creates and returns a <see cref="Statistics" /> instance of the given <see cref="StatisticsType" /> type, <c>textId</c>, and <c>numericId</c>. + /// </summary> + /// <para> + /// The created instance may not be <see cref="Statistics#isAtomic" /> atomic. + /// </para> + virtual Statistics^ CreateStatistics(StatisticsType^ type, String^ textId, System::Int64 numericId); + + /// <summary> + /// Creates and returns a <see cref="Statistics" /> instance of the given <see cref="StatisticsType" /> type, <c>textId</c>, and with default ids. + /// </summary> + /// <para> + /// The created instance will be <see cref="Statistics#isAtomic" /> atomic. + /// </para> + virtual Statistics^ CreateAtomicStatistics(StatisticsType^ type); + + /// <summary> + /// Creates and returns a <see cref="Statistics" /> instance of the given <see cref="StatisticsType" /> type, <c>textId</c>, and with a default numeric id. + /// </summary> + /// <para> + /// The created instance will be <see cref="Statistics#isAtomic" /> atomic. + /// </para> + virtual Statistics^ CreateAtomicStatistics(StatisticsType^ type, String^ textId); + + /// <summary> + /// Creates and returns a <see cref="Statistics" /> instance of the given <see cref="StatisticsType" /> type, <c>textId</c>, and <c>numericId</c>. + /// </summary> + /// <para> + /// The created instance will be <see cref="Statistics#isAtomic" /> atomic. + /// </para> + virtual Statistics^ CreateAtomicStatistics(StatisticsType^ type, String^ textId, System::Int64 numericId); + + /// <summary> + /// Return the first instance that matches the type, or NULL + /// </summary> + virtual Statistics^ FindFirstStatisticsByType(StatisticsType^ type); + + /// <summary> + /// Returns a name that can be used to identify the manager + /// </summary> + virtual property String^ Name + { + virtual String^ get(); + } + + /// <summary> + /// Returns a numeric id that can be used to identify the manager + /// </summary> + virtual property System::Int64 ID + { + virtual System::Int64 get(); + } + + internal: + /// <summary> + /// Internal factory function to wrap a native object pointer inside + /// this managed class, with null pointer check. + /// </summary> + /// <param name="nativeptr">native object pointer</param> + /// <returns> + /// the managed wrapper object, or null if the native pointer is null. + /// </returns> + inline static StatisticsFactory^ Create( + apache::geode::statistics::StatisticsFactory* nativeptr) + { + return __nullptr == nativeptr ? nullptr : + gcnew StatisticsFactory( nativeptr ); + } + + private: + /// <summary> + /// Private constructor to wrap a native object pointer + /// </summary> + /// <param name="nativeptr">The native object pointer</param> + inline StatisticsFactory(apache::geode::statistics::StatisticsFactory* nativeptr) + : m_nativeptr( nativeptr ) + { + } + + apache::geode::statistics::StatisticsFactory* m_nativeptr; + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + +
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/StatisticsType.cpp ---------------------------------------------------------------------- diff --git a/clicache/src/StatisticsType.cpp b/clicache/src/StatisticsType.cpp new file mode 100644 index 0000000..117f7ee --- /dev/null +++ b/clicache/src/StatisticsType.cpp @@ -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. + */ + + + +//#include "geode_includes.hpp" +#include "StatisticsType.hpp" +#include "StatisticDescriptor.hpp" + +#include "impl/ManagedString.hpp" +#include "ExceptionTypes.hpp" +#include "impl/SafeConvert.hpp" + + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + String^ StatisticsType::Name::get() + { + return ManagedString::Get( m_nativeptr->getName() ); + } + + String^ StatisticsType::Description::get() + { + return ManagedString::Get( m_nativeptr->getDescription() ); + } + + array<StatisticDescriptor^>^ StatisticsType::Statistics::get() + { + _GF_MG_EXCEPTION_TRY2/* due to auto replace */ + + apache::geode::statistics::StatisticDescriptor ** nativedescriptors = m_nativeptr->getStatistics(); + array<StatisticDescriptor^>^ descriptors = gcnew array<StatisticDescriptor^>(m_nativeptr->getDescriptorsCount()); + for (int item = 0; item < m_nativeptr->getDescriptorsCount(); item++) + { + descriptors[item] = StatisticDescriptor::Create(nativedescriptors[item]); + } + return descriptors; + + _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */ + } + + System::Int32 StatisticsType::NameToId( String^ name ) + { + ManagedString mg_name( name ); + _GF_MG_EXCEPTION_TRY2/* due to auto replace */ + return m_nativeptr->nameToId(mg_name.CharPtr); + _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */ + } + + StatisticDescriptor^ StatisticsType::NameToDescriptor( String^ name ) + { + ManagedString mg_name( name ); + _GF_MG_EXCEPTION_TRY2/* due to auto replace */ + return StatisticDescriptor::Create(m_nativeptr->nameToDescriptor(mg_name.CharPtr)); + _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */ + } + + System::Int32 StatisticsType::DescriptorsCount::get() + { + return m_nativeptr->getDescriptorsCount(); + } // namespace Client + } // namespace Geode +} // namespace Apache + + } //namespace + http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/StatisticsType.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/StatisticsType.hpp b/clicache/src/StatisticsType.hpp new file mode 100644 index 0000000..6644b34 --- /dev/null +++ b/clicache/src/StatisticsType.hpp @@ -0,0 +1,144 @@ +/* + * 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/statistics/StatisticsType.hpp> +#include <geode/statistics/StatisticDescriptor.hpp> +#include "end_native.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + ref class StatisticDescriptor; + + /// <summary> + /// This class is used to describe a logical collection of StatisticDescriptors.These descriptions + /// are used to create an instance of <see cref="Statistics" /> class. + /// </summary> + /// <para> + /// To get an instance of this interface use an instance of + /// <see cref="StatisticsFactory" /> class. + /// </para> + public ref class StatisticsType sealed + { + public: + /// <summary> + /// Returns the name of this statistics type. + /// </summary> + virtual property String^ Name + { + virtual String^ get( ); + } + + /// <summary> + /// Returns a description of this statistics type. + /// </summary> + virtual property String^ Description + { + virtual String^ get( ); + } + + /// <summary> + /// Returns descriptions of the statistics that this statistics type + /// gathers together. + /// </summary> + virtual property array<StatisticDescriptor^>^ Statistics + { + virtual array<StatisticDescriptor^>^ get( ); + } + + /// <summary> + /// Returns the id of the statistic with the given name in this + /// statistics instance. + /// </summary> + /// <param name="name">the statistic name</param> + /// <returns>the id of the statistic with the given name</returns> + /// <exception cref="IllegalArgumentException"> + /// if no statistic named <c>name</c> exists in this + /// statistic instance. + /// </exception> + virtual System::Int32 NameToId(String^ name); + + /// <summary> + /// Returns the descriptor of the statistic with the given name in this + /// statistics instance. + /// </summary> + /// <param name="name">the statistic name</param> + /// <returns>the descriptor of the statistic with the given name</returns> + /// <exception cref="IllegalArgumentException"> + /// if no statistic named <c>name</c> exists in this + /// statistic instance. + /// </exception> + virtual StatisticDescriptor^ NameToDescriptor(String^ name); + + /// <summary> + /// Returns the total number of statistics descriptors in the type. + /// </summary> + virtual property System::Int32 DescriptorsCount + { + virtual System::Int32 get( ); + } + + internal: + /// <summary> + /// Internal factory function to wrap a native object pointer inside + /// this managed class, with null pointer check. + /// </summary> + /// <param name="nativeptr">native object pointer</param> + /// <returns> + /// the managed wrapper object, or null if the native pointer is null. + /// </returns> + inline static StatisticsType^ Create( + apache::geode::statistics::StatisticsType* nativeptr ) + { + return __nullptr == nativeptr ? nullptr : + gcnew StatisticsType( nativeptr ); + } + + apache::geode::statistics::StatisticsType* GetNative() + { + return m_nativeptr; + } + + private: + /// <summary> + /// Private constructor to wrap a native object pointer + /// </summary> + /// <param name="nativeptr">The native object pointer</param> + inline StatisticsType( apache::geode::statistics::StatisticsType* nativeptr ) + : m_nativeptr( nativeptr ) + { + } + + apache::geode::statistics::StatisticsType* m_nativeptr; + + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + + http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/Struct.cpp ---------------------------------------------------------------------- diff --git a/clicache/src/Struct.cpp b/clicache/src/Struct.cpp new file mode 100644 index 0000000..213703f --- /dev/null +++ b/clicache/src/Struct.cpp @@ -0,0 +1,117 @@ +/* + * 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 "begin_native.hpp" +#include <geode/Struct.hpp> +#include "end_native.hpp" + +#include "Struct.hpp" +#include "StructSet.hpp" +#include "ExceptionTypes.hpp" +#include "impl/SafeConvert.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + namespace native = apache::geode::client; + + Object^ Struct::default::get(size_t index) + { + try + { + return (Serializable::GetManagedValueGeneric<Object^>( + static_cast<native::Struct*>(m_nativeptr->get())->operator[](static_cast<System::Int32>(index)))); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + Object^ Struct::default::get(String^ fieldName) + { + ManagedString mg_fieldName(fieldName); + try + { + return (Serializable::GetManagedValueGeneric<Object^>( + static_cast<native::Struct*>(m_nativeptr->get())->operator[](mg_fieldName.CharPtr))); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + StructSet<Object^>^ Struct::Set::get() + { + try + { + return StructSet</*TResult*/Object^>::Create( + static_cast<native::Struct*>(m_nativeptr->get())->getStructSet()); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + + bool Struct/*<TResult>*/::HasNext() + { + try + { + return static_cast<native::Struct*>(m_nativeptr->get())->hasNext(); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + size_t Struct/*<TResult>*/::Length::get() + { + try + { + return static_cast<native::Struct*>(m_nativeptr->get())->length(); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + Object^ Struct/*<TResult>*/::Next() + { + try + { + return (Serializable::GetManagedValueGeneric<Object^>( + static_cast<native::Struct*>(m_nativeptr->get())->next())); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + } // namespace Client + } // namespace Geode +} // namespace Apache http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/Struct.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/Struct.hpp b/clicache/src/Struct.hpp new file mode 100644 index 0000000..9b43820 --- /dev/null +++ b/clicache/src/Struct.hpp @@ -0,0 +1,148 @@ +/* + * 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 "Serializable.hpp" +#include "begin_native.hpp" +#include <geode/Struct.hpp> +#include "end_native.hpp" + + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + generic<class TResult> + ref class StructSet; + + /// <summary> + /// Encapsulates a row of query struct set. + /// </summary> + /// <remarks> + /// A Struct has a StructSet as its parent. It contains the field values + /// returned after executing a Query obtained from a QueryService which in turn + /// is obtained from a Cache. + /// </remarks> + //generic<class TResult> + public ref class Struct sealed + : public Apache::Geode::Client::Serializable + { + public: + + /// <summary> + /// Get the field value for the given index number. + /// </summary> + /// <returns> + /// The value of the field or null if index is out of bounds. + /// </returns> + property /*Apache::Geode::Client::IGeodeSerializable^*//*TResult*/ Object^ GFINDEXER( size_t ) + { + /*Apache::Geode::Client::IGeodeSerializable^*/ /*TResult*/ Object^ get( size_t index ); + } + + /// <summary> + /// Get the field value for the given field name. + /// </summary> + /// <returns>The value of the field.</returns> + /// <exception cref="IllegalArgumentException"> + /// if the field name is not found. + /// </exception> + property /*Apache::Geode::Client::IGeodeSerializable^*//*TResult*/Object^ GFINDEXER( String^ ) + { + /*Apache::Geode::Client::IGeodeSerializable^*//*TResult*/Object^ get( String^ fieldName ); + } + + /// <summary> + /// Get the parent <c>StructSet</c> of this <c>Struct</c>. + /// </summary> + /// <returns> + /// A reference to the parent <c>StructSet</c> of this <c>Struct</c>. + /// </returns> + property Apache::Geode::Client::StructSet</*TResult*/Object^>^ Set + { + Apache::Geode::Client::StructSet</*TResult*/Object^>^ get( ); + } + + /// <summary> + /// Check whether another field value is available to iterate over + /// in this <c>Struct</c>. + /// </summary> + /// <returns>true if available otherwise false.</returns> + bool HasNext( ); + + /// <summary> + /// Get the number of field values available. + /// </summary> + /// <returns>the number of field values available.</returns> + property size_t Length + { + size_t get( ); + } + + /// <summary> + /// Get the next field value item available in this <c>Struct</c>. + /// </summary> + /// <returns> + /// A reference to the next item in the <c>Struct</c> + /// or null if no more available. + /// </returns> + /*Apache::Geode::Client::IGeodeSerializable^*//*TResult*/Object^ Next( ); + + + private: + + /// <summary> + /// Private constructor to wrap a native object pointer + /// </summary> + /// <param name="nativeptr">The native object pointer</param> + inline Apache::Geode::Client::Struct/*<TResult>*/( apache::geode::client::SerializablePtr nativeptr ) + : Apache::Geode::Client::Serializable( nativeptr ) { } + + inline Apache::Geode::Client::Struct/*<TResult>*/( ) + : Apache::Geode::Client::Serializable( std::shared_ptr<apache::geode::client::Serializable>(apache::geode::client::Struct::createDeserializable())) { } + + internal: + + /// <summary> + /// Factory function to register wrapper + /// </summary> + inline static Apache::Geode::Client::IGeodeSerializable^ /*Struct^*/ /*<TResult>*/ Create( ::apache::geode::client::SerializablePtr obj ) + { + return ( obj != nullptr ? + gcnew Apache::Geode::Client::Struct/*<TResult>*/( obj ) : nullptr ); + /*return ( obj != nullptr ? + gcnew Struct( obj ) : nullptr );*/ + } + + inline static Apache::Geode::Client::IGeodeSerializable^ CreateDeserializable( ) + { + return gcnew Apache::Geode::Client::Struct/*<TResult>*/( ) ; + //return gcnew Struct( ) ; + } + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + //namespace http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/StructSet.cpp ---------------------------------------------------------------------- diff --git a/clicache/src/StructSet.cpp b/clicache/src/StructSet.cpp new file mode 100644 index 0000000..ef134e8 --- /dev/null +++ b/clicache/src/StructSet.cpp @@ -0,0 +1,130 @@ +/* + * 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 "StructSet.hpp" +#include "SelectResultsIterator.hpp" +#include "ExceptionTypes.hpp" +#include "impl/SafeConvert.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + generic<class TResult> + bool StructSet<TResult>::IsModifiable::get( ) + { + try + { + return m_nativeptr->get()->isModifiable( ); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + generic<class TResult> + System::Int32 StructSet<TResult>::Size::get( ) + { + try + { + return m_nativeptr->get()->size( ); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + generic<class TResult> + TResult StructSet<TResult>::default::get( size_t index ) + { + try + { + return Serializable::GetManagedValueGeneric<TResult>((m_nativeptr->get()->operator[](static_cast<System::Int32>(index)))); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + generic<class TResult> + SelectResultsIterator<TResult>^ StructSet<TResult>::GetIterator( ) + { + try + { + return SelectResultsIterator<TResult>::Create(std::make_unique<apache::geode::client::SelectResultsIterator>(m_nativeptr->get()->getIterator())); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + + generic<class TResult> + System::Collections::Generic::IEnumerator<TResult>^ StructSet<TResult>::GetEnumerator( ) + { + return GetIterator( ); + } + + generic<class TResult> + System::Collections::IEnumerator^ StructSet<TResult>::GetIEnumerator( ) + { + return GetIterator( ); + } + + generic<class TResult> + size_t StructSet<TResult>::GetFieldIndex( String^ fieldName ) + { + ManagedString mg_fieldName( fieldName ); + + _GF_MG_EXCEPTION_TRY2/* due to auto replace */ + + try + { + return m_nativeptr->get()->getFieldIndex( mg_fieldName.CharPtr ); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + + _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */ + } + + generic<class TResult> + String^ StructSet<TResult>::GetFieldName(size_t index) + { + try + { + return ManagedString::Get(m_nativeptr->get()->getFieldName(static_cast<System::Int32> (index)).c_str()); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + } + } // namespace Client + } // namespace Geode +} // namespace Apache http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/StructSet.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/StructSet.hpp b/clicache/src/StructSet.hpp new file mode 100644 index 0000000..ae81b76 --- /dev/null +++ b/clicache/src/StructSet.hpp @@ -0,0 +1,171 @@ +/* + * 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/StructSet.hpp> +#include "end_native.hpp" + +#include "native_shared_ptr.hpp" +#include "ICqResults.hpp" + + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + namespace native = apache::geode::client; + interface class IGeodeSerializable; + + generic<class TResult> + ref class SelectResultsIterator; + + /// <summary> + /// Encapsulates a query struct set. + /// </summary> + generic<class TResult> + public ref class StructSet sealed + : public ICqResults<TResult> + { + public: + + /// <summary> + /// True if this <c>StructSet</c> is modifiable. + /// </summary> + /// <returns>returns false always at this time.</returns> + virtual property bool IsModifiable + { + virtual bool get( ); + } + + /// <summary> + /// The size of the <c>StructSet</c>. + /// </summary> + /// <returns> + /// the number of items in the <c>StructSet</c>. + /// </returns> + virtual property System::Int32 Size + { + virtual System::Int32 get( ); + } + + /// <summary> + /// Index operator to directly access an item in the <c>StructSet</c>. + /// </summary> + /// <exception cref="IllegalArgumentException"> + /// if the index is out of bounds. + /// </exception> + /// <returns>Item at the given index.</returns> + virtual property /*Apache::Geode::Client::IGeodeSerializable^*/TResult GFINDEXER( size_t ) + { + virtual /*Apache::Geode::Client::IGeodeSerializable^*/TResult get( size_t index ); + } + + /// <summary> + /// Get a <c>SelectResultsIterator</c> with which to iterate + /// over the items in the <c>StructSet</c>. + /// </summary> + /// <returns> + /// The <c>SelectResultsIterator</c> with which to iterate. + /// </returns> + virtual SelectResultsIterator<TResult>^ GetIterator( ); + + /// <summary> + /// Get the index number of the specified field name + /// in the <c>StructSet</c>. + /// </summary> + /// <param name="fieldName"> + /// the field name for which the index is required. + /// </param> + /// <returns>the index number of the specified field name.</returns> + /// <exception cref="IllegalArgumentException"> + /// if the field name is not found. + /// </exception> + size_t GetFieldIndex( String^ fieldName ); + + /// <summary> + /// Get the field name of the <c>StructSet</c> from the + /// specified index number. + /// </summary> + /// <param name="index"> + /// the index number of the field name to get. + /// </param> + /// <returns> + /// the field name from the specified index number or null if not found. + /// </returns> + String^ GetFieldName( size_t index ); + + + // Region: IEnumerable<IGeodeSerializable^> Members + + /// <summary> + /// Returns an enumerator that iterates through the <c>StructSet</c>. + /// </summary> + /// <returns> + /// A <c>System.Collections.Generic.IEnumerator</c> that + /// can be used to iterate through the <c>StructSet</c>. + /// </returns> + virtual System::Collections::Generic::IEnumerator</*Apache::Geode::Client::IGeodeSerializable^*/TResult>^ + GetEnumerator( ); + + // End Region: IEnumerable<IGeodeSerializable^> Members + + + 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 StructSet<TResult>^ Create(native::StructSetPtr nativeptr) + { + return __nullptr == nativeptr ? nullptr : + gcnew StructSet<TResult>( nativeptr ); + } + + + private: + + virtual System::Collections::IEnumerator^ GetIEnumerator( ) sealed + = System::Collections::IEnumerable::GetEnumerator; + + /// <summary> + /// Private constructor to wrap a native object pointer + /// </summary> + /// <param name="nativeptr">The native object pointer</param> + inline StructSet(native::StructSetPtr nativeptr) + { + m_nativeptr = gcnew native_shared_ptr<native::StructSet>(nativeptr); + } + + native_shared_ptr<native::StructSet>^ m_nativeptr; + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + //namespace http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/SystemProperties.cpp ---------------------------------------------------------------------- diff --git a/clicache/src/SystemProperties.cpp b/clicache/src/SystemProperties.cpp new file mode 100644 index 0000000..8683548 --- /dev/null +++ b/clicache/src/SystemProperties.cpp @@ -0,0 +1,220 @@ +/* + * 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 "SystemProperties.hpp" +#include "impl/SafeConvert.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + namespace native = apache::geode::client; + + void SystemProperties::LogSettings( ) + { + m_nativeptr->logSettings( ); + } + + System::Int32 SystemProperties::StatisticsSampleInterval::get( ) + { + return m_nativeptr->statisticsSampleInterval( ); + } + + bool SystemProperties::StatisticsEnabled::get( ) + { + return m_nativeptr->statisticsEnabled( ); + } + + String^ SystemProperties::StatisticsArchiveFile::get( ) + { + return ManagedString::Get( m_nativeptr->statisticsArchiveFile( ) ); + } + + String^ SystemProperties::LogFileName::get( ) + { + return ManagedString::Get( m_nativeptr->logFilename( ) ); + } + + LogLevel SystemProperties::GFLogLevel::get( ) + { + return static_cast<LogLevel>( m_nativeptr->logLevel( ) ); + } + + bool SystemProperties::HeapLRULimitEnabled::get( ) + { + return m_nativeptr->heapLRULimitEnabled( ); + } + + size_t SystemProperties::HeapLRULimit::get( ) + { + return m_nativeptr->heapLRULimit( ); + } + + System::Int32 SystemProperties::HeapLRUDelta::get( ) + { + return m_nativeptr->heapLRUDelta( ); + } + + System::Int32 SystemProperties::MaxSocketBufferSize::get( ) + { + return m_nativeptr->maxSocketBufferSize( ); + } + + System::Int32 SystemProperties::PingInterval::get( ) + { + return m_nativeptr->pingInterval( ); + } + + System::Int32 SystemProperties::RedundancyMonitorInterval::get( ) + { + return m_nativeptr->redundancyMonitorInterval( ); + } + + System::Int32 SystemProperties::NotifyAckInterval::get( ) + { + return m_nativeptr->notifyAckInterval( ); + } + + System::Int32 SystemProperties::NotifyDupCheckLife::get( ) + { + return m_nativeptr->notifyDupCheckLife( ); + } + + bool SystemProperties::DebugStackTraceEnabled::get( ) + { + return m_nativeptr->debugStackTraceEnabled( ); + } + + bool SystemProperties::CrashDumpEnabled::get( ) + { + return m_nativeptr->crashDumpEnabled(); + } + + bool SystemProperties::AppDomainEnabled::get( ) + { + return m_nativeptr->isAppDomainEnabled(); + } + + String^ SystemProperties::Name::get( ) + { + return ManagedString::Get( m_nativeptr->name( ) ); + } + + String^ SystemProperties::CacheXmlFile::get( ) + { + return ManagedString::Get( m_nativeptr->cacheXMLFile( ) ); + } + + System::Int32 SystemProperties::LogFileSizeLimit::get( ) + { + return m_nativeptr->logFileSizeLimit( ); + } + + System::Int32 SystemProperties::LogDiskSpaceLimit::get( ) + { + return m_nativeptr->logDiskSpaceLimit( ); + } + + System::Int32 SystemProperties::StatsFileSizeLimit::get( ) + { + return m_nativeptr->statsFileSizeLimit( ); + } + + System::Int32 SystemProperties::StatsDiskSpaceLimit::get( ) + { + return m_nativeptr->statsDiskSpaceLimit( ); + } + + System::UInt32 SystemProperties::MaxQueueSize::get( ) + { + return m_nativeptr->maxQueueSize( ); + } + + bool SystemProperties::SSLEnabled::get( ) + { + return m_nativeptr->sslEnabled(); + } + + String^ SystemProperties::SSLKeyStore::get() + { + return ManagedString::Get(m_nativeptr->sslKeyStore()); + } + + String^ SystemProperties::SSLTrustStore::get() + { + return ManagedString::Get(m_nativeptr->sslTrustStore()); + } + + // adongre + String^ SystemProperties::SSLKeystorePassword::get() + { + return ManagedString::Get(m_nativeptr->sslKeystorePassword()); + } + + + bool SystemProperties::IsSecurityOn::get( ) + { + return m_nativeptr->isSecurityOn( ); + } + + Properties<String^, String^>^ SystemProperties::GetSecurityProperties::get( ) + { + return Properties<String^, String^>::Create(m_nativeptr->getSecurityProperties()); + } + + String^ SystemProperties::DurableClientId::get( ) + { + return ManagedString::Get( m_nativeptr->durableClientId( ) ); + } + + System::UInt32 SystemProperties::DurableTimeout::get( ) + { + return m_nativeptr->durableTimeout( ); + } + + System::UInt32 SystemProperties::ConnectTimeout::get( ) + { + return m_nativeptr->connectTimeout( ); + } + + String^ SystemProperties::ConflateEvents::get( ) + { + return ManagedString::Get( m_nativeptr->conflateEvents( ) ); + } + + System::UInt32 SystemProperties::SuspendedTxTimeout::get( ) + { + return m_nativeptr->suspendedTxTimeout( ); + } + + bool SystemProperties::ReadTimeoutUnitInMillis::get( ) + { + return m_nativeptr->readTimeoutUnitInMillis( ); + } + + bool SystemProperties::OnClientDisconnectClearPdxTypeIds::get( ) + { + return m_nativeptr->onClientDisconnectClearPdxTypeIds( ); + } // namespace Client + } // namespace Geode +} // namespace Apache + +} http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/SystemProperties.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/SystemProperties.hpp b/clicache/src/SystemProperties.hpp new file mode 100644 index 0000000..507035b --- /dev/null +++ b/clicache/src/SystemProperties.hpp @@ -0,0 +1,428 @@ +/* + * 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/SystemProperties.hpp> +#include "end_native.hpp" + +#include "Log.hpp" +#include "Properties.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + namespace native = apache::geode::client; + + /// <summary> + /// A class for internal use, that encapsulates the properties that can be + /// set through <see cref="DistributedSystem.Connect" /> + /// or a geode.properties file. + /// </summary> + public ref class SystemProperties sealed + { + public: + + /// <summary> + /// Prints all settings to the process log. + /// </summary> + void LogSettings(); + + /// <summary> + /// Returns the sampling interval, that is, + /// how often the statistics thread writes to disk, in seconds. + /// </summary> + /// <returns>the statistics sampling interval</returns> + property System::Int32 StatisticsSampleInterval + { + System::Int32 get(); + } + + /// <summary> + /// True if statistics are enabled (archived). + /// </summary> + /// <returns>true if enabled</returns> + property bool StatisticsEnabled + { + bool get(); + } + + /// <summary> + /// Returns the name of the statistics archive file. + /// </summary> + /// <returns>the filename</returns> + property String^ StatisticsArchiveFile + { + String^ get(); + } + + /// <summary> + /// Returns the name of the message log file. + /// </summary> + /// <returns>the filename</returns> + property String^ LogFileName + { + String^ get(); + } + + /// <summary> + /// Returns the message logging level. + /// </summary> + /// <returns>the log level</returns> + property LogLevel GFLogLevel + { + LogLevel get(); + } + + /// <summary> + /// Returns a boolean that specifies if heapLRULimit has been enabled for the + /// process. If enabled, the HeapLRULimit specifies the maximum amount of memory + /// that values in a cache can use to store data before overflowing to disk or + /// destroying entries to ensure that the server process never runs out of + /// memory + /// </summary> + /// <returns>true if enabled</returns> + property bool HeapLRULimitEnabled + { + bool get(); + } + + /// <summary> + /// Returns the HeapLRULimit value (in bytes), the maximum memory that values + /// in a cache can use to store data before overflowing to disk or destroying + /// entries to ensure that the server process never runs out of memory due to + /// cache memory usage + /// </summary> + /// <returns>the HeapLRULimit value</returns> + property size_t HeapLRULimit + { + size_t get(); + } + + /// <summary> + /// Returns the HeapLRUDelta value (a percent value). This specifies the + /// percentage of entries the system will evict each time it detects that + /// it has exceeded the HeapLRULimit. Defaults to 10% + /// </summary> + /// <returns>the HeapLRUDelta value</returns> + property System::Int32 HeapLRUDelta + { + System::Int32 get(); + } + + /// <summary> + /// Returns the maximum socket buffer size to use + /// </summary> + /// <returns>the MaxSocketBufferSize value</returns> + property System::Int32 MaxSocketBufferSize + { + System::Int32 get(); + } + + /// <summary> + /// Returns the time between two consecutive ping to servers + /// </summary> + /// <returns>the PingInterval value</returns> + property System::Int32 PingInterval + { + System::Int32 get(); + } + + /// <summary> + /// Returns the time between two consecutive checks for redundancy for HA + /// </summary> + /// <returns>the RedundancyMonitorInterval value</returns> + property System::Int32 RedundancyMonitorInterval + { + System::Int32 get(); + } + + /// <summary> + /// Returns the periodic notify ack interval + /// </summary> + /// <returns>the NotifyAckInterval value</returns> + property System::Int32 NotifyAckInterval + { + System::Int32 get(); + } + + /// <summary> + /// Returns the expiry time of an idle event id map entry for duplicate notification checking + /// </summary> + /// <returns>the NotifyDupCheckLife value</returns> + property System::Int32 NotifyDupCheckLife + { + System::Int32 get(); + } + + /// <summary> + /// True if the stack trace is enabled. + /// </summary> + /// <returns>true if enabled</returns> + property bool DebugStackTraceEnabled + { + bool get(); + } + + /// <summary> + /// True if the crash dump generation for unhandled fatal exceptions + /// is enabled. If "log-file" property has been specified then they are + /// created in the same directory as the log file, and having the same + /// prefix as log file. By default crash dumps are created in the + /// current working directory and have the "geode_cpp" prefix. + /// + /// The actual dump file will have timestamp and process ID + /// in the full name. + /// </summary> + /// <returns>true if enabled</returns> + property bool CrashDumpEnabled + { + bool get(); + } + + /// <summary> + /// Whether client is running in multiple AppDomain or not. + /// Default value is "false". + /// </summary> + /// <returns>true if enabled</returns> + property bool AppDomainEnabled + { + bool get(); + } + + /// <summary> + /// Returns the system name. + /// </summary> + /// <returns>the name</returns> + property String^ Name + { + String^ get(); + } + + /// <summary> + /// Returns the name of the "cache.xml" file. + /// </summary> + /// <returns>the filename</returns> + property String^ CacheXmlFile + { + String^ get(); + } + + /// <summary> + /// Returns the maximum log file size, in bytes, or 0 if unlimited. + /// </summary> + /// <returns>the maximum limit</returns> + property System::Int32 LogFileSizeLimit + { + System::Int32 get(); + } + + /// <summary> + /// Returns the maximum log Disk size, in bytes, or 0 if unlimited. + /// </summary> + /// <returns>the maximum limit</returns> + property System::Int32 LogDiskSpaceLimit + { + System::Int32 get(); + } + + /// <summary> + /// Returns the maximum statistics file size, in bytes, or 0 if unlimited. + /// </summary> + /// <returns>the maximum limit</returns> + property System::Int32 StatsFileSizeLimit + { + System::Int32 get(); + } + + /// <summary> + /// Returns the maximum statistics Disk size, in bytes, or 0 if unlimited. + /// </summary> + /// <returns>the maximum limit</returns> + property System::Int32 StatsDiskSpaceLimit + { + System::Int32 get(); + } + + /// <summary> + /// Returns the max queue size for notification messages + /// </summary> + /// <returns>the max queue size</returns> + property System::UInt32 MaxQueueSize + { + System::UInt32 get(); + } + + /// <summary> + /// True if ssl connection support is enabled. + /// </summary> + /// <returns>true if enabled</returns> + property bool SSLEnabled + { + bool get(); + } + + /// <summary> + /// Returns the SSL private keystore file path. + /// </summary> + /// <returns>the SSL private keystore file path</returns> + property String^ SSLKeyStore + { + String^ get(); + } + + /// <summary> + /// Returns the SSL public certificate trust store file path. + /// </summary> + /// <returns>the SSL public certificate trust store file path</returns> + property String^ SSLTrustStore + { + String^ get(); + } + + // adongre + /// <summary> + /// Returns the client keystore password.. + /// </summary> + /// <returns>Returns the client keystore password.</returns> + property String^ SSLKeystorePassword + { + String^ get(); + } + + /// <summary> + /// True if client needs to be authenticated + /// </summary> + /// <returns>true if enabled</returns> + property bool IsSecurityOn + { + bool get(); + } + + /// <summary> + /// Returns all the security properties + /// </summary> + /// <returns>the security properties</returns> + //generic <class TPropKey, class TPropValue> + property Properties<String^, String^>^ GetSecurityProperties { + Properties<String^, String^>^ get(); + } + + /// <summary> + /// Returns the durable client's ID. + /// </summary> + /// <returns>the durable client ID</returns> + property String^ DurableClientId + { + String^ get(); + } + + /// <summary> + /// Returns the durable client's timeout. + /// </summary> + /// <returns>the durable client timeout</returns> + property System::UInt32 DurableTimeout + { + System::UInt32 get(); + } + + /// <summary> + /// Returns the connect timeout used for server and locator handshakes. + /// </summary> + /// <returns>the connect timeout used for server and locator handshakes</returns> + property System::UInt32 ConnectTimeout + { + System::UInt32 get(); + } + + /// <summary> + /// Returns the conflate event's option + /// </summary> + /// <returns>the conflate event option</returns> + property String^ ConflateEvents + { + String^ get(); + } + + /// <summary> + /// Returns the timeout after which suspended transactions are rolled back. + /// </summary> + /// <returns>the timeout for suspended transactions</returns> + property System::UInt32 SuspendedTxTimeout + { + System::UInt32 get(); + } + + /// <summary> + /// This can be called to know whether read timeout unit is in milli second. + /// </summary> + /// <returns>true if enabled or false by default.</returns> + property bool ReadTimeoutUnitInMillis + { + bool get(); + } + /// <summary> + /// True if app want to clear pdx types ids on client disconnect + /// </summary> + /// <returns>true if enabled</returns> + property bool OnClientDisconnectClearPdxTypeIds + { + bool get(); + } + + internal: + + /// <summary> + /// Internal factory function to wrap a native object pointer inside + /// this managed class, with null pointer check. + /// </summary> + /// <param name="nativeptr">native object pointer</param> + /// <returns> + /// the managed wrapper object, or null if the native pointer is null. + /// </returns> + inline static SystemProperties^ Create( + native::SystemProperties* nativeptr) + { + return (nativeptr != nullptr ? + gcnew SystemProperties(nativeptr) : nullptr); + } + + + private: + + /// <summary> + /// Private constructor to wrap a native object pointer + /// </summary> + /// <param name="nativeptr">The native object pointer</param> + inline SystemProperties(native::SystemProperties* nativeptr) + : m_nativeptr(nativeptr) + { + } + + native::SystemProperties* m_nativeptr; + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/TransactionEvent.cpp ---------------------------------------------------------------------- diff --git a/clicache/src/TransactionEvent.cpp b/clicache/src/TransactionEvent.cpp new file mode 100644 index 0000000..d4d694c --- /dev/null +++ b/clicache/src/TransactionEvent.cpp @@ -0,0 +1,79 @@ +/* + * 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. + */ +#ifdef CSTX_COMMENTED +//#include "geode_includes.hpp" +#include "TransactionEvent.hpp" +#include "Log.hpp" +#include "impl/SafeConvert.hpp" +#include "TransactionId.hpp" +#include "Cache.hpp" +#include "EntryEvent.hpp" +#include "Cache.hpp" + + +using namespace System; +using namespace Apache::Geode::Client; + + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + generic<class TKey, class TValue> + Cache^ TransactionEvent<TKey, TValue>::Cache::get( ) + { + apache::geode::client::CachePtr & nativeptr( + NativePtr->getCache( ) ); + + return Apache::Geode::Client::Cache::Create( + nativeptr.get() ); + } + + generic<class TKey, class TValue> + Apache::Geode::Client::TransactionId^ TransactionEvent<TKey, TValue>::TransactionId::get( ) + { + apache::geode::client::TransactionIdPtr & nativeptr( + NativePtr->getTransactionId( ) ); + + return Apache::Geode::Client::TransactionId::Create( + nativeptr.get() ); + } + + generic<class TKey, class TValue> + array<EntryEvent<TKey, TValue>^>^ TransactionEvent<TKey, TValue>::Events::get( ) + { + apache::geode::client::VectorOfEntryEvent vee; + vee = NativePtr->getEvents(); + array<EntryEvent<TKey, TValue>^>^ events = + gcnew array<EntryEvent<TKey, TValue>^>( vee.size( ) ); + // Loop through the unmanaged event objects to convert them to the managed generic objects. + for( System::Int32 index = 0; index < vee.size( ); index++ ) + { + apache::geode::client::EntryEventPtr& nativeptr( vee[ index ] ); + EntryEvent<TKey, TValue> entryEvent( nativeptr.get() ); + events[ index ] = (%entryEvent); + } + return events; + } // namespace Client + } // namespace Geode +} // namespace Apache + + } //namespace +#endif http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/TransactionEvent.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/TransactionEvent.hpp b/clicache/src/TransactionEvent.hpp new file mode 100644 index 0000000..80680c2 --- /dev/null +++ b/clicache/src/TransactionEvent.hpp @@ -0,0 +1,88 @@ +/* + * 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. + */ + +#ifdef CSTX_COMMENTED +#pragma once + +#include "geode_defs.hpp" +#include <cppcache/TransactionEvent.hpp> + +//#include "TransactionId.hpp" +//#include "Cache.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + ref class TransactionId; + ref class Cache; + + generic<class TKey, class TValue> + ref class EntryEvent; + + /// <summary> + /// This class encapsulates events that occur for an transaction in a cache. + /// </summary> + generic<class TKey, class TValue> + public ref class TransactionEvent sealed + : public Internal::UMWrap<apache::geode::client::TransactionEvent> + { + public: + /// <summary> + /// Gets the transaction id for this transaction. + /// </summary> + property Apache::Geode::Client::TransactionId^ TransactionId + { + Apache::Geode::Client::TransactionId^ get( ); + } + + /// <summary> + /// Returns an ordered list of every event for this transaction. + /// The event order is consistent with the order in which the operations were + /// performed during the transaction. + /// </summary> + property array<EntryEvent<TKey, TValue>^>^ Events + { + array<EntryEvent<TKey, TValue>^>^ get( ); + } + + /// <summary> + /// Gets the Cache for this transaction event + /// </summary> + property Apache::Geode::Client::Cache^ Cache + { + Apache::Geode::Client::Cache^ get( ); + } + + internal: + /// <summary> + /// Internal constructor to wrap a native object pointer + /// </summary> + /// <param name="nativeptr">The native object pointer</param> + inline TransactionEvent( apache::geode::client::TransactionEvent* nativeptr ) + : UMWrap( nativeptr, false ) { } + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + //namespace +#endif http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/TransactionId.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/TransactionId.hpp b/clicache/src/TransactionId.hpp new file mode 100644 index 0000000..29ceeb8 --- /dev/null +++ b/clicache/src/TransactionId.hpp @@ -0,0 +1,71 @@ +/* + * 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/TransactionId.hpp> +#include "end_native.hpp" + + + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + namespace native = apache::geode::client; + + /// <summary> + /// This class encapsulates Id of a transaction. + /// </summary> + public ref class TransactionId sealed + { + internal: + + inline static TransactionId^ Create(native::TransactionIdPtr nativeptr ) + { + return __nullptr == nativeptr ? nullptr : + gcnew TransactionId( nativeptr ); + } + + std::shared_ptr<native::TransactionId> GetNative() + { + return m_nativeptr->get_shared_ptr(); + } + + private: + + /// <summary> + /// Private constructor to wrap a native object pointer + /// </summary> + /// <param name="nativeptr">The native object pointer</param> + inline TransactionId( native::TransactionIdPtr nativeptr ) + { + m_nativeptr = gcnew native_shared_ptr<native::TransactionId>(nativeptr); + } + + native_shared_ptr<native::TransactionId>^ m_nativeptr; + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + //namespace http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/TransactionListenerAdapter.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/TransactionListenerAdapter.hpp b/clicache/src/TransactionListenerAdapter.hpp new file mode 100644 index 0000000..7f1f86f --- /dev/null +++ b/clicache/src/TransactionListenerAdapter.hpp @@ -0,0 +1,61 @@ +/* + * 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. + */ +#ifdef CSTX_COMMENTED +#pragma once + +#include "geode_defs.hpp" +#include "ITransactionListener.hpp" + + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + /// <summary> + /// Utility class that implements all methods in <c>ITransactionListener</c> + /// with empty implementations. Applications can subclass this class + /// and only override the methods for the events of interest. + /// </summary> + generic<class TKey, class TValue> + public ref class TransactionListenerAdapter + : public Apache::Geode::Client::ITransactionListener<TKey, TValue> + { + public: + virtual void AfterCommit(Apache::Geode::Client::TransactionEvent<TKey, TValue>^ te) + { + } + + virtual void AfterFailedCommit(Apache::Geode::Client::TransactionEvent<TKey, TValue>^ te) + { + } + + virtual void AfterRollback(Apache::Geode::Client::TransactionEvent<TKey, TValue>^ te) + { + } + + virtual void Close() + { + } + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + +#endif http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/TransactionWriterAdapte.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/TransactionWriterAdapte.hpp b/clicache/src/TransactionWriterAdapte.hpp new file mode 100644 index 0000000..04d4183 --- /dev/null +++ b/clicache/src/TransactionWriterAdapte.hpp @@ -0,0 +1,48 @@ +/* + * 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. + */ +#ifdef CSTX_COMMENTED +#pragma once + +#include "geode_defs.hpp" +#include "ITransactionWriter.hpp" + + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + /// <summary> + /// Utility class that implements all methods in <c>ITransactionWriter</c> + /// with empty implementations. + /// </summary> + generic<class TKey, class TValue> + public ref class TransactionWriterAdapter + : public Apache::Geode::Client::ITransactionWriter<TKey, TValue> + { + public: + virtual void BeforeCommit(TransactionEvent<TKey, TValue>^ te) + { + } + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + +#endif http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/UserFunctionExecutionException.cpp ---------------------------------------------------------------------- diff --git a/clicache/src/UserFunctionExecutionException.cpp b/clicache/src/UserFunctionExecutionException.cpp new file mode 100644 index 0000000..306919e --- /dev/null +++ b/clicache/src/UserFunctionExecutionException.cpp @@ -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. + */ + + +#include "UserFunctionExecutionException.hpp" +#include "CacheableString.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + // IGeodeSerializable methods + + void UserFunctionExecutionException::ToData(DataOutput^ output) + { + throw gcnew IllegalStateException("UserFunctionExecutionException::ToData is not intended for use."); + } + + IGeodeSerializable^ UserFunctionExecutionException::FromData(DataInput^ input) + { + throw gcnew IllegalStateException("UserFunctionExecutionException::FromData is not intended for use."); + return this; + } + + System::UInt32 UserFunctionExecutionException::ObjectSize::get() + { + _GF_MG_EXCEPTION_TRY2 + throw gcnew IllegalStateException("UserFunctionExecutionException::ObjectSize is not intended for use."); + try + { + return m_nativeptr->get()->objectSize(); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + + _GF_MG_EXCEPTION_CATCH_ALL2 + } + + String^ UserFunctionExecutionException::Message::get() + { + _GF_MG_EXCEPTION_TRY2 + + try + { + auto value = m_nativeptr->get()->getMessage(); + return CacheableString::GetString(value.get()); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + + _GF_MG_EXCEPTION_CATCH_ALL2 + } + + String^ UserFunctionExecutionException::Name::get() + { + _GF_MG_EXCEPTION_TRY2 + + try + { + auto value = m_nativeptr->get()->getName(); + return CacheableString::GetString(value.get()); + } + finally + { + GC::KeepAlive(m_nativeptr); + } + + _GF_MG_EXCEPTION_CATCH_ALL2 + } + } // namespace Client + } // namespace Geode +} // namespace Apache + http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/UserFunctionExecutionException.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/UserFunctionExecutionException.hpp b/clicache/src/UserFunctionExecutionException.hpp new file mode 100644 index 0000000..dd9e74d --- /dev/null +++ b/clicache/src/UserFunctionExecutionException.hpp @@ -0,0 +1,143 @@ +/* + * 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/UserFunctionExecutionException.hpp> +#include "end_native.hpp" + +#include "native_shared_ptr.hpp" +#include "IGeodeSerializable.hpp" +#include "DataInput.hpp" +#include "DataOutput.hpp" + +using namespace System; + +namespace Apache +{ + namespace Geode + { + namespace Client + { + namespace native = apache::geode::client; + + /// <summary> + /// UserFunctionExecutionException class is used to encapsulate geode sendException in case of Function execution. + /// </summary> + public ref class UserFunctionExecutionException sealed + : public IGeodeSerializable + { + public: + // IGeodeSerializable members + + /// <summary> + /// Serializes this object. + /// Users should not implement/call this api as it is only intended for internal use. + /// </summary> + /// <param name="output"> + /// the DataOutput stream to use for serialization + /// </param> + /// <exception cref="IllegalStateException"> + /// If this api is called from User code. + /// </exception> + virtual void ToData(DataOutput^ output); + + /// <summary> + /// Deserializes this object. + /// Users should not implement/call this api as it is only intended for internal use. + /// </summary> + /// <param name="input"> + /// the DataInput stream to use for reading data + /// </param> + /// <exception cref="IllegalStateException"> + /// If this api is called from User code. + /// </exception> + /// <returns>the deserialized object</returns> + virtual IGeodeSerializable^ FromData(DataInput^ input); + + /// <summary> + /// Returns the classId of this class for serialization. + /// Users should not implement/call this api as it is only intended for internal use. + /// </summary> + /// <exception cref="IllegalStateException"> + /// If this api is called from User code. + /// </exception> + /// <returns>classId of this class</returns> + /// <seealso cref="IGeodeSerializable.ClassId" /> + virtual property System::UInt32 ClassId + { + inline virtual System::UInt32 get() + { + throw gcnew IllegalStateException("UserFunctionExecutionException::ClassId is not intended for use."); + return 0; + } + } + + /// <summary> + /// return the size of this object in bytes + /// Users should not implement/call this api as it is only intended for internal use. + /// </summary> + /// <exception cref="IllegalStateException"> + /// If this api is called from User code. + /// </exception> + virtual property System::UInt32 ObjectSize + { + virtual System::UInt32 get(); + } + + // End: IGeodeSerializable members + + /// <summary> + /// return as String the Exception message returned from geode sendException api. + /// </summary> + /// <returns>the String Exception Message</returns> + property String^ Message + { + String^ get(); + } + + /// <summary> + /// return as String the Exception name returned from geode sendException api. + /// </summary> + /// <returns>the String Exception Name</returns> + property String^ Name + { + String^ get(); + } + + internal: + + /// <summary> + /// Private constructor to wrap a native object pointer. + /// </summary> + /// <param name="nativeptr">The native object pointer</param> + inline UserFunctionExecutionException(apache::geode::client::UserFunctionExecutionExceptionPtr nativeptr) + { + m_nativeptr = gcnew native_shared_ptr<native::UserFunctionExecutionException>(nativeptr); + } + + native_shared_ptr<native::UserFunctionExecutionException>^ m_nativeptr; + }; + } // namespace Client + } // namespace Geode +} // namespace Apache + + http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/Utils.cpp ---------------------------------------------------------------------- diff --git a/clicache/src/Utils.cpp b/clicache/src/Utils.cpp new file mode 100644 index 0000000..e293b52 --- /dev/null +++ b/clicache/src/Utils.cpp @@ -0,0 +1,77 @@ +/* + * 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 "gfcli/Utils.hpp" +#include "begin_native.hpp" +#include <Utils.hpp> +#include "end_native.hpp" + +namespace Apache +{ + namespace Geode + { + namespace Client + { + + MethodInfo^ Utils::LoadMethod( String^ assemblyName, + String^ typeName, String^ methodName) + { + Type^ loadType; + + loadType = Type::GetType( typeName + ',' + assemblyName, false, true ); + if (loadType != nullptr) + { + return loadType->GetMethod( methodName, BindingFlags::Public | + BindingFlags::Static | BindingFlags::IgnoreCase ); + } + return nullptr; + } + + MethodInfo^ Utils::LoadMethodFrom( String^ assemblyPath, + String^ typeName, String^ methodName) + { + String^ assemblyName; + Type^ loadType; + + assemblyName = System::IO::Path::GetFileNameWithoutExtension( + assemblyPath ); + loadType = Type::GetType( typeName + ',' + assemblyName, false, true ); + if (loadType == nullptr) + { + Assembly^ assmb = Assembly::LoadFrom( assemblyPath ); + if (assmb != nullptr) + { + loadType = assmb->GetType(typeName, false, true); + } + } + if (loadType != nullptr) + { + return loadType->GetMethod( methodName, BindingFlags::Public | + BindingFlags::Static | BindingFlags::IgnoreCase ); + } + return nullptr; + } + + System::Int32 Utils::LastError::get( ) + { + return apache::geode::client::Utils::getLastError( ); + } // namespace Client + } // namespace Geode +} // namespace Apache + +} http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/begin_native.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/begin_native.hpp b/clicache/src/begin_native.hpp new file mode 100644 index 0000000..5ee5877 --- /dev/null +++ b/clicache/src/begin_native.hpp @@ -0,0 +1,41 @@ +/* + * 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. + */ + +#if defined(__begin_native__hpp__) +#error Including begin_native.hpp mulitple times without end_native.hpp +#endif +#define __begin_native__hpp__ + +#pragma push_macro("_ALLOW_KEYWORD_MACROS") +#undef _ALLOW_KEYWORD_MACROS +#define _ALLOW_KEYWORD_MACROS + +#pragma push_macro("nullptr") +#undef nullptr +#define nullptr __nullptr + +#pragma warning(push) + +// Disable XML warnings +#pragma warning(disable: 4635) +#pragma warning(disable: 4638) +#pragma warning(disable: 4641) + +// Disable native code generation warning +#pragma warning(disable: 4793) + +#pragma managed(push, off) http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/end_native.hpp ---------------------------------------------------------------------- diff --git a/clicache/src/end_native.hpp b/clicache/src/end_native.hpp new file mode 100644 index 0000000..8a8a4ae --- /dev/null +++ b/clicache/src/end_native.hpp @@ -0,0 +1,25 @@ +/* + * 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 managed(pop) + +#pragma warning(pop) + +#pragma pop_macro("nullptr") +#pragma pop_macro("_ALLOW_KEYWORD_MACROS") + +#undef __begin_native__hpp__ \ No newline at end of file