http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxInstanceImpl.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxInstanceImpl.hpp b/src/cppcache/src/PdxInstanceImpl.hpp index 751d8c9..825c89a 100644 --- a/src/cppcache/src/PdxInstanceImpl.hpp +++ b/src/cppcache/src/PdxInstanceImpl.hpp @@ -38,917 +38,918 @@ typedef std::map<std::string, CacheablePtr> FieldVsValues; class CPPCACHE_EXPORT PdxInstanceImpl : public WritablePdxInstance { public: /** - * @brief destructor - */ + * @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 - */ + * 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> - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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. - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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 - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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. - */ + * 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> - */ + * 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} - */ + * 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 - */ + * 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 int32_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 - */ + * 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. - */ + * @brief serialize this object. This is an internal method. + */ virtual void toData(DataOutput& output) const { PdxInstance::toData(output); } /** @@ -960,48 +961,47 @@ class CPPCACHE_EXPORT PdxInstanceImpl : public WritablePdxInstance { } /** - * 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 - */ + * 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 @@ -1011,9 +1011,9 @@ class CPPCACHE_EXPORT PdxInstanceImpl : public WritablePdxInstance { 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 - */ + * 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 @@ -1025,18 +1025,18 @@ class CPPCACHE_EXPORT PdxInstanceImpl : public WritablePdxInstance { virtual void toData(PdxWriterPtr output) /*const*/; /** - * @brief Deserialize this object. This is an internal method. - * @param PdxReader to Deserialize the PDX object - */ + * @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. - */ + * 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; @@ -1045,8 +1045,8 @@ class CPPCACHE_EXPORT PdxInstanceImpl : public WritablePdxInstance { public: /** - * @brief constructors - */ + * @brief constructors + */ PdxInstanceImpl(); PdxInstanceImpl(uint8_t* buffer, int length, int typeId) { @@ -1164,7 +1164,7 @@ class CPPCACHE_EXPORT PdxInstanceImpl : public WritablePdxInstance { static int8_t m_NULLARRAYDefaultBytes[]; static PdxFieldTypePtr m_DefaultPdxFieldType; }; -typedef SharedPtr<PdxInstanceImpl> PdxInstanceImplPtr; +typedef std::shared_ptr<PdxInstanceImpl> PdxInstanceImplPtr; } // namespace client } // namespace geode } // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxLocalReader.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxLocalReader.hpp b/src/cppcache/src/PdxLocalReader.hpp index 8d9b86d..7f0c724 100644 --- a/src/cppcache/src/PdxLocalReader.hpp +++ b/src/cppcache/src/PdxLocalReader.hpp @@ -214,7 +214,7 @@ class PdxLocalReader : public PdxReader { virtual PdxUnreadFieldsPtr readUnreadFields(); }; -typedef SharedPtr<PdxLocalReader> PdxLocalReaderPtr; +typedef std::shared_ptr<PdxLocalReader> PdxLocalReaderPtr; } // namespace client } // namespace geode } // namespace apache http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxLocalWriter.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxLocalWriter.hpp b/src/cppcache/src/PdxLocalWriter.hpp index d05e932..230eea3 100644 --- a/src/cppcache/src/PdxLocalWriter.hpp +++ b/src/cppcache/src/PdxLocalWriter.hpp @@ -335,7 +335,7 @@ class PdxLocalWriter : public PdxWriter, inline int32_t getStartPositionOffset() { return m_startPositionOffset; } }; -typedef SharedPtr<PdxLocalWriter> PdxLocalWriterPtr; +typedef std::shared_ptr<PdxLocalWriter> PdxLocalWriterPtr; } // namespace client } // namespace geode } // namespace apache http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxReaderWithTypeCollector.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxReaderWithTypeCollector.hpp b/src/cppcache/src/PdxReaderWithTypeCollector.hpp index 834e56d..8d89434 100644 --- a/src/cppcache/src/PdxReaderWithTypeCollector.hpp +++ b/src/cppcache/src/PdxReaderWithTypeCollector.hpp @@ -174,7 +174,8 @@ class PdxReaderWithTypeCollector : public PdxLocalReader { virtual void readCollection(const char* fieldName, CacheableArrayListPtr& collection); }; -typedef SharedPtr<PdxReaderWithTypeCollector> PdxReaderWithTypeCollectorPtr; +typedef std::shared_ptr<PdxReaderWithTypeCollector> + PdxReaderWithTypeCollectorPtr; } // namespace client } // namespace geode } // namespace apache http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxRemotePreservedData.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxRemotePreservedData.hpp b/src/cppcache/src/PdxRemotePreservedData.hpp index da15c5a..07d6ac3 100644 --- a/src/cppcache/src/PdxRemotePreservedData.hpp +++ b/src/cppcache/src/PdxRemotePreservedData.hpp @@ -27,7 +27,7 @@ namespace apache { namespace geode { namespace client { class PdxRemotePreservedData; -typedef SharedPtr<PdxRemotePreservedData> PdxRemotePreservedDataPtr; +typedef std::shared_ptr<PdxRemotePreservedData> PdxRemotePreservedDataPtr; class PdxRemotePreservedData : public PdxUnreadFields { private: http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxRemoteReader.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxRemoteReader.hpp b/src/cppcache/src/PdxRemoteReader.hpp index 2856f89..b036513 100644 --- a/src/cppcache/src/PdxRemoteReader.hpp +++ b/src/cppcache/src/PdxRemoteReader.hpp @@ -209,7 +209,7 @@ class PdxRemoteReader : public PdxLocalReader { virtual void readCollection(const char* fieldName, CacheableArrayListPtr& collection); }; -typedef SharedPtr<PdxRemoteReader> PdxRemoteReaderPtr; +typedef std::shared_ptr<PdxRemoteReader> PdxRemoteReaderPtr; } // namespace client } // namespace geode } // namespace apache http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxRemoteWriter.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxRemoteWriter.hpp b/src/cppcache/src/PdxRemoteWriter.hpp index 4b6d172..809833b 100644 --- a/src/cppcache/src/PdxRemoteWriter.hpp +++ b/src/cppcache/src/PdxRemoteWriter.hpp @@ -236,7 +236,7 @@ class PdxRemoteWriter : public PdxLocalWriter { int8_t** array, int arrayLength, int* elementLength); }; -typedef SharedPtr<PdxRemoteWriter> PdxRemoteWriterPtr; +typedef std::shared_ptr<PdxRemoteWriter> PdxRemoteWriterPtr; } // namespace client } // namespace geode } // namespace apache http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxType.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxType.hpp b/src/cppcache/src/PdxType.hpp index b14e767..3a90a78 100644 --- a/src/cppcache/src/PdxType.hpp +++ b/src/cppcache/src/PdxType.hpp @@ -39,7 +39,7 @@ namespace client { typedef std::map<std::string, PdxFieldTypePtr> NameVsPdxType; class PdxType; -typedef SharedPtr<PdxType> PdxTypePtr; +typedef std::shared_ptr<PdxType> PdxTypePtr; /* adongre * Coverity - II * CID 29178: Other violation (MISSING_COPY) http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/src/PdxWriterWithTypeCollector.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PdxWriterWithTypeCollector.hpp b/src/cppcache/src/PdxWriterWithTypeCollector.hpp index a203f51..714f2cb 100644 --- a/src/cppcache/src/PdxWriterWithTypeCollector.hpp +++ b/src/cppcache/src/PdxWriterWithTypeCollector.hpp @@ -204,7 +204,7 @@ class PdxWriterWithTypeCollector : public PdxLocalWriter { *Write a string array to the PdxWriter. *@param fieldName The name of the field associated with the value. *@param value The string array value to write - */ + */ virtual PdxWriterPtr writeStringArray(const char* fieldName, char** array, int length); @@ -223,7 +223,8 @@ class PdxWriterWithTypeCollector : public PdxLocalWriter { virtual PdxWriterPtr writeUnreadFields(PdxUnreadFieldsPtr unread); }; -typedef SharedPtr<PdxWriterWithTypeCollector> PdxWriterWithTypeCollectorPtr; +typedef std::shared_ptr<PdxWriterWithTypeCollector> + PdxWriterWithTypeCollectorPtr; } // namespace client } // namespace geode } // namespace apache
