clicache/src/CacheableString.hpp - geode-native - Git at Google

 /*
  * 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 <msclr/marshal.h>

 #include "geode_defs.hpp"
 #include "begin_native.hpp"
 #include <geode/CacheableString.hpp>
 #include "end_native.hpp"

 #include "CacheableKey.hpp"
 #include "IDataSerializablePrimitive.hpp"

 using namespace System;

 namespace Apache
 {
   namespace Geode
   {
     namespace Client
     {

       /// <summary>
       /// An immutable string wrapper that can serve as a distributable
       /// key object for caching as well as being a string value.
       /// </summary>
       ref class CacheableString
         :  public IDataSerializablePrimitive, public CacheableKey
       {
       public:
         /// <summary>
         /// Allocates a new instance copying from the given string.
         /// </summary>
         /// <param name="value">the string value of the new instance</param>
         /// <exception cref="IllegalArgumentException">
         /// if the provided string is null or has zero length
         /// </exception>
         CacheableString(String^ value);

         /// <summary>
         /// Allocates a new instance copying from the given character array.
         /// </summary>
         /// <param name="value">
         /// the character array value of the new instance
         /// </param>
         /// <exception cref="IllegalArgumentException">
         /// if the provided array is null or has zero length
         /// </exception>
         CacheableString(array<Char>^ value);

         /// <summary>
         /// Static function to create a new instance copying from
         /// the given string.
         /// </summary>
         /// <remarks>
         /// Providing a null or zero size string will return a null
         /// <c>CacheableString</c> object.
         /// </remarks>
         /// <param name="value">the string value of the new instance</param>
         inline static CacheableString^ Create(String^ value)
         {
           return (value != nullptr ?
                   gcnew CacheableString(value, true) : nullptr);
         }

         virtual void ToData(DataOutput^ output);

         virtual void FromData(DataInput^ input);

         property int8_t DsCode
         {
           virtual int8_t get()
           {
             return static_cast<int8_t>(m_type);
           }
         }

         property System::UInt64 ObjectSize
         {
           System::UInt64 get() override;
         }

         /// <summary>
         /// Static function to create a new instance copying from
         /// the given character array.
         /// </summary>
         /// <remarks>
         /// Providing a null or zero size character array will return a null
         /// <c>CacheableString</c> object.
         /// </remarks>
         /// <param name="value">
         /// the character array value of the new instance
         /// </param>
         inline static CacheableString^ Create(array<Char>^ value)
         {
           return (value != nullptr && value->Length > 0 ?
                   gcnew CacheableString(value, true) : nullptr);
         }

         /// <summary>
         /// Return a string representation of the object.
         /// This returns the same string as <c>Value</c> property.
         /// </summary>
         virtual String^ ToString() override
         {
           return m_value;
         }

         /// <summary>
         /// Return true if this key matches other object.
         /// It invokes the '==' operator of the underlying
         /// <c>apache::geode::client::CacheableString</c> object.
         /// </summary>
         virtual bool Equals(Apache::Geode::Client::ICacheableKey^ other) override;

         /// <summary>
         /// Return true if this key matches other object.
         /// It invokes the '==' operator of the underlying
         /// <c>apache::geode::client::CacheableString</c> object.
         /// </summary>
         virtual bool Equals(Object^ obj) override;

         /// <summary>
         /// Return the hashcode for this key.
         /// </summary>
         virtual System::Int32 GetHashCode() override;

         /// <summary>
         /// Gets the string value.
         /// </summary>
         property String^ Value
         {
           inline String^ get()
           {
             return m_value;
           }
         }

         /// <summary>
         /// Static function to check whether IsNullOrEmpty.
         /// </summary>
         /// <remarks>
         /// This is similar to the C# string.IsNullOrEmpty method.
         /// </remarks>
         /// <param name="value">the CacheableString value to check</param>
         inline static bool IsNullOrEmpty(CacheableString^ value)
         {
           return (value == nullptr || value->Length == 0);
         }

         /// <summary>
         /// Implicit conversion operator to underlying <c>System.String</c>.
         /// </summary>
         inline static operator String ^ (CacheableString^ str)
         {
           return (str != nullptr ? str->ToString() : nullptr);
         }

         /// <summary>
         /// Gets the length of the underlying C string.
         /// </summary>
         property System::UInt32 Length
         {
           inline System::UInt32 get()
           {
             return m_value->Length;
           }
         }

         /// <summary>
         /// True when the underlying C string is a wide-character string.
         /// </summary>
         property bool IsWideString
         {
           inline bool get()
           {
             return true;//TODO:
           }
         }

       internal:
         static ISerializable^ CreateDeserializable()
         {
           return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableASCIIString));
         }

         static ISerializable^ createDeserializableHuge()
         {
           return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableASCIIStringHuge));
         }

         static ISerializable^ createUTFDeserializable()
         {
           return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableString));
         }

         static ISerializable^ createUTFDeserializableHuge()
         {
           return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableStringHuge));
         }
         /// <summary>
         /// Factory function to register wrapper
         /// </summary>
         static ISerializable^ Create(std::shared_ptr<apache::geode::client::Serializable> obj)
         {
           if (auto str = std::dynamic_pointer_cast<apache::geode::client::CacheableString>(obj)) {
             return gcnew CacheableString(str);
           }

           return nullptr;
         }

         CacheableString(System::UInt32 type) : CacheableKey()
         {
           m_type = static_cast<DSCode>(type);
         }

       private:
         String^ m_value;
         DSCode m_type;
         int m_hashcode;

         CacheableString() : CacheableKey()
         {
           m_type = DSCode::CacheableASCIIString;
         }

         void SetStringType();
         /// <summary>
         /// Private constructor to create a CacheableString without checking
         /// for arguments.
         /// </summary>
         CacheableString(String^ value, bool noParamCheck);

         /// <summary>
         /// Private constructor to create a CacheableString without checking
         /// for arguments.
         /// </summary>
         CacheableString(array<Char>^ value, bool noParamCheck);

         /// <summary>
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
         inline CacheableString(std::shared_ptr<apache::geode::client::CacheableString> nativeptr)
           : CacheableKey(nativeptr) {

           m_value = msclr::interop::marshal_as<String^>(nativeptr->value());
           m_type = nativeptr->getDsCode();
           m_hashcode = nativeptr->hashcode();
         }
       };
     }  // namespace Client
   }  // namespace Geode
 }  // namespace Apache
	/*
	* 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 <msclr/marshal.h>

	#include "geode_defs.hpp"
	#include "begin_native.hpp"
	#include <geode/CacheableString.hpp>
	#include "end_native.hpp"

	#include "CacheableKey.hpp"
	#include "IDataSerializablePrimitive.hpp"

	using namespace System;

	namespace Apache
	{
	namespace Geode
	{
	namespace Client
	{

	/// <summary>
	/// An immutable string wrapper that can serve as a distributable
	/// key object for caching as well as being a string value.
	/// </summary>
	ref class CacheableString
	: public IDataSerializablePrimitive, public CacheableKey
	{
	public:
	/// <summary>
	/// Allocates a new instance copying from the given string.
	/// </summary>
	/// <param name="value">the string value of the new instance</param>
	/// <exception cref="IllegalArgumentException">
	/// if the provided string is null or has zero length
	/// </exception>
	CacheableString(String^ value);

	/// <summary>
	/// Allocates a new instance copying from the given character array.
	/// </summary>
	/// <param name="value">
	/// the character array value of the new instance
	/// </param>
	/// <exception cref="IllegalArgumentException">
	/// if the provided array is null or has zero length
	/// </exception>
	CacheableString(array<Char>^ value);

	/// <summary>
	/// Static function to create a new instance copying from
	/// the given string.
	/// </summary>
	/// <remarks>
	/// Providing a null or zero size string will return a null
	/// <c>CacheableString</c> object.
	/// </remarks>
	/// <param name="value">the string value of the new instance</param>
	inline static CacheableString^ Create(String^ value)
	{
	return (value != nullptr ?
	gcnew CacheableString(value, true) : nullptr);
	}

	virtual void ToData(DataOutput^ output);

	virtual void FromData(DataInput^ input);

	property int8_t DsCode
	{
	virtual int8_t get()
	{
	return static_cast<int8_t>(m_type);
	}
	}

	property System::UInt64 ObjectSize
	{
	System::UInt64 get() override;
	}

	/// <summary>
	/// Static function to create a new instance copying from
	/// the given character array.
	/// </summary>
	/// <remarks>
	/// Providing a null or zero size character array will return a null
	/// <c>CacheableString</c> object.
	/// </remarks>
	/// <param name="value">
	/// the character array value of the new instance
	/// </param>
	inline static CacheableString^ Create(array<Char>^ value)
	{
	return (value != nullptr && value->Length > 0 ?
	gcnew CacheableString(value, true) : nullptr);
	}

	/// <summary>
	/// Return a string representation of the object.
	/// This returns the same string as <c>Value</c> property.
	/// </summary>
	virtual String^ ToString() override
	{
	return m_value;
	}

	/// <summary>
	/// Return true if this key matches other object.
	/// It invokes the '==' operator of the underlying
	/// <c>apache::geode::client::CacheableString</c> object.
	/// </summary>
	virtual bool Equals(Apache::Geode::Client::ICacheableKey^ other) override;

	/// <summary>
	/// Return true if this key matches other object.
	/// It invokes the '==' operator of the underlying
	/// <c>apache::geode::client::CacheableString</c> object.
	/// </summary>
	virtual bool Equals(Object^ obj) override;

	/// <summary>
	/// Return the hashcode for this key.
	/// </summary>
	virtual System::Int32 GetHashCode() override;

	/// <summary>
	/// Gets the string value.
	/// </summary>
	property String^ Value
	{
	inline String^ get()
	{
	return m_value;
	}
	}

	/// <summary>
	/// Static function to check whether IsNullOrEmpty.
	/// </summary>
	/// <remarks>
	/// This is similar to the C# string.IsNullOrEmpty method.
	/// </remarks>
	/// <param name="value">the CacheableString value to check</param>
	inline static bool IsNullOrEmpty(CacheableString^ value)
	{
	return (value == nullptr \|\| value->Length == 0);
	}

	/// <summary>
	/// Implicit conversion operator to underlying <c>System.String</c>.
	/// </summary>
	inline static operator String ^ (CacheableString^ str)
	{
	return (str != nullptr ? str->ToString() : nullptr);
	}

	/// <summary>
	/// Gets the length of the underlying C string.
	/// </summary>
	property System::UInt32 Length
	{
	inline System::UInt32 get()
	{
	return m_value->Length;
	}
	}

	/// <summary>
	/// True when the underlying C string is a wide-character string.
	/// </summary>
	property bool IsWideString
	{
	inline bool get()
	{
	return true;//TODO:
	}
	}

	internal:
	static ISerializable^ CreateDeserializable()
	{
	return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableASCIIString));
	}

	static ISerializable^ createDeserializableHuge()
	{
	return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableASCIIStringHuge));
	}

	static ISerializable^ createUTFDeserializable()
	{
	return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableString));
	}

	static ISerializable^ createUTFDeserializableHuge()
	{
	return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableStringHuge));
	}
	/// <summary>
	/// Factory function to register wrapper
	/// </summary>
	static ISerializable^ Create(std::shared_ptr<apache::geode::client::Serializable> obj)
	{
	if (auto str = std::dynamic_pointer_cast<apache::geode::client::CacheableString>(obj)) {
	return gcnew CacheableString(str);
	}

	return nullptr;
	}

	CacheableString(System::UInt32 type) : CacheableKey()
	{
	m_type = static_cast<DSCode>(type);
	}

	private:
	String^ m_value;
	DSCode m_type;
	int m_hashcode;

	CacheableString() : CacheableKey()
	{
	m_type = DSCode::CacheableASCIIString;
	}

	void SetStringType();
	/// <summary>
	/// Private constructor to create a CacheableString without checking
	/// for arguments.
	/// </summary>
	CacheableString(String^ value, bool noParamCheck);

	/// <summary>
	/// Private constructor to create a CacheableString without checking
	/// for arguments.
	/// </summary>
	CacheableString(array<Char>^ value, bool noParamCheck);

	/// <summary>
	/// Private constructor to wrap a native object pointer
	/// </summary>
	/// <param name="nativeptr">The native object pointer</param>
	inline CacheableString(std::shared_ptr<apache::geode::client::CacheableString> nativeptr)
	: CacheableKey(nativeptr) {

	m_value = msclr::interop::marshal_as<String^>(nativeptr->value());
	m_type = nativeptr->getDsCode();
	m_hashcode = nativeptr->hashcode();
	}
	};
	} // namespace Client
	} // namespace Geode
	} // namespace Apache