You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by jb...@apache.org on 2017/02/21 17:40:27 UTC
[14/31] geode-native git commit: GEODE-2476: Replace gfcpp with geode.
http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd58b100/src/cppcache/include/gfcpp/Log.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Log.hpp b/src/cppcache/include/gfcpp/Log.hpp
deleted file mode 100644
index 4644451..0000000
--- a/src/cppcache/include/gfcpp/Log.hpp
+++ /dev/null
@@ -1,674 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GFCPP_LOG_H_
-#define GEODE_GFCPP_LOG_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.
- */
-
-/**
- * The interface of the Log class
- *
- *
- */
-
-#include "gfcpp_globals.hpp"
-#include <stdio.h>
-#include <stdarg.h>
-
-/******************************************************************************/
-
-#ifndef GEODE_HIGHEST_LOG_LEVEL
-#define GEODE_HIGHEST_LOG_LEVEL All
-#endif
-
-#ifndef GEODE_MAX_LOG_FILE_LIMIT
-#define GEODE_MAX_LOG_FILE_LIMIT (1024 * 1024 * 1024)
-#endif
-
-#ifndef GEODE_MAX_LOG_DISK_LIMIT
-#define GEODE_MAX_LOG_DISK_LIMIT (1024ll * 1024ll * 1024ll * 1024ll)
-#endif
-
-#define _GF_MSG_LIMIT 8192
-
-/******************************************************************************/
-
-/** @file
-*/
-
-namespace apache {
-namespace geode {
-namespace client {
-
-class Exception;
-
-/******************************************************************************/
-/******************************************************************************/
-
-/* Logs the message if the given level is less than or equal to the current
- * logging level. */
-#define GF_LOG(level, expr) \
- if (level > apache::geode::client::Log::logLevel()) { \
- } else \
- apache::geode::client::Log::log(level, expr)
-
-/** Defines methods available to clients that want to write a log message
- * to their Geode system's shared log file.
- * <p>
- * This class must be initialized prior to its use:
- * @ref Log::init
- * <p>
- * For any logged message the log file will contain:
- * <ul>
- * <li> The message's level.
- * <li> The time the message was logged.
- * <li> The id of the connection and thread that logged the message.
- * <li> The message itself which can be a const char* (perhaps with
- * an exception including the exception's stack trace.
- * </ul>
- * <p>
- * A message always has a level.
- * Logging levels are ordered. Enabling logging at a given level also
- * enables logging at higher levels. The higher the level the more
- * important and urgent the message.
- * <p>
- * The levels, in descending order of severity, are:
- * <ul>
- *
- * <li> <code>error</code> (highest severity) is a message level
- * indicating a serious failure. In general <code>error</code>
- * messages should describe events that are of considerable
- * importance and which will prevent normal program execution. They
- * should be reasonably intelligible to end users and to system
- * administrators.
- *
- * <li> <code>warning</code> is a message level indicating a
- * potential problem. In general <code>warning</code> messages
- * should describe events that will be of interest to end users or
- * system managers, or which indicate potential problems.
- *
- * <li> <code>info</code> is a message level for informational
- * messages. Typically <code>info</code> messages should be
- * reasonably significant and should make sense to end users and
- * system administrators.
- *
- * <li> <code>config</code> is a message level for static
- * configuration messages. <code>config</code> messages are intended
- * to provide a variety of static configuration information, to
- * assist in debugging problems that may be associated with
- * particular configurations.
- *
- * <li> <code>fine</code> is a message level providing tracing
- * information. In general the <code>fine</code> level should be
- * used for information that will be broadly interesting to
- * developers. This level is for the lowest volume, and most
- * important, tracing messages.
- *
- * <li> <code>finer</code> indicates a moderately detailed tracing
- * message. This is an intermediate level between <code>fine</code>
- * and <code>finest</code>.
- *
- * <li> <code>finest</code> indicates a very detailed tracing
- * message. Logging calls for entering, returning, or throwing an
- * exception are traced at the <code>finest</code> level.
- *
- * <li> <code>debug</code> (lowest severity) indicates a highly
- * detailed tracing message. In general the <code>debug</code> level
- * should be used for the most voluminous detailed tracing messages.
- * </ul>
- *
- * <p>
- * For each level methods exist that will request a message, at that
- * level, to be logged. These methods are all named after their level.
- * <p>
- * For each level a method exists that indicates if messages at that
- * level will currently be logged. The names of these methods are of
- * the form: <em>level</em><code>Enabled</code>.
- *
- *
- */
-
-class CPPCACHE_EXPORT Log {
- public:
- /******/
-
- enum LogLevel {
-
- // NOTE: if you change this enum declaration at all, be sure to
- // change levelToChars and charsToLevel functions!
-
- None,
-
- Error,
- Warning,
- Info,
-
- Default,
-
- Config,
-
- Fine,
- Finer,
- Finest,
-
- Debug,
-
- All
-
- };
-
- /******/
-
- /**
- * Returns the current log level.
- */
- static LogLevel logLevel() { return s_logLevel; }
-
- /**
- * Set the current log level.
- */
- static void setLogLevel(LogLevel level) { s_logLevel = level; }
-
- /**
- * @return the name of the current log file.
- * NOTE: This function is for debugging only, as it is not completely
- * thread-safe!
- */
- static const char* logFileName();
-
- /**
- * Initializes logging facility with given level and filenames.
- * This method is called automatically within @ref DistributedSystem::connect
- * with the log-file, log-level, and log-file-size system properties used as
- * arguments
- */
- static void init
- // 0 => use maximum value (currently 1G)
- (LogLevel level, const char* logFileName, int32 logFileLimit = 0,
- int64 logDiskSpaceLimit = 0);
-
- /**
- * closes logging facility (until next init).
- */
- static void close();
-
- /**
- * returns character string for given log level. The string will be
- * identical to the enum declaration above, except it will be all
- * lower case. Out of range values will throw
- * IllegalArgumentException.
- */
- static const char* levelToChars(Log::LogLevel level);
-
- /**
- * returns log level specified by "chars", or throws
- * IllegalArgumentException. Allowed values are identical to the
- * enum declaration above for LogLevel, but with character case ignored.
- */
- static LogLevel charsToLevel(const char* chars);
-
- /**
- * Fills the provided buffer with formatted log-line given the level
- * and returns the buffer. This assumes that the buffer has large
- * enough space left to hold the formatted log-line (around 70 chars).
- *
- * This is provided so that applications wishing to use the same format
- * as Geode log-lines can do so easily. A log-line starts with the prefix
- * given below which is filled in by this method:
- * [<level> <date> <time> <timezone> <host>:<process ID> <thread ID>]
- *
- * This method is not thread-safe for the first invocation.
- * When invoking from outside either <init> should have been invoked,
- * or at least the first invocation should be single-threaded.
- */
- static char* formatLogLine(char* buf, LogLevel level);
-
- /******/
-
- /**
- * Returns whether log messages at given level are enabled.
- */
- static bool enabled(LogLevel level) {
- return (((s_doingDebug && level == Debug) ||
- GEODE_HIGHEST_LOG_LEVEL >= level) &&
- s_logLevel >= level);
- }
-
- /**
- * Logs a message at given level.
- */
- static void log(LogLevel level, const char* msg) {
- if (enabled(level)) put(level, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- */
- static void logThrow(LogLevel level, const char* msg, const Exception& ex) {
- if (enabled(level)) putThrow(level, msg, ex);
- }
-
- /**
- * Logs both a message and caught exception.
- */
- static void logCatch(LogLevel level, const char* msg, const Exception& ex) {
- if (enabled(level)) putCatch(level, msg, ex);
- }
-
- /******/
-
- /**
- * Returns whether "error" log messages are enabled.
- */
- static bool errorEnabled() {
- return GEODE_HIGHEST_LOG_LEVEL >= Error && s_logLevel >= Error;
- }
-
- /**
- * Logs a message.
- * The message level is "error".
- */
- static void error(const char* msg) {
- if (errorEnabled()) put(Error, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- * The message level is "error".
- */
- static void errorThrow(const char* msg, const Exception& ex) {
- if (errorEnabled()) putThrow(Error, msg, ex);
- }
-
- /**
- * Writes both a message and caught exception.
- * The message level is "error".
- */
- static void errorCatch(const char* msg, const Exception& ex) {
- if (errorEnabled()) putCatch(Error, msg, ex);
- }
-
- /******/
-
- /**
- * Returns whether "warning" log messages are enabled.
- */
- static bool warningEnabled() {
- return GEODE_HIGHEST_LOG_LEVEL >= Warning && s_logLevel >= Warning;
- }
-
- /**
- * Logs a message.
- * The message level is "warning".
- */
- static void warning(const char* msg) {
- if (warningEnabled()) put(Warning, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- * The message level is "warning".
- */
- static void warningThrow(const char* msg, const Exception& ex) {
- if (warningEnabled()) putThrow(Warning, msg, ex);
- }
-
- /**
- * Writes both a message and caught exception.
- * The message level is "warning".
- */
- static void warningCatch(const char* msg, const Exception& ex) {
- if (warningEnabled()) putCatch(Warning, msg, ex);
- }
-
- /******/
-
- /**
- * Returns whether "info" log messages are enabled.
- */
- static bool infoEnabled() {
- return GEODE_HIGHEST_LOG_LEVEL >= Info && s_logLevel >= Info;
- }
-
- /**
- * Logs a message.
- * The message level is "info".
- */
- static void info(const char* msg) {
- if (infoEnabled()) put(Info, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- * The message level is "info".
- */
- static void infoThrow(const char* msg, const Exception& ex) {
- if (infoEnabled()) putThrow(Info, msg, ex);
- }
-
- /**
- * Writes both a message and caught exception.
- * The message level is "info".
- */
- static void infoCatch(const char* msg, const Exception& ex) {
- if (infoEnabled()) putCatch(Info, msg, ex);
- }
-
- /******/
-
- /**
- * Returns whether "config" log messages are enabled.
- */
- static bool configEnabled() {
- return GEODE_HIGHEST_LOG_LEVEL >= Config && s_logLevel >= Config;
- }
-
- /**
- * Logs a message.
- * The message level is "config".
- */
- static void config(const char* msg) {
- if (configEnabled()) put(Config, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- * The message level is "config".
- */
- static void configThrow(const char* msg, const Exception& ex) {
- if (configEnabled()) putThrow(Config, msg, ex);
- }
-
- /**
- * Writes both a message and caught exception.
- * The message level is "config".
- */
- static void configCatch(const char* msg, const Exception& ex) {
- if (configEnabled()) putCatch(Config, msg, ex);
- }
-
- /******/
-
- /**
- * Returns whether "fine" log messages are enabled.
- */
- static bool fineEnabled() {
- return GEODE_HIGHEST_LOG_LEVEL >= Fine && s_logLevel >= Fine;
- }
-
- /**
- * Logs a message.
- * The message level is "fine".
- */
- static void fine(const char* msg) {
- if (fineEnabled()) put(Fine, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- * The message level is "fine".
- */
- static void fineThrow(const char* msg, const Exception& ex) {
- if (fineEnabled()) putThrow(Fine, msg, ex);
- }
-
- /**
- * Writes both a message and caught exception.
- * The message level is "fine".
- */
- static void fineCatch(const char* msg, const Exception& ex) {
- if (fineEnabled()) putCatch(Fine, msg, ex);
- }
-
- /******/
-
- /**
- * Returns whether "finer" log messages are enabled.
- */
- static bool finerEnabled() {
- return GEODE_HIGHEST_LOG_LEVEL >= Finer && s_logLevel >= Finer;
- }
-
- /**
- * Logs a message.
- * The message level is "finer".
- */
- static void finer(const char* msg) {
- if (finerEnabled()) put(Finer, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- * The message level is "finer".
- */
- static void finerThrow(const char* msg, const Exception& ex) {
- if (finerEnabled()) putThrow(Finer, msg, ex);
- }
-
- /**
- * Writes both a message and caught exception.
- * The message level is "finer".
- */
- static void finerCatch(const char* msg, const Exception& ex) {
- if (finerEnabled()) putCatch(Finer, msg, ex);
- }
-
- /******/
-
- /**
- * Returns whether "finest" log messages are enabled.
- */
- static bool finestEnabled() {
- return GEODE_HIGHEST_LOG_LEVEL >= Finest && s_logLevel >= Finest;
- }
-
- /**
- * Logs a message.
- * The message level is "finest".
- */
- static void finest(const char* msg) {
- if (finestEnabled()) put(Finest, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- * The message level is "finest".
- */
- static void finestThrow(const char* msg, const Exception& ex) {
- if (finestEnabled()) putThrow(Finest, msg, ex);
- }
-
- /**
- * Writes both a message and caught exception.
- * The message level is "finest".
- */
- static void finestCatch(const char* msg, const Exception& ex) {
- if (finestEnabled()) putCatch(Finest, msg, ex);
- }
-
- /******/
-
- /**
- * Returns whether "debug" log messages are enabled.
- */
- static bool debugEnabled() {
- return (s_doingDebug || GEODE_HIGHEST_LOG_LEVEL >= Debug) &&
- s_logLevel >= Debug;
- }
-
- /**
- * Logs a message.
- * The message level is "debug".
- */
- static void debug(const char* msg) {
- if (debugEnabled()) put(Debug, msg);
- }
-
- /**
- * Logs both a message and thrown exception.
- * The message level is "debug".
- */
- static void debugThrow(const char* msg, const Exception& ex) {
- if (debugEnabled()) putThrow(Debug, msg, ex);
- }
-
- /**
- * Writes both a message and caught exception.
- * The message level is "debug".
- */
- static void debugCatch(const char* msg, const Exception& ex) {
- if (debugEnabled()) putCatch(Debug, msg, ex);
- }
-
- /******/
-
- static void enterFn(LogLevel level, const char* functionName);
-
- static void exitFn(LogLevel level, const char* functionName);
-
- /******/
-
- private:
- static LogLevel s_logLevel;
-
-/******/
-
-#ifdef DEBUG
- enum { s_doingDebug = 1 };
-#else
- enum { s_doingDebug = 0 };
-#endif
-
- /******/
-
- static void writeBanner();
-
- /******/
- public:
- static void put(LogLevel level, const char* msg);
-
- static void putThrow(LogLevel level, const char* msg, const Exception& ex);
-
- static void putCatch(LogLevel level, const char* msg, const Exception& ex);
-};
-
-/******************************************************************************/
-/******************************************************************************/
-
-class LogFn {
- const char* m_functionName;
- Log::LogLevel m_level;
-
- public:
- LogFn(const char* functionName, Log::LogLevel level = Log::Finest)
- : m_functionName(functionName), m_level(level) {
- if (Log::enabled(m_level)) Log::enterFn(m_level, m_functionName);
- }
-
- ~LogFn() {
- if (Log::enabled(m_level)) Log::exitFn(m_level, m_functionName);
- }
-
- private:
- LogFn(const LogFn& rhs); // never defined
- void operator=(const LogFn& rhs); // never defined
-};
-
-/******************************************************************************/
-/******************************************************************************/
-
-/**
- * These functions are added to facilitate logging in printf format.
- */
-
-class CPPCACHE_EXPORT LogVarargs {
- public:
- static void debug(const char* fmt, ...);
- static void error(const char* fmt, ...);
- static void warn(const char* fmt, ...);
- static void info(const char* fmt, ...);
- static void config(const char* fmt, ...);
- static void fine(const char* fmt, ...);
- static void finer(const char* fmt, ...);
- static void finest(const char* fmt, ...);
-};
-} // namespace client
-} // namespace geode
-} // namespace apache
-
-/************************ LOGDEBUG ***********************************/
-
-#define LOGDEBUG \
- if (apache::geode::client::Log::Debug <= \
- apache::geode::client::Log::logLevel()) \
- apache::geode::client::LogVarargs::debug
-
-/************************ LOGERROR ***********************************/
-
-#define LOGERROR \
- if (apache::geode::client::Log::Error <= \
- apache::geode::client::Log::logLevel()) \
- apache::geode::client::LogVarargs::error
-
-/************************ LOGWARN ***********************************/
-
-#define LOGWARN \
- if (apache::geode::client::Log::Warning <= \
- apache::geode::client::Log::logLevel()) \
- apache::geode::client::LogVarargs::warn
-
-/************************ LOGINFO ***********************************/
-
-#define LOGINFO \
- if (apache::geode::client::Log::Info <= \
- apache::geode::client::Log::logLevel()) \
- apache::geode::client::LogVarargs::info
-
-/************************ LOGCONFIG ***********************************/
-
-#define LOGCONFIG \
- if (apache::geode::client::Log::Config <= \
- apache::geode::client::Log::logLevel()) \
- apache::geode::client::LogVarargs::config
-
-/************************ LOGFINE ***********************************/
-
-#define LOGFINE \
- if (apache::geode::client::Log::Fine <= \
- apache::geode::client::Log::logLevel()) \
- apache::geode::client::LogVarargs::fine
-
-/************************ LOGFINER ***********************************/
-
-#define LOGFINER \
- if (apache::geode::client::Log::Finer <= \
- apache::geode::client::Log::logLevel()) \
- apache::geode::client::LogVarargs::finer
-
-/************************ LOGFINEST ***********************************/
-
-#define LOGFINEST \
- if (apache::geode::client::Log::Finest <= \
- apache::geode::client::Log::logLevel()) \
- apache::geode::client::LogVarargs::finest
-
-/******************************************************************************/
-
-/******************************************************************************/
-
-#endif // GEODE_GFCPP_LOG_H_
http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd58b100/src/cppcache/include/gfcpp/PartitionResolver.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PartitionResolver.hpp b/src/cppcache/include/gfcpp/PartitionResolver.hpp
deleted file mode 100644
index 81c4e4c..0000000
--- a/src/cppcache/include/gfcpp/PartitionResolver.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GFCPP_PARTITIONRESOLVER_H_
-#define GEODE_GFCPP_PARTITIONRESOLVER_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 "SharedPtr.hpp"
-#include "Cacheable.hpp"
-#include <string>
-
-namespace apache {
-namespace geode {
-namespace client {
-
-class EntryEvent;
-
-/**
-* Implementers of interface <code>PartitionResolver</code> enable custom
-* partitioning on the <code>PartitionedRegion</code>.
-* 1. The Key class or callback arg can implement PartitionResolver interface to
-* enable custom partitioning OR
-* 2. Configure your own PartitionResolver class in partition attributes (For
-* instance when the Key is a primitive type or String) Implement the
-* appropriate equals - For all implementations, you need to be sure to code the
-* class equals method so it properly verifies equality for the
-* PartitionResolver implementation. This might mean verifying that class names
-* are the same or that the returned routing objects are the same etc.. When you
-* initiate the partitioned region on multiple nodes, Geode uses the equals
-* method to ensure you are using the same PartitionResolver implementation for
-* all of the nodes for the region.
-* Geode uses the routing object's hashCode to determine where the data is
-* being managed. Say, for example, you want to colocate all Trades by month and
-* year.The key is implemented by TradeKey class which also implements the
-* PartitionResolver interface.
-* public class TradeKey implements PartitionResolver {<br>
-*     private String tradeID;<br>
-*     private Month month ;<br>
-*     private Year year ;<br>
-*
-*     public TradingKey(){ } <br>
-*     public TradingKey(Month month, Year year){<br>
-*         this.month = month;<br>
-*         this.year = year;<br>
-*     } <br>
-*     public Serializable getRoutingObject(EntryOperation
-* opDetails){<br>
-*         return this.month + this.year;<br>
-*     }<br> }<br>
-*
-* In the example above, all trade entries with the same month and year are
-* guaranteed to be colocated.
-*/
-class CPPCACHE_EXPORT PartitionResolver : public SharedBase {
- /**
- * @brief public methods
- */
-
- public:
- /**
- * @brief destructor
- */
- virtual ~PartitionResolver();
-
- /**
- * Returns the name of the PartitionResolver
- * @return String name
- */
- virtual const char* getName();
-
- /**
- * @param opDetails the detail of the entry event
- * @throws RuntimeException - any exception thrown will terminate the operation
- * and the exception will be passed to the
- * calling thread.
- * @return object associated with entry event which allows the Partitioned
- * Region to store associated data together
- */
- virtual CacheableKeyPtr getRoutingObject(const EntryEvent& opDetails) = 0;
-
- protected:
- /**
- * @brief constructors
- */
- PartitionResolver();
-
- private:
- // never implemented.
- PartitionResolver(const PartitionResolver& other);
- void operator=(const PartitionResolver& other);
-};
-} // namespace client
-} // namespace geode
-} // namespace apache
-
-#endif // GEODE_GFCPP_PARTITIONRESOLVER_H_
http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd58b100/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp b/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp
deleted file mode 100644
index fae16d2..0000000
--- a/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp
+++ /dev/null
@@ -1,531 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GFCPP_PDXAUTOSERIALIZER_H_
-#define GEODE_GFCPP_PDXAUTOSERIALIZER_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_globals.hpp"
-#include "PdxWriter.hpp"
-#include "PdxReader.hpp"
-#include "VectorT.hpp"
-#include "HashMapT.hpp"
-#include "HashSetT.hpp"
-#include "GeodeTypeIds.hpp"
-#include "TypeHelper.hpp"
-
-namespace apache {
-namespace geode {
-namespace client {
-namespace PdxAutoSerializable {
-// Read and write methods for various types
-// uint8_t
-//------------------------------------------------------------------------------------------------
-#ifdef _SOLARIS
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int8_t value) {
- pw->writeByte(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int8_t& value) {
- value = pr->readByte(fieldName);
-}
-#else
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, char value) {
- pw->writeChar(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, char& value) {
- value = pr->readChar(fieldName);
-}
-#endif
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, wchar_t value) {
- pw->writeWideChar(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, wchar_t& value) {
- value = pr->readWideChar(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, bool value) {
- pw->writeBoolean(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, bool& value) {
- value = pr->readBoolean(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, signed char value) {
- pw->writeByte(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, signed char& value) {
- value = pr->readByte(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int16_t value) {
- pw->writeShort(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int16_t& value) {
- value = pr->readShort(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int32_t value) {
- pw->writeInt(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int32_t& value) {
- value = pr->readInt(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int64_t value) {
- pw->writeLong(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int64_t& value) {
- value = pr->readLong(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, float value) {
- pw->writeFloat(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, float& value) {
- value = pr->readFloat(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, double value) {
- pw->writeDouble(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, double& value) {
- value = pr->readDouble(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, CacheableDatePtr value) {
- pw->writeDate(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, CacheableDatePtr& value) {
- value = pr->readDate(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, const char* value) {
- pw->writeString(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, char*& value) {
- value = pr->readString(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, const wchar_t* value) {
- pw->writeWideString(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, wchar_t*& value) {
- value = pr->readWideString(fieldName);
-}
-// ---- helper methods for bytearrayofarray -------
-#ifdef _SOLARIS
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, char** value,
- int32_t arraySize, int32_t* elemArraySize) {
- pw->writeArrayOfByteArrays(fieldName, (char**)value, arraySize,
- elemArraySize);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, char**& value, int32_t& len,
- int32_t*& Lengtharr) {
- GF_NEW(Lengtharr, int32_t[len]);
- value = (char**)pr->readArrayOfByteArrays(fieldName, len, &Lengtharr);
-}
-#else
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int8_t** value,
- int32_t arraySize, int32_t* elemArraySize) {
- pw->writeArrayOfByteArrays(fieldName, value, arraySize, elemArraySize);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int8_t**& value, int32_t& len,
- int32_t*& Lengtharr) {
- GF_NEW(Lengtharr, int32_t[len]);
- value = (signed char**)pr->readArrayOfByteArrays(fieldName, len, &Lengtharr);
-}
-#endif
-
-//------------------------------------------------------------------------------------------------
-// Base Serializable types
-template <typename TObj>
-inline void writePdxObject(
- apache::geode::client::PdxWriterPtr& pw, const char* fieldName,
- const apache::geode::client::SharedPtr<TObj>& value,
- apache::geode::client::TypeHelper::yes_type isSerializable) {
- pw->writeObject(fieldName, value);
-}
-
-template <typename TObj>
-inline void writePdxObject(
- apache::geode::client::PdxWriterPtr& pw, const char* fieldName,
- const apache::geode::client::SharedPtr<TObj>& value) {
- writePdxObject(pw, fieldName, value, GF_TYPE_IS_SERIALIZABLE_TYPE(TObj));
-}
-
-template <typename TObj>
-inline void readPdxObject(
- apache::geode::client::PdxReaderPtr& pr, const char* fieldName,
- apache::geode::client::SharedPtr<TObj>& value,
- apache::geode::client::TypeHelper::yes_type isSerializable) {
- value = dynCast<apache::geode::client::SharedPtr<TObj> >(
- pr->readObject(fieldName));
-}
-
-template <typename TObj>
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName,
- apache::geode::client::SharedPtr<TObj>& value) {
- readPdxObject(pr, fieldName, value, GF_TYPE_IS_SERIALIZABLE_TYPE(TObj));
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, bool* value, int32_t len) {
- pw->writeBooleanArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, bool*& value, int32_t& len) {
- value = pr->readBooleanArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, wchar_t* value, int32_t len) {
- pw->writeWideCharArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, wchar_t*& value,
- int32_t& len) {
- value = pr->readWideCharArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-#ifdef _SOLARIS
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int8_t* value, int32_t len) {
- pw->writeByteArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int8_t*& value, int32_t& len) {
- value = (int8_t*)pr->readByteArray(fieldName, len);
-}
-#else
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, char* value, int32_t len) {
- pw->writeCharArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, char*& value, int32_t& len) {
- value = pr->readCharArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, signed char* value,
- int32_t len) {
- pw->writeByteArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, signed char*& value,
- int32_t& len) {
- value = (signed char*)pr->readByteArray(fieldName, len);
-}
-#endif
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int16_t* value, int32_t len) {
- pw->writeShortArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int16_t*& value,
- int32_t& len) {
- value = pr->readShortArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int32_t* value, int32_t len) {
- pw->writeIntArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int32_t*& value,
- int32_t& len) {
- value = pr->readIntArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, int64_t* value, int32_t len) {
- pw->writeLongArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, int64_t*& value,
- int32_t& len) {
- value = pr->readLongArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, float* value, int32_t len) {
- pw->writeFloatArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, float*& value, int32_t& len) {
- value = pr->readFloatArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, double* value, int32_t len) {
- pw->writeDoubleArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, double*& value, int32_t& len) {
- value = pr->readDoubleArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, char** value, int32_t len) {
- pw->writeStringArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, char**& value, int32_t& len) {
- value = pr->readStringArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName, wchar_t** value,
- int32_t len) {
- pw->writeWideStringArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName, wchar_t**& value,
- int32_t& len) {
- value = pr->readWideStringArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
- const char* fieldName,
- CacheableObjectArrayPtr value) {
- pw->writeObjectArray(fieldName, value);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
- const char* fieldName,
- CacheableObjectArrayPtr& value) {
- value = pr->readObjectArray(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-// For containers vector/hashmap/hashset
-// template <typename TObj>
-// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw, const
-// char*
-// fieldName,
-// const VectorT< TObj >& value )
-//{
-// int32_t len = (int32_t)value.size();
-// pw->writeArrayLen( len );
-// for ( typename VectorT< TObj >::Iterator iter = value.begin( );
-// iter != value.end( ); ++iter ) {
-// writePdxObject( output, *iter );
-// }
-//}
-
-// inline uint32_t objectSize( const _VectorOfCacheable& value )
-//{
-// uint32_t objectSize = 0;
-// for ( _VectorOfCacheable::Iterator iter = value.begin( );
-// iter != value.end( ); ++iter ) {
-// if (*iter != NULLPTR) {
-// objectSize += (*iter)->objectSize( );
-// }
-// }
-// objectSize += (sizeof(CacheablePtr) * (uint32_t)value.size());
-// return objectSize;
-//}
-
-// template <typename TObj>
-// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr, const
-// char* fieldName,
-// VectorT< TObj >& value )
-//{
-// int32_t len;
-// pr->readArrayLen( &len );
-// if ( len >= 0 ) {
-// TObj obj;
-// for ( int32_t index = 0; index < len; index++ ) {
-// readPdxObject( input, obj );
-// value.push_back( obj );
-// }
-// }
-//}
-
-// template <typename TKey, typename TValue>
-// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw, const
-// char*
-// fieldName,
-// const HashMapT< TKey, TValue >& value )
-//{
-// int32_t len = (int32_t)value.size();
-// pw->writeArrayLen( len );
-// if ( len > 0 ) {
-// for ( typename HashMapT< TKey, TValue >::Iterator iter = value.begin( );
-// iter != value.end( ); ++iter ) {
-// writePdxObject( output, iter.first( ) );
-// writePdxObject( output, iter.second( ) );
-// }
-// }
-//}
-
-// inline uint32_t objectSize( const _HashMapOfCacheable& value )
-//{
-// uint32_t objectSize = 0;
-// for ( _HashMapOfCacheable::Iterator iter = value.begin( );
-// iter != value.end( ); ++iter ) {
-// objectSize += iter.first( )->objectSize( );
-// if (iter.second( ) != NULLPTR) {
-// objectSize += iter.second( )->objectSize( );
-// }
-// }
-// objectSize += ( ( sizeof( CacheableKeyPtr ) + sizeof( CacheablePtr ) )
-// * (uint32_t)value.size());
-// return objectSize;
-//}
-
-// template <typename TKey, typename TValue>
-// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr, const
-// char* fieldName,
-// HashMapT< TKey, TValue >& value )
-//{
-// int32_t len;
-// pr->readArrayLen( &len );
-// if ( len > 0 ) {
-// TKey key;
-// TValue val;
-// for( int32_t index = 0; index < len; index++ ) {
-// readPdxObject( input, key );
-// readPdxObject( input, val );
-// value.insert( key, val );
-// }
-// }
-//}
-
-// template <typename TKey>
-// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw, const
-// char*
-// fieldName,
-// const HashSetT< TKey >& value )
-//{
-// int32_t len = (int32_t)value.size();
-// pw->writeArrayLen( len );
-// for ( typename HashSetT< TKey >::Iterator iter = value.begin( );
-// iter != value.end( ); ++iter ) {
-// writePdxObject( output, *iter );
-// }
-//}
-
-// inline uint32_t objectSize( const _HashSetOfCacheableKey& value )
-//{
-// uint32_t objectSize = 0;
-// for ( _HashSetOfCacheableKey::Iterator iter = value.begin( );
-// iter != value.end( ); ++iter ) {
-// if (*iter != NULLPTR) {
-// objectSize += (*iter)->objectSize( );
-// }
-// }
-// objectSize += (sizeof(CacheableKeyPtr) * (uint32_t)value.size());
-// return objectSize;
-//}
-
-// template <typename TKey>
-// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr, const
-// char* fieldName,
-// HashSetT< TKey >& value )
-//{
-// int32_t len;
-// pr->readArrayLen( &len );
-// if ( len > 0 ) {
-// TKey key;
-// for( int32_t index = 0; index < len; index++ ) {
-// readPdxObject( input, key );
-// value.insert( key );
-// }
-// }
-//}
-
-//// Default value for builtin types
-
-// template <typename TObj>
-// inline TObj zeroObject( )
-//{
-// return 0;
-//}
-
-// template <>
-// inline bool zeroObject<bool>( )
-//{
-// return false;
-//}
-
-// template <>
-// inline double zeroObject<double>( )
-//{
-// return 0.0;
-//}
-
-// template <>
-// inline float zeroObject<float>( )
-//{
-// return 0.0F;
-//}
-
-} // namespace PdxAutoSerializable
-} // namespace client
-} // namespace geode
-} // namespace apache
-
-
-#endif // GEODE_GFCPP_PDXAUTOSERIALIZER_H_
http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd58b100/src/cppcache/include/gfcpp/PdxFieldTypes.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxFieldTypes.hpp b/src/cppcache/include/gfcpp/PdxFieldTypes.hpp
deleted file mode 100644
index f2182fb..0000000
--- a/src/cppcache/include/gfcpp/PdxFieldTypes.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GFCPP_PDXFIELDTYPES_H_
-#define GEODE_GFCPP_PDXFIELDTYPES_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.
- */
-
-namespace apache {
-namespace geode {
-namespace client {
-
-class CPPCACHE_EXPORT PdxFieldTypes {
- public:
- enum PdxFieldType {
- BOOLEAN,
- BYTE,
- CHAR,
- SHORT,
- INT,
- LONG,
- FLOAT,
- DOUBLE,
- DATE,
- STRING,
- OBJECT,
- BOOLEAN_ARRAY,
- CHAR_ARRAY,
- BYTE_ARRAY,
- SHORT_ARRAY,
- INT_ARRAY,
- LONG_ARRAY,
- FLOAT_ARRAY,
- DOUBLE_ARRAY,
- STRING_ARRAY,
- OBJECT_ARRAY,
- ARRAY_OF_BYTE_ARRAYS
- };
-};
-} // namespace client
-} // namespace geode
-} // namespace apache
-
-#endif // GEODE_GFCPP_PDXFIELDTYPES_H_
http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd58b100/src/cppcache/include/gfcpp/PdxInstance.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxInstance.hpp b/src/cppcache/include/gfcpp/PdxInstance.hpp
deleted file mode 100644
index 60ac0d9..0000000
--- a/src/cppcache/include/gfcpp/PdxInstance.hpp
+++ /dev/null
@@ -1,618 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GFCPP_PDXINSTANCE_H_
-#define GEODE_GFCPP_PDXINSTANCE_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 "PdxSerializable.hpp"
-#include "CacheableBuiltins.hpp"
-#include "PdxFieldTypes.hpp"
-
-namespace apache {
-namespace geode {
-namespace client {
-
-/**
-* PdxInstance provides run time access to the fields of a PDX without
-* deserializing the PDX. Preventing deserialization saves time
-* and memory.
-* The PdxInstance implementation
-* is a light weight wrapper that simply refers to the raw bytes of the PDX
-* that are kept in the cache.
-* Applications can choose to access PdxInstances instead of C++ objects by
-* configuring the Cache to prefer PDX instances during deserialization.
-* This can be done in <code>cache.xml</code> by setting the attribute
-* <code>read-serialized</code>
-* to true on the <code>pdx</code> element. Or it can be done programmatically
-* using
-* {@link CacheFactory#setPdxReadSerialized(boolean) setPdxReadSerialized}
-* method. Once this preference is configured, then any time deserialization of a
-* PDX is done it will deserialize into a PdxInstance.
-* PdxInstance are immutable. If you want to change one call {@link
-* #createWriter}.
-*/
-class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
- public:
- /**
- * @brief destructor
- */
- virtual ~PdxInstance() {}
-
- /**
- * 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() = 0;
-
- /**
- * 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) = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- // 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 = 0;
-
- /**
- * 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 = 0;
-
- // 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 = 0;
-
- /**
- * 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 = 0;
-
- // 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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) = 0;
-
- /**
- * 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() = 0;
-
- /**
- * 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 = 0;
-
- /**
- * 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 = 0;
-
- /**
- * @brief serialize this object. This is an internal method.
- */
- virtual void toData(DataOutput& output) const {
- PdxSerializable::toData(output);
- }
-
- /**
- * @brief deserialize this object, typical implementation should return
- * the 'this' pointer. This is an internal method.
- */
- virtual Serializable* fromData(DataInput& input) {
- return PdxSerializable::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 = 0;
-
- /** @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 = 0;
-
- /**
- * 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() = 0;
-
- // 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) = 0;
-
- /**
- * @brief Deserialize this object. This is an internal method.
- * @param PdxReader to Deserialize the PDX object
- */
- virtual void fromData(PdxReaderPtr input) = 0;
-
- /**
- * 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 = 0;
-
- /**
-* Return the type @see PdxInstance::PdxFieldTypes of the field in the pdx
-* instance.
-* @return the type @see PdxInstance::PdxFieldTypes of the field in the pdx
-* instance.
-* @throws IllegalStateException if the PdxInstance typeid is not defined yet, to
-* get classname
-* or if PdxType is not defined for PdxInstance.
-*/
- virtual PdxFieldTypes::PdxFieldType getFieldType(
- const char* fieldname) const = 0;
-
- protected:
- /**
- * @brief constructors
- */
- PdxInstance() {}
-
- private:
- // never implemented.
- PdxInstance(const PdxInstance& other);
- void operator=(const PdxInstance& other);
-};
-} // namespace client
-} // namespace geode
-} // namespace apache
-
-#endif // GEODE_GFCPP_PDXINSTANCE_H_