| #pragma once |
| |
| #ifndef GEODE_PDXINSTANCEIMPL_H_ |
| #define GEODE_PDXINSTANCEIMPL_H_ |
| |
| |
| /* |
| * 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 <gfcpp/PdxInstance.hpp> |
| #include <gfcpp/WritablePdxInstance.hpp> |
| #include <gfcpp/PdxSerializable.hpp> |
| #include "PdxType.hpp" |
| #include "PdxLocalWriter.hpp" |
| #include <gfcpp/PdxFieldTypes.hpp> |
| #include <vector> |
| #include <map> |
| |
| namespace apache { |
| namespace geode { |
| namespace client { |
| |
| typedef std::map<std::string, CacheablePtr> FieldVsValues; |
| |
| class CPPCACHE_EXPORT PdxInstanceImpl : public WritablePdxInstance { |
| public: |
| /** |
| * @brief destructor |
| */ |
| virtual ~PdxInstanceImpl(); |
| |
| /** |
| * Deserializes and returns the domain object that this instance represents. |
| * For deserialization C++ Native Client requires the domain class to be |
| * registered. |
| * @return the deserialized domain object. |
| * |
| * @see Serializable::registerPdxType |
| */ |
| virtual PdxSerializablePtr getObject(); |
| |
| /** |
| * Checks if the named field exists and returns the result. |
| * This can be useful when writing code that handles more than one version of |
| * a PDX class. |
| * @param fieldname the name of the field to check |
| * @return <code>true</code> if the named field exists; otherwise |
| * <code>false</code> |
| */ |
| virtual bool hasField(const char* fieldname); |
| |
| /** |
| * Reads the named field and set its value in bool type out param. |
| * bool type is corresponding to java boolean type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with bool type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, bool& value) const; |
| |
| /** |
| * Reads the named field and set its value in signed char type out param. |
| * signed char type is corresponding to java byte type. |
| * For C++ on Windows and Linux, signed char type is corresponding to int8_t |
| * type. |
| * However C++ users on Solaris should always use this api after casting int8_t |
| * to signed char. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with signed char type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, signed char& value) const; |
| |
| /** |
| * Reads the named field and set its value in unsigned char type out param. |
| * unsigned char type is corresponding to java byte type. |
| * For C++ on Windows and Linux, unsigned char type is corresponding to int8_t |
| * type. |
| * However C++ users on Solaris should always use this api after casting int8_t |
| * to unsigned char. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with unsigned char type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, unsigned char& value) const; |
| |
| /** |
| * Reads the named field and set its value in int16_t type out param. |
| * int16_t type is corresponding to java short type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with int16_t type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, int16_t& value) const; |
| |
| /** |
| * Reads the named field and set its value in int32_t type out param. |
| * int32_t type is corresponding to java int type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with int32_t type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| */ |
| virtual void getField(const char* fieldname, int32_t& value) const; |
| |
| /** |
| * Reads the named field and set its value in int64_t type out param. |
| * int64_t type is corresponding to java long type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with int64_t type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, int64_t& value) const; |
| |
| /** |
| * Reads the named field and set its value in float type out param. |
| * float type is corresponding to java float type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with float type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, float& value) const; |
| |
| /** |
| * Reads the named field and set its value in double type out param. |
| * double type is corresponding to java double type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with double type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, double& value) const; |
| |
| /** |
| * Reads the named field and set its value in wchar_t type out param. |
| * wchar_t type is corresponding to java char type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with wchar_t type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldName, wchar_t& value) const; |
| |
| /** |
| * Reads the named field and set its value in char type out param. |
| * char type is corresponding to java char type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with char type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldName, char& value) const; |
| |
| /** |
| * Reads the named field and set its value in bool array type out param. |
| * bool* type is corresponding to java boolean[] type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with bool array type. |
| * @param length length is set with number of bool elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, bool** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in signed char array type out param. |
| * signed char* type is corresponding to java byte[] type. |
| * For C++ on Windows and Linux, signed char* type is corresponding to int8_t* |
| * type. |
| * However C++ users on Solaris should always use this api after casting |
| * int8_t* to signed char*. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with signed char array type. |
| * @param length length is set with number of signed char elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, signed char** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in unsigned char array type out |
| * param. |
| * unsigned char* type is corresponding to java byte[] type. |
| * For C++ on Windows and Linux, unsigned char* type is corresponding to |
| * int8_t* type. |
| * However C++ users on Solaris should always use this api after casting |
| * int8_t* to unsigned char*. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with unsigned char array type. |
| * @param length length is set with number of unsigned char elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, unsigned char** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in int16_t array type out param. |
| * int16_t* type is corresponding to java short[] type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with int16_t array type. |
| * @param length length is set with number of int16_t elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, int16_t** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in int32_t array type out param. |
| * int32_t* type is corresponding to java int[] type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with int32_t array type. |
| * @param length length is set with number of int32_t elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, int32_t** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in int64_t array type out param. |
| * int64_t* type is corresponding to java long[] type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with int64_t array type. |
| * @param length length is set with number of int64_t elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, int64_t** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in float array type out param. |
| * float* type is corresponding to java float[] type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with float array type. |
| * @param length length is set with number of float elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, float** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in double array type out param. |
| * double* type is corresponding to java double[] type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with double array type. |
| * @param length length is set with number of double elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, double** value, |
| int32_t& length) const; |
| |
| // charArray |
| /** |
| * Reads the named field and set its value in wchar_t array type out param. |
| * wchar_t* type is corresponding to java String type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with wchar_t array type. |
| * @param length length is set with number of wchar_t* elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldName, wchar_t** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in char array type out param. |
| * char* type is corresponding to java String type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with char array type. |
| * @param length length is set with number of char* elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldName, char** value, |
| int32_t& length) const; |
| |
| // String |
| /** |
| * Reads the named field and set its value in wchar_t* type out param. |
| * wchar_t* type is corresponding to java String type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with wchar_t type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, wchar_t** value) const; |
| |
| /** |
| * Reads the named field and set its value in char* type out param. |
| * char* type is corresponding to java String type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with char* type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, char** value) const; |
| |
| // StringArray |
| /** |
| * Reads the named field and set its value in wchar_t* array type out param. |
| * wchar_t** type is corresponding to java String[] type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with wchar_t* array type. |
| * @param length length is set with number of wchar_t** elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, wchar_t*** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in char* array type out param. |
| * char** type is corresponding to java String[] type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with char* array type. |
| * @param length length is set with number of char** elements. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, char*** value, |
| int32_t& length) const; |
| |
| /** |
| * Reads the named field and set its value in CacheableDatePtr type out param. |
| * CacheableDatePtr type is corresponding to java Java.util.date type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with CacheableDatePtr type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, CacheableDatePtr& value) const; |
| |
| /** |
| * Reads the named field and set its value in array of byte arrays type out |
| * param. |
| * int8_t** type is corresponding to java byte[][] type. |
| * @param fieldname name of the field to read. |
| * @param value value of the field to be set with array of byte arrays type. |
| * @param arrayLength arrayLength is set to the number of byte arrays. |
| * @param elementLength elementLength is set to individual byte array lengths. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldName, int8_t*** value, |
| int32_t& arrayLength, int32_t*& elementLength) const; |
| |
| /** |
| * Reads the named field and set its value in CacheablePtr type out param. |
| * CacheablePtr type is corresponding to java object type. |
| * @param fieldname name of the field to read |
| * @param value value of the field to be set with CacheablePtr type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * For deserialization C++ Native Client requires the domain class to be |
| * registered. |
| * |
| * @see Serializable::registerPdxType |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, CacheablePtr& value) const; |
| |
| /** |
| * Reads the named field and set its value in CacheableObjectArrayPtr type out |
| * param. |
| * For deserialization C++ Native Client requires the domain class to be |
| * registered. |
| * CacheableObjectArrayPtr type is corresponding to java Object[] type. |
| * @param fieldname name of the field to read. |
| * @param value value of the field to be set with CacheableObjectArrayPtr type. |
| * @throws IllegalStateException if PdxInstance doesn't has the named field. |
| * |
| * @see Serializable::registerPdxType |
| * @see PdxInstance#hasField |
| */ |
| virtual void getField(const char* fieldname, |
| CacheableObjectArrayPtr& value) const; |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * bool type is corresponding to java boolean type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type bool |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, bool value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * signed char type is corresponding to java byte type. |
| * For C++ on Windows and Linux, signed char type is corresponding to int8_t |
| * type. |
| * However C++ users on Solaris should always use this api after casting int8_t |
| * to signed char. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type signed char |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, signed char value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * unsigned char type is corresponding to java byte type. |
| * For C++ on Windows and Linux, unsigned char type is corresponding to int8_t |
| * type. |
| * However C++ users on Solaris should always use this api after casting int8_t |
| * to unsigned char. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type unsigned char |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, unsigned char value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * int16_t type is corresponding to java short type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type int16_t |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, int16_t value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * int32_t type is corresponding to java int type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type int32_t |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, int32_t value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * int64_t type is corresponding to java long type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type int64_t |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, int64_t value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * float type is corresponding to java float type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type float |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, float value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * double type is corresponding to java double type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type double |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, double value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * wchar_t type is corresponding to java char type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type wchar_t |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, wchar_t value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * char type is corresponding to java char type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type char |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, char value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * CacheableDatePtr type is corresponding to java Java.util.date type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type CacheableDatePtr |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, CacheableDatePtr value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * bool* type is corresponding to java boolean[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type bool array |
| * @param length |
| * The number of elements in bool array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, bool* value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * signed char* type is corresponding to java byte[] type. |
| * For C++ on Windows and Linux, signed char* type is corresponding to int8_t* |
| * type. |
| * However C++ users on Solaris should always use this api after casting |
| * int8_t* to signed char*. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type signed char array |
| * @param length |
| * The number of elements in signed char array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, signed char* value, |
| int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * unsigned char* type is corresponding to java byte[] type. |
| * For C++ on Windows and Linux, unsigned char* type is corresponding to |
| * int8_t* type. |
| * However C++ users on Solaris should always use this api after casting |
| * int8_t* to unsigned char*. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type unsigned char array |
| * @param length |
| * The number of elements in unsigned char array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, unsigned char* value, |
| int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * int16_t* type is corresponding to java short[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type int16_t array |
| * @param length |
| * The number of elements in int16_t array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, int16_t* value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * int32_t* type is corresponding to java int[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type int32_t array |
| * @param length |
| * The number of elements in int32_t array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, int32_t* value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * int64_t* type is corresponding to java long[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type int64_t array |
| * @param length |
| * The number of elements in int64_t array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, int64_t* value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * float* type is corresponding to java float[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type float array |
| * @param length |
| * The number of elements in float array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, float* value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * double* type is corresponding to java double[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type double array |
| * @param length |
| * The number of elements in double array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, double* value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * wchar_t* type is corresponding to java String type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type wchar_t* |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, const wchar_t* value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * char* type is corresponding to java String type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type char* |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, const char* value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * wchar_t* type is corresponding to java char[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type wchar_t array |
| * @param length |
| * The number of elements in wchar_t array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, wchar_t* value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * char* type is corresponding to java char[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type char array |
| * @param length |
| * The number of elements in char array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, char* value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * wchar_t** type is corresponding to java String[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type wchar_t* array |
| * @param length |
| * The number of elements in WCString array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, wchar_t** value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * char** type is corresponding to java String[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type char* array |
| * @param length |
| * The number of elements in CString array type. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, char** value, int32_t length); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * int8_t** type is corresponding to java byte[][] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type array of byte arrays |
| * @param arrayLength |
| * The number of byte arrays. |
| * @param elementLength |
| * The lengths of individual byte arrays. |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, int8_t** value, |
| int32_t arrayLength, int32_t* elementLength); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be assigned to the field of type CacheablePtr |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, CacheablePtr value); |
| |
| /** |
| * Set the existing named field to the given value. |
| * The setField method has copy-on-write semantics. |
| * So for the modifications to be stored in the cache the WritablePdxInstance |
| * must be put into a region after setField has been called one or more times. |
| * CacheableObjectArrayPtr type is corresponding to java Object[] type. |
| * @param fieldName |
| * name of the field whose value will be set |
| * @param value |
| * value that will be set to the field of type CacheableObjectArrayPtr |
| * @throws IllegalStateException if the named field does not exist |
| * or if the type of the value is not compatible with the field. |
| */ |
| virtual void setField(const char* fieldName, CacheableObjectArrayPtr value); |
| |
| /** |
| * Checks if the named field was {@link PdxWriter#markIdentityField}marked as |
| * an identity field. |
| * Note that if no fields have been marked then all the fields are used as |
| * identity fields even though |
| * this method will return <code>false</code> since none of them have been |
| * <em>marked</em>. |
| * @param fieldname the name of the field to check |
| * @return <code>true</code> if the named field exists and was marked as an |
| * identify field; otherwise <code>false</code> |
| */ |
| virtual bool isIdentityField(const char* fieldname); |
| |
| /** |
| * Creates and returns a {@link WritablePdxInstance} whose initial |
| * values are those of this PdxInstance. |
| * This call returns a copy of the current field values so modifications |
| * made to the returned value will not modify this PdxInstance. |
| * @return a {@link WritablePdxInstance} |
| */ |
| virtual WritablePdxInstancePtr createWriter(); |
| |
| /** |
| * Generates a hashcode based on the identity fields of |
| * this PdxInstance. |
| * <p>If a PdxInstance has marked identity fields using {@link |
| * PdxWriter#markIdentityField} |
| * then only the marked identity fields are its identity fields. |
| * Otherwise all its fields are identity fields. |
| * </p> |
| * For deserialization C++ Native Client requires the domain class to be |
| * registered. |
| * If the field is an array then all array |
| * elements are used for hashcode computation. |
| * Otherwise the raw bytes of its value are used to compute the hash code. |
| * @throws IllegalStateException if the field contains an element that is not |
| * of CacheableKey derived type. |
| * |
| * @see Serializable::registerPdxType |
| */ |
| virtual uint32_t hashcode() const; |
| |
| /** |
| * Prints out all of the identity fields of this PdxInstance. |
| * <p>If a PdxInstance has marked identity fields using {@link |
| * PdxWriter#markIdentityField} |
| * then only the marked identity fields are its identity fields. |
| * Otherwise all its fields are identity fields</p>. |
| * For deserialization C++ Native Client requires the domain class to be |
| * registered. |
| * |
| * @see Serializable::registerPdxType |
| */ |
| virtual CacheableStringPtr toString() const; |
| |
| /** |
| * @brief serialize this object. This is an internal method. |
| */ |
| virtual void toData(DataOutput& output) const { PdxInstance::toData(output); } |
| |
| /** |
| * @brief deserialize this object, typical implementation should return |
| * the 'this' pointer. This is an internal method. |
| */ |
| virtual Serializable* fromData(DataInput& input) { |
| return PdxInstance::fromData(input); |
| } |
| |
| /** |
| * Returns true if the given CacheableKey derived object is equals to this |
| * instance. |
| * <p>If <code>other</code> is not a PdxInstance then it is not equal to this |
| * instance. |
| * NOTE: Even if <code>other</code> is the result of calling {@link |
| * #getObject()} it will not |
| * be equal to this instance</p>. |
| * <p>Otherwise equality of two PdxInstances is determined as follows: |
| * <ol> |
| * <li>The domain class name must be equal for both PdxInstances |
| * <li>Each identity field must be equal. |
| * </ol> </p> |
| * If one of the instances does not have a field that the other one does then |
| * equals will assume it |
| * has the field with a default value. |
| * If a PdxInstance has marked identity fields using {@link |
| * PdxWriter#markIdentityField markIdentityField} |
| * then only the marked identity fields are its identity fields. |
| * Otherwise all its fields are identity fields. |
| * <p>An identity field is equal if all the following are true: |
| * <ol> |
| * <li>The field name is equal. |
| * <li>The field type is equal. |
| * <li>The field value is equal. |
| * </ol> </p> |
| * If an identity field is of type derived from <code>Cacheable</code> then it |
| * is deserialized. For deserialization C++ Native Client requires the domain |
| * class to be registered. |
| * If the deserialized object is an array then all array elements |
| * are used to determine equality. |
| * If an identity field is of type <code>CacheableObjectArray</code> then it is |
| * deserialized and all array elements are used to determine equality. |
| * For all other field types the value does not need to be deserialized. |
| * Instead the serialized raw bytes are compared and used to determine |
| * equality. |
| * @param other the other instance to compare to this. |
| * @return <code>true</code> if this instance is equal to <code>other</code>. |
| * @throws IllegalStateException if the field contains an element that is not |
| * of CacheableKey derived type. |
| * |
| * @see Serializable::registerPdxType |
| */ |
| virtual bool operator==(const CacheableKey& other) const; |
| |
| /** @return the size of the object in bytes |
| * This is an internal method. |
| * It is used in case of heap LRU property is set. |
| */ |
| virtual uint32_t objectSize() const; |
| |
| /** |
| * Return an unmodifiable list of the field names on this PdxInstance. |
| * @return an unmodifiable list of the field names on this PdxInstance |
| */ |
| virtual CacheableStringArrayPtr getFieldNames(); |
| |
| // From PdxSerializable |
| /** |
| * @brief serialize this object in geode PDX format. This is an internal |
| * method. |
| * @param PdxWriter to serialize the PDX object |
| */ |
| virtual void toData(PdxWriterPtr output) /*const*/; |
| |
| /** |
| * @brief Deserialize this object. This is an internal method. |
| * @param PdxReader to Deserialize the PDX object |
| */ |
| virtual void fromData(PdxReaderPtr input); |
| |
| /** |
| * Return the full name of the class that this pdx instance represents. |
| * @return the name of the class that this pdx instance represents. |
| * @throws IllegalStateException if the PdxInstance typeid is not defined yet, |
| * to get classname |
| * or if PdxType is not defined for PdxInstance. |
| */ |
| virtual const char* getClassName() const; |
| |
| virtual PdxFieldTypes::PdxFieldType getFieldType(const char* fieldname) const; |
| |
| void setPdxId(int32_t typeId); |
| |
| public: |
| /** |
| * @brief constructors |
| */ |
| PdxInstanceImpl(); |
| |
| PdxInstanceImpl(uint8_t* buffer, int length, int typeId) { |
| m_buffer = DataInput::getBufferCopy(buffer, length); |
| m_bufferLength = length; |
| LOGDEBUG("PdxInstanceImpl::m_bufferLength = %d ", m_bufferLength); |
| m_typeId = typeId; |
| m_pdxType = NULLPTR; |
| } |
| |
| PdxInstanceImpl(FieldVsValues fieldVsValue, PdxTypePtr pdxType); |
| |
| PdxTypePtr getPdxType() const; |
| |
| void updatePdxStream(uint8_t* newPdxStream, int len); |
| |
| private: |
| // never implemented. |
| PdxInstanceImpl(const PdxInstanceImpl& other); |
| void operator=(const PdxInstanceImpl& other); |
| |
| uint8_t* m_buffer; |
| int m_bufferLength; |
| int m_typeId; |
| PdxTypePtr m_pdxType; |
| FieldVsValues m_updatedFields; |
| |
| std::vector<PdxFieldTypePtr> getIdentityPdxFields(PdxTypePtr pt) const; |
| |
| int getOffset(DataInput& dataInput, PdxTypePtr pt, int sequenceId) const; |
| |
| int getRawHashCode(PdxTypePtr pt, PdxFieldTypePtr pField, |
| DataInput& dataInput) const; |
| |
| int getNextFieldPosition(DataInput& dataInput, int fieldId, |
| PdxTypePtr pt) const; |
| |
| int getSerializedLength(DataInput& dataInput, PdxTypePtr pt) const; |
| |
| bool hasDefaultBytes(PdxFieldTypePtr pField, DataInput& dataInput, int start, |
| int end) const; |
| |
| bool compareDefaulBytes(DataInput& dataInput, int start, int end, |
| int8_t* defaultBytes, int32_t length) const; |
| |
| void writeField(PdxWriterPtr writer, const char* fieldName, int typeId, |
| CacheablePtr value); |
| |
| void writeUnmodifieldField(DataInput& dataInput, int startPos, int endPos, |
| PdxLocalWriterPtr localWriter); |
| |
| void setOffsetForObject(DataInput& dataInput, PdxTypePtr pt, |
| int sequenceId) const; |
| |
| bool compareRawBytes(PdxInstanceImpl& other, PdxTypePtr myPT, |
| PdxFieldTypePtr myF, DataInput& myDataInput, |
| PdxTypePtr otherPT, PdxFieldTypePtr otherF, |
| DataInput& otherDataInput) const; |
| |
| void equatePdxFields(std::vector<PdxFieldTypePtr>& my, |
| std::vector<PdxFieldTypePtr>& other) const; |
| |
| static int deepArrayHashCode(CacheablePtr obj); |
| |
| static int enumerateMapHashCode(CacheableHashMapPtr map); |
| |
| static int enumerateVectorHashCode(CacheableVectorPtr vec); |
| |
| static int enumerateArrayListHashCode(CacheableArrayListPtr arrList); |
| |
| static int enumerateLinkedListHashCode(CacheableLinkedListPtr linkedList); |
| |
| static int enumerateObjectArrayHashCode(CacheableObjectArrayPtr objArray); |
| |
| static int enumerateSetHashCode(CacheableHashSetPtr set); |
| |
| static int enumerateLinkedSetHashCode(CacheableLinkedHashSetPtr linkedset); |
| |
| static int enumerateHashTableCode(CacheableHashTablePtr hashTable); |
| |
| static bool deepArrayEquals(CacheablePtr obj, CacheablePtr otherObj); |
| |
| static bool enumerateObjectArrayEquals(CacheableObjectArrayPtr Obj, |
| CacheableObjectArrayPtr OtherObj); |
| |
| static bool enumerateVectorEquals(CacheableVectorPtr Obj, |
| CacheableVectorPtr OtherObj); |
| |
| static bool enumerateArrayListEquals(CacheableArrayListPtr Obj, |
| CacheableArrayListPtr OtherObj); |
| |
| static bool enumerateMapEquals(CacheableHashMapPtr Obj, |
| CacheableHashMapPtr OtherObj); |
| |
| static bool enumerateSetEquals(CacheableHashSetPtr Obj, |
| CacheableHashSetPtr OtherObj); |
| |
| static bool enumerateLinkedSetEquals(CacheableLinkedHashSetPtr Obj, |
| CacheableLinkedHashSetPtr OtherObj); |
| |
| static bool enumerateHashTableEquals(CacheableHashTablePtr Obj, |
| CacheableHashTablePtr OtherObj); |
| |
| static int8_t m_BooleanDefaultBytes[]; |
| static int8_t m_ByteDefaultBytes[]; |
| static int8_t m_CharDefaultBytes[]; |
| static int8_t m_ShortDefaultBytes[]; |
| static int8_t m_IntDefaultBytes[]; |
| static int8_t m_LongDefaultBytes[]; |
| static int8_t m_FloatDefaultBytes[]; |
| static int8_t m_DoubleDefaultBytes[]; |
| static int8_t m_DateDefaultBytes[]; |
| static int8_t m_StringDefaultBytes[]; |
| static int8_t m_ObjectDefaultBytes[]; |
| static int8_t m_NULLARRAYDefaultBytes[]; |
| static PdxFieldTypePtr m_DefaultPdxFieldType; |
| }; |
| typedef SharedPtr<PdxInstanceImpl> PdxInstanceImplPtr; |
| } // namespace client |
| } // namespace geode |
| } // namespace apache |
| |
| |
| #endif // GEODE_PDXINSTANCEIMPL_H_ |