You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by vo...@apache.org on 2015/09/03 11:28:32 UTC
[04/14] ignite git commit: IGNITE-1364: WIP.
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_reader.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_reader.h b/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_reader.h
new file mode 100644
index 0000000..8cefaf2
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_reader.h
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef _GRIDGAIN_PORTABLE_READER
+#define _GRIDGAIN_PORTABLE_READER
+
+#include <stdint.h>
+#include <string>
+
+#include <ignite/common/common.h>
+
+#include "gridgain/portable/portable_raw_reader.h"
+#include "gridgain/guid.h"
+
+namespace gridgain
+{
+ namespace portable
+ {
+ /**
+ * Portable reader.
+ */
+ class IGNITE_IMPORT_EXPORT PortableReader
+ {
+ public:
+ /**
+ * Constructor.
+ *
+ * @param impl Implementation.
+ */
+ PortableReader(gridgain::impl::portable::PortableReaderImpl* impl);
+
+ /**
+ * Read 8-byte signed integer. Maps to "byte" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ int8_t ReadInt8(const char* fieldName);
+
+ /**
+ * Read array of 8-byte signed integers. Maps to "byte[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadInt8Array(const char* fieldName, int8_t* res, const int32_t len);
+
+ /**
+ * Read bool. Maps to "short" type in Java.
+ *
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ bool ReadBool(const char* fieldName);
+
+ /**
+ * Read array of bools. Maps to "bool[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadBoolArray(const char* fieldName, bool* res, const int32_t len);
+
+ /**
+ * Read 16-byte signed integer. Maps to "short" type in Java.
+ *
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ int16_t ReadInt16(const char* fieldName);
+
+ /**
+ * Read array of 16-byte signed integers. Maps to "short[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadInt16Array(const char* fieldName, int16_t* res, const int32_t len);
+
+ /**
+ * Read 16-byte unsigned integer. Maps to "char" type in Java.
+ *
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ uint16_t ReadUInt16(const char* fieldName);
+
+ /**
+ * Read array of 16-byte unsigned integers. Maps to "char[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadUInt16Array(const char* fieldName, uint16_t* res, const int32_t len);
+
+ /**
+ * Read 32-byte signed integer. Maps to "int" type in Java.
+ *
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ int32_t ReadInt32(const char* fieldName);
+
+ /**
+ * Read array of 32-byte signed integers. Maps to "int[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadInt32Array(const char* fieldName, int32_t* res, const int32_t len);
+
+ /**
+ * Read 64-byte signed integer. Maps to "long" type in Java.
+ *
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ int64_t ReadInt64(const char* fieldName);
+
+ /**
+ * Read array of 64-byte signed integers. Maps to "long[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadInt64Array(const char* fieldName, int64_t* res, const int32_t len);
+
+ /**
+ * Read float. Maps to "float" type in Java.
+ *
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ float ReadFloat(const char* fieldName);
+
+ /**
+ * Read array of floats. Maps to "float[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadFloatArray(const char* fieldName, float* res, const int32_t len);
+
+ /**
+ * Read double. Maps to "double" type in Java.
+ *
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ double ReadDouble(const char* fieldName);
+
+ /**
+ * Read array of doubles. Maps to "double[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadDoubleArray(const char* fieldName, double* res, const int32_t len);
+
+ /**
+ * Read Guid. Maps to "UUID" type in Java.
+ *
+ * @param fieldName Field name.
+ * @return Result.
+ */
+ Guid ReadGuid(const char* fieldName);
+
+ /**
+ * Read array of Guids. Maps to "UUID[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of array.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadGuidArray(const char* fieldName, Guid* res, const int32_t len);
+
+ /**
+ * Read string.
+ *
+ * @param fieldName Field name.
+ * @param res Array to store data to.
+ * @param len Expected length of string. NULL terminator will be set in case len is
+ * greater than real string length.
+ * @return Actual amount of elements read. If "len" argument is less than actual
+ * array size or resulting array is set to null, nothing will be written
+ * to resulting array and returned value will contain required array length.
+ * -1 will be returned in case array in stream was null.
+ */
+ int32_t ReadString(const char* fieldName, char* res, const int32_t len);
+
+ /**
+ * Read string from the stream.
+ *
+ * @param fieldName Field name.
+ * @return String.
+ */
+ std::string ReadString(const char* fieldName)
+ {
+ int32_t len = ReadString(fieldName, NULL, 0);
+
+ if (len != -1)
+ {
+ gridgain::impl::utils::SafeArray<char> arr(len + 1);
+
+ ReadString(fieldName, arr.target, len + 1);
+
+ return std::string(arr.target);
+ }
+ else
+ return std::string();
+ }
+
+ /**
+ * Start string array read.
+ *
+ * @param fieldName Field name.
+ * @return String array reader.
+ */
+ PortableStringArrayReader ReadStringArray(const char* fieldName);
+
+ /**
+ * Start array read.
+ *
+ * @param fieldName Field name.
+ * @return Array reader.
+ */
+ template<typename T>
+ PortableArrayReader<T> ReadArray(const char* fieldName)
+ {
+ int32_t size;
+
+ int32_t id = impl->ReadArray(fieldName, &size);
+
+ return PortableArrayReader<T>(impl, id, size);
+ }
+
+ /**
+ * Start collection read.
+ *
+ * @param fieldName Field name.
+ * @return Collection reader.
+ */
+ template<typename T>
+ PortableCollectionReader<T> ReadCollection(const char* fieldName)
+ {
+ CollectionType typ;
+ int32_t size;
+
+ int32_t id = impl->ReadCollection(fieldName, &typ, &size);
+
+ return PortableCollectionReader<T>(impl, id, typ, size);
+ }
+
+ /**
+ * Start map read.
+ *
+ * @param fieldName Field name.
+ * @return Map reader.
+ */
+ template<typename K, typename V>
+ PortableMapReader<K, V> ReadMap(const char* fieldName)
+ {
+ MapType typ;
+ int32_t size;
+
+ int32_t id = impl->ReadMap(fieldName, &typ, &size);
+
+ return PortableMapReader<K, V>(impl, id, typ, size);
+ }
+
+ /**
+ * Read object.
+ *
+ * @param fieldName Field name.
+ * @return Object.
+ */
+ template<typename T>
+ T ReadObject(const char* fieldName)
+ {
+ return impl->ReadObject<T>(fieldName);
+ }
+
+ /**
+ * Get raw reader for this reader.
+ *
+ * @return Raw reader.
+ */
+ PortableRawReader RawReader();
+ private:
+ /** Implementation delegate. */
+ gridgain::impl::portable::PortableReaderImpl* impl;
+ };
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_type.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_type.h b/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_type.h
new file mode 100644
index 0000000..53528071
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_type.h
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef _GRIDGAIN_PORTABLE_TYPE
+#define _GRIDGAIN_PORTABLE_TYPE
+
+#include <stdint.h>
+
+#include <ignite/common/common.h>
+
+#include "gridgain/grid_error.h"
+
+/**
+ * Start portable type definition.
+ */
+#define GG_PORTABLE_TYPE_START(T) \
+template<> \
+struct PortableType<T> \
+{
+
+/**
+ * End portable type definition.
+ */
+#define GG_PORTABLE_TYPE_END \
+};
+
+/**
+ * Implementation of GetTypeId() which returns predefined constant.
+ */
+#define GG_PORTABLE_GET_TYPE_ID_AS_CONST(id) \
+int32_t GetTypeId() \
+{ \
+ return id; \
+}
+
+/**
+ * Implementation of GetTypeId() which returns hash of passed type name.
+ */
+#define GG_PORTABLE_GET_TYPE_ID_AS_HASH(typeName) \
+int32_t GetTypeId() \
+{ \
+ return GetPortableStringHashCode(#typeName); \
+}
+
+/**
+ * Implementation of GetTypeName() which returns type name as is.
+ */
+#define GG_PORTABLE_GET_TYPE_NAME_AS_IS(typeName) \
+std::string GetTypeName() \
+{ \
+ return #typeName; \
+}
+
+/**
+ * Default implementation of GetFieldId() function which returns Java-way hash code of the string.
+ */
+#define GG_PORTABLE_GET_FIELD_ID_AS_HASH \
+int32_t GetFieldId(const char* name) \
+{ \
+ return GetPortableStringHashCode(name); \
+}
+
+/**
+ * Implementation of GetHashCode() function which always returns 0.
+ */
+#define GG_PORTABLE_GET_HASH_CODE_ZERO(T) \
+int32_t GetHashCode(const T& obj) \
+{ \
+ return 0; \
+}
+
+/**
+ * Implementation of IsNull() function which always returns false.
+ */
+#define GG_PORTABLE_IS_NULL_FALSE(T) \
+bool IsNull(const T& obj) \
+{ \
+ return false; \
+}
+
+/**
+ * Implementation of IsNull() function which return true if passed object is null pointer.
+ */
+#define GG_PORTABLE_IS_NULL_IF_NULLPTR(T) \
+bool IsNull(const T& obj) \
+{ \
+ return obj; \
+}
+
+/**
+ * Implementation of GetNull() function which returns an instance created with defult constructor.
+ */
+#define GG_PORTABLE_GET_NULL_DEFAULT_CTOR(T) \
+T GetNull() \
+{ \
+ return T(); \
+}
+
+/**
+ * Implementation of GetNull() function which returns NULL pointer.
+ */
+#define GG_PORTABLE_GET_NULL_NULLPTR(T) \
+T GetNull() \
+{ \
+ return NULL; \
+}
+
+namespace gridgain
+{
+ namespace portable
+ {
+ class PortableWriter;
+ class PortableReader;
+
+ /**
+ * Get portable string hash code.
+ *
+ * @param val Value.
+ * @return Hash code.
+ */
+ IGNITE_IMPORT_EXPORT int32_t GetPortableStringHashCode(const char* val);
+
+ /**
+ * Portable type structure. Defines a set of functions required for type to be serialized and deserialized.
+ */
+ template<typename T>
+ struct IGNITE_IMPORT_EXPORT PortableType
+ {
+ /**
+ * Get portable object type ID.
+ *
+ * @return Type ID.
+ */
+ int32_t GetTypeId()
+ {
+ GG_ERROR_1(GridError::GG_ERR_PORTABLE, "GetTypeId function is not defined for portable type.");
+ }
+
+ /**
+ * Get portable object type name.
+ *
+ * @return Type name.
+ */
+ std::string GetTypeName()
+ {
+ GG_ERROR_1(GridError::GG_ERR_PORTABLE, "GetTypeName function is not defined for portable type.");
+ }
+
+ /**
+ * Get portable object field ID.
+ *
+ * @param name Field name.
+ * @return Field ID.
+ */
+ int32_t GetFieldId(const char* name)
+ {
+ return GetPortableStringHashCode(name);
+ }
+
+ /**
+ * Get portable object hash code.
+ *
+ * @param obj Portable object.
+ * @return Hash code.
+ */
+ int32_t GetHashCode(const T& obj)
+ {
+ return 0;
+ }
+
+ /**
+ * Write portable object.
+ *
+ * @param writer Writer.
+ * @param obj Object.
+ */
+ void Write(PortableWriter& writer, const T& obj)
+ {
+ GG_ERROR_1(GridError::GG_ERR_PORTABLE, "Write function is not defined for portable type.");
+ }
+
+ /**
+ * Read portable object.
+ *
+ * @param reader Reader.
+ * @return Object.
+ */
+ T Read(PortableReader& reader)
+ {
+ GG_ERROR_1(GridError::GG_ERR_PORTABLE, "Read function is not defined for portable type.");
+ }
+
+ /**
+ * Check whether passed portable object should be interpreted as NULL.
+ *
+ * @param obj Portable object to test.
+ * @return True if portable object should be interpreted as NULL.
+ */
+ bool IsNull(const T& obj)
+ {
+ return false;
+ }
+
+ /**
+ * Get NULL value for the given portable type.
+ *
+ * @return NULL value.
+ */
+ T GetNull()
+ {
+ GG_ERROR_1(GridError::GG_ERR_PORTABLE, "GetNull function is not defined for portable type.");
+ }
+ };
+
+ /*
+ * Templated portable type for pointers.
+ */
+ template <typename T>
+ struct IGNITE_IMPORT_EXPORT PortableType<T*>
+ {
+ /** Actual type. */
+ PortableType<T> typ;
+
+ /**
+ * Constructor.
+ */
+ PortableType()
+ {
+ typ = PortableType<T>();
+ }
+
+ int32_t GetTypeId()
+ {
+ return typ.GetTypeId();
+ }
+
+ std::string GetTypeName()
+ {
+ return typ.GetTypeName();
+ }
+
+ int32_t GetFieldId(const char* name)
+ {
+ return typ.GetFieldId(name);
+ }
+
+ int32_t GetHashCode(T* const& obj)
+ {
+ return typ.GetHashCode(*obj);
+ }
+
+ void Write(PortableWriter& writer, T* const& obj)
+ {
+ typ.Write(writer, *obj);
+ }
+
+ T* Read(PortableReader& reader)
+ {
+ T* res = new T();
+
+ *res = typ.Read(reader);
+
+ return res;
+ }
+
+ bool IsNull(T* const& obj)
+ {
+ return !obj || typ.IsNull(*obj);
+ }
+
+ T* GetNull()
+ {
+ return NULL;
+ }
+ };
+ }
+}
+
+#endif
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_writer.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_writer.h b/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_writer.h
new file mode 100644
index 0000000..4730ef7
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/include/gridgain/portable/portable_writer.h
@@ -0,0 +1,327 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef _GRIDGAIN_PORTABLE_WRITER
+#define _GRIDGAIN_PORTABLE_WRITER
+
+#include <string>
+#include <stdint.h>
+
+#include <ignite/common/common.h>
+
+#include "gridgain/portable/portable_raw_writer.h"
+
+namespace gridgain
+{
+ namespace portable
+ {
+ /**
+ * Portable writer.
+ */
+ class IGNITE_IMPORT_EXPORT PortableWriter
+ {
+ public:
+ /**
+ * Constructor.
+ *
+ * @param impl Implementation.
+ */
+ PortableWriter(gridgain::impl::portable::PortableWriterImpl* impl);
+
+ /**
+ * Write 8-byte signed integer. Maps to "byte" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteInt8(const char* fieldName, const int8_t val);
+
+ /**
+ * Write array of 8-byte signed integers. Maps to "byte[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteInt8Array(const char* fieldName, const int8_t* val, const int32_t len);
+
+ /**
+ * Write bool. Maps to "short" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteBool(const char* fieldName, const bool val);
+
+ /**
+ * Write array of bools. Maps to "bool[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteBoolArray(const char* fieldName, const bool* val, const int32_t len);
+
+ /**
+ * Write 16-byte signed integer. Maps to "short" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteInt16(const char* fieldName, const int16_t val);
+
+ /**
+ * Write array of 16-byte signed integers. Maps to "short[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteInt16Array(const char* fieldName, const int16_t* val, const int32_t len);
+
+ /**
+ * Write 16-byte unsigned integer. Maps to "char" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteUInt16(const char* fieldName, const uint16_t val);
+
+ /**
+ * Write array of 16-byte unsigned integers. Maps to "char[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteUInt16Array(const char* fieldName, const uint16_t* val, const int32_t len);
+
+ /**
+ * Write 32-byte signed integer. Maps to "int" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteInt32(const char* fieldName, const int32_t val);
+
+ /**
+ * Write array of 32-byte signed integers. Maps to "int[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteInt32Array(const char* fieldName, const int32_t* val, const int32_t len);
+
+ /**
+ * Write 64-byte signed integer. Maps to "long" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteInt64(const char* fieldName, const int64_t val);
+
+ /**
+ * Write array of 64-byte signed integers. Maps to "long[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteInt64Array(const char* fieldName, const int64_t* val, const int32_t len);
+
+ /**
+ * Write float. Maps to "float" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteFloat(const char* fieldName, const float val);
+
+ /**
+ * Write array of floats. Maps to "float[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteFloatArray(const char* fieldName, const float* val, const int32_t len);
+
+ /**
+ * Write double. Maps to "double" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteDouble(const char* fieldName, const double val);
+
+ /**
+ * Write array of doubles. Maps to "double[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteDoubleArray(const char* fieldName, const double* val, const int32_t len);
+
+ /**
+ * Write Guid. Maps to "UUID" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ void WriteGuid(const char* fieldName, const Guid val);
+
+ /**
+ * Write array of Guids. Maps to "UUID[]" type in Java.
+ *
+ * @param fieldName Field name.
+ * @param val Array.
+ * @param len Array length.
+ */
+ void WriteGuidArray(const char* fieldName, const Guid* val, const int32_t len);
+
+ /**
+ * Write string.
+ *
+ * @param fieldName Field name.
+ * @param val Null-terminated character sequence.
+ */
+ void WriteString(const char* fieldName, const char* val);
+
+ /**
+ * Write string.
+ *
+ * @param fieldName Field name.
+ * @param val String.
+ * @param len String length (characters).
+ */
+ void WriteString(const char* fieldName, const char* val, const int32_t len);
+
+ /**
+ * Write string.
+ *
+ * @param fieldName Field name.
+ * @param val String.
+ */
+ void WriteString(const char* fieldName, const std::string& val)
+ {
+ WriteString(fieldName, val.c_str());
+ }
+
+ /**
+ * Start string array write.
+ *
+ * @param fieldName Field name.
+ * @return String array writer.
+ */
+ PortableStringArrayWriter WriteStringArray(const char* fieldName);
+
+ /**
+ * Write NULL value.
+ *
+ * @param fieldName Field name.
+ */
+ void WriteNull(const char* fieldName);
+
+ /**
+ * Start array write.
+ *
+ * @param fieldName Field name.
+ * @return Array writer.
+ */
+ template<typename T>
+ PortableArrayWriter<T> WriteArray(const char* fieldName)
+ {
+ int32_t id = impl->WriteArray(fieldName);
+
+ return PortableArrayWriter<T>(impl, id);
+ }
+
+ /**
+ * Start collection write.
+ *
+ * @param fieldName Field name.
+ * @return Collection writer.
+ */
+ template<typename T>
+ PortableCollectionWriter<T> WriteCollection(const char* fieldName)
+ {
+ return WriteCollection<T>(fieldName, GG_COLLECTION_UNDEFINED);
+ }
+
+ /**
+ * Start collection write.
+ *
+ * @param fieldName Field name.
+ * @param type Collection type.
+ * @return Collection writer.
+ */
+ template<typename T>
+ PortableCollectionWriter<T> WriteCollection(const char* fieldName, gridgain::portable::CollectionType typ)
+ {
+ int32_t id = impl->WriteCollection(fieldName, typ);
+
+ return PortableCollectionWriter<T>(impl, id);
+ }
+
+ /**
+ * Start map write.
+ *
+ * @param fieldName Field name.
+ * @param typ Map type.
+ * @return Map writer.
+ */
+ template<typename K, typename V>
+ PortableMapWriter<K, V> WriteMap(const char* fieldName)
+ {
+ return WriteMap<K, V>(fieldName, GG_MAP_UNDEFINED);
+ }
+
+ /**
+ * Start map write.
+ *
+ * @param fieldName Field name.
+ * @param typ Map type.
+ * @return Map writer.
+ */
+ template<typename K, typename V>
+ PortableMapWriter<K, V> WriteMap(const char* fieldName, gridgain::portable::MapType typ)
+ {
+ int32_t id = impl->WriteMap(fieldName, typ);
+
+ return PortableMapWriter<K, V>(impl, id);
+ }
+
+ /**
+ * Write object.
+ *
+ * @param fieldName Field name.
+ * @param val Value.
+ */
+ template<typename T>
+ void WriteObject(const char* fieldName, T val)
+ {
+ impl->WriteObject<T>(fieldName, val);
+ }
+
+ /**
+ * Get raw writer for this reader.
+ *
+ * @return Raw writer.
+ */
+ PortableRawWriter RawWriter();
+ private:
+ /** Implementation delegate. */
+ gridgain::impl::portable::PortableWriterImpl* impl;
+ };
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/os/linux/include/Makefile.am
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/os/linux/include/Makefile.am b/modules/platform/src/main/cpp/core/os/linux/include/Makefile.am
new file mode 100644
index 0000000..59a7a69
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/os/linux/include/Makefile.am
@@ -0,0 +1,3 @@
+ACLOCAL_AMFLAGS = "-Im4"
+
+nobase_include_HEADERS = gridgain/impl/utils.h
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/os/linux/include/gridgain/impl/utils.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/os/linux/include/gridgain/impl/utils.h b/modules/platform/src/main/cpp/core/os/linux/include/gridgain/impl/utils.h
new file mode 100644
index 0000000..980114f
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/os/linux/include/gridgain/impl/utils.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef GRIDGAIN_UTILS
+#define GRIDGAIN_UTILS
+
+#include <cstring>
+#include <string>
+
+#include <ignite/common/common.h>
+
+#ifdef GG_FRIEND
+ #define GG_FRIEND_EXPORT IGNITE_EXPORT
+#else
+ #define GG_FRIEND_EXPORT
+#endif
+
+namespace gridgain
+{
+ namespace impl
+ {
+ namespace utils
+ {
+ /**
+ * Copy characters.
+ *
+ * @param val Value.
+ * @return Result.
+ */
+ GG_FRIEND_EXPORT char* CopyChars(const char* val);
+
+ /**
+ * Release characters.
+ *
+ * @param val Value.
+ */
+ GG_FRIEND_EXPORT void ReleaseChars(char* val);
+
+ /**
+ * Read system environment variable taking thread-safety in count.
+ *
+ * @param name Environment variable name.
+ * @param found Whether environment variable with such name was found.
+ * @return Environment variable value.
+ */
+ GG_FRIEND_EXPORT std::string GetEnv(const std::string& name, bool* found);
+
+ /**
+ * Ensure that file on the given path exists in the system.
+ *
+ * @param path Path.
+ * @return True if file exists, false otherwise.
+ */
+ GG_FRIEND_EXPORT bool FileExists(const std::string& path);
+
+ /**
+ * Attempts to find JVM library to load it into the process later.
+ * First search is performed using the passed path argument (is not NULL).
+ * Then JRE_HOME is evaluated. Last, JAVA_HOME is evaluated.
+ *
+ * @param Explicitly defined path (optional).
+ * @param found Whether library was found.
+ * @return Path to the file.
+ */
+ GG_FRIEND_EXPORT std::string FindJvmLibrary(const std::string* path, bool* found);
+
+ /**
+ * Load JVM library into the process.
+ *
+ * @param path Optional path to the library.
+ * @return Whether load was successful.
+ */
+ GG_FRIEND_EXPORT bool LoadJvmLibrary(const std::string& path);
+
+ /**
+ * Resolve GRIDGAIN_HOME directory. Resolution is performed in several
+ * steps:
+ * 1) Check for path provided as argument.
+ * 2) Check for environment variable.
+ * 3) Check for current working directory.
+ * Result of these 3 checks are evaluated based on existence of certain
+ * predefined folders inside possible GG home. If they are found,
+ * GRIDGAIN_HOME is considered resolved.
+ *
+ * @param path Optional path to evaluate.
+ * @param found Whether GRIDGAIN_HOME home was found.
+ * @return Resolved GG home.
+ */
+ GG_FRIEND_EXPORT std::string ResolveGridGainHome(const std::string* path, bool* found);
+
+ /**
+ * Create GridGain classpath based on user input and home directory.
+ *
+ * @param usrCp User's classpath.
+ * @param home GridGain home directory.
+ * @return Classpath.
+ */
+ GG_FRIEND_EXPORT std::string CreateGridGainClasspath(const std::string* usrCp, const std::string* home);
+
+ /**
+ * Create GridGain classpath based on user input and home directory.
+ *
+ * @param usrCp User's classpath.
+ * @param home GridGain home directory.
+ * @param test Whether test classpath must be used.
+ * @return Classpath.
+ */
+ GG_FRIEND_EXPORT std::string CreateGridGainClasspath(const std::string* usrCp, const std::string* home, bool test);
+
+ /**
+ * Safe array which automatically reclaims occupied memory when out of scope.
+ */
+ template<typename T>
+ struct GG_FRIEND_EXPORT SafeArray
+ {
+ /**
+ * Constructor.
+ */
+ SafeArray(int cap)
+ {
+ target = new T[cap];
+ }
+
+ /**
+ * Destructor.
+ */
+ ~SafeArray()
+ {
+ delete[] target;
+ }
+
+ IGNITE_NO_COPY_ASSIGNMENT(SafeArray);
+
+ /** Target array. */
+ T* target;
+ };
+ }
+ }
+}
+
+#endif
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/os/linux/src/impl/utils.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/os/linux/src/impl/utils.cpp b/modules/platform/src/main/cpp/core/os/linux/src/impl/utils.cpp
new file mode 100644
index 0000000..ae53d9f
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/os/linux/src/impl/utils.cpp
@@ -0,0 +1,440 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <dlfcn.h>
+
+#include "gridgain/impl/utils.h"
+
+namespace gridgain
+{
+ namespace impl
+ {
+ namespace utils
+ {
+ const char* JAVA_HOME = "JAVA_HOME";
+ const char* JAVA_DLL = "/jre/lib/amd64/server/libjvm.so";
+
+ const char* GRIDGAIN_HOME = "GRIDGAIN_HOME";
+
+ const char* PROBE_BIN = "/bin";
+ const char* PROBE_EXAMPLES = "/examples";
+
+ const char* GRIDGAIN_NATIVE_TEST_CLASSPATH = "GRIDGAIN_NATIVE_TEST_CLASSPATH";
+
+ /**
+ * Helper method to set boolean result to reference with proper NULL-check.
+ *
+ * @param res Result.
+ * @param outRes Where to set the result.
+ */
+ inline void SetBoolResult(bool res, bool* outRes)
+ {
+ if (outRes)
+ *outRes = res;
+ }
+
+ /**
+ * Check if string ends with the given ending.
+ *
+ * @param str String to check.
+ * @param ending Ending.
+ * @return Result.
+ */
+ inline bool StringEndsWith(const std::string& str, const std::string& ending)
+ {
+ if (str.length() > ending.length())
+ return str.compare(str.length() - ending.length(), ending.length(), ending) == 0;
+
+ return false;
+ }
+
+ /**
+ * Helper function for GG home resolution. Checks whether certain folders
+ * exist in the path. Optionally goes upwards in directory hierarchy.
+ *
+ * @param path Path to evaluate.
+ * @param up Whether to go upwards.
+ * @res Resolution result.
+ * @return Resolved directory.
+ */
+ std::string ResolveGridGainHome0(const std::string& path, bool up, bool* res)
+ {
+ struct stat pathStat;
+
+ if (stat(path.c_str(), &pathStat) != -1 && S_ISDIR(pathStat.st_mode))
+ {
+ // Remove trailing slashes, otherwise we will have an infinite loop.
+ std::string path0 = path;
+
+ while (true) {
+ char lastChar = *path0.rbegin();
+
+ if (lastChar == '/' || lastChar == ' ') {
+ size_t off = path0.find_last_of(lastChar);
+
+ path0.erase(off, 1);
+ }
+ else
+ break;
+ }
+
+ std::string binStr = path0 + PROBE_BIN;
+ struct stat binStat;
+
+ std::string examplesStr = path0 + PROBE_EXAMPLES;
+ struct stat examplesStat;
+
+ if (stat(binStr.c_str(), &binStat) != -1 && S_ISDIR(binStat.st_mode) &&
+ stat(examplesStr.c_str(), &examplesStat) != -1 && S_ISDIR(examplesStat.st_mode))
+ {
+ SetBoolResult(true, res);
+
+ return std::string(path0);
+ }
+
+ if (up)
+ {
+ // Evaluate parent directory.
+ size_t slashPos = path0.find_last_of("/");
+
+ if (slashPos != std::string::npos)
+ {
+ std::string parent = path0.substr(0, slashPos);
+
+ return ResolveGridGainHome0(parent, true, res);
+ }
+ }
+
+ }
+
+ SetBoolResult(false, res);
+
+ return std::string();
+ }
+
+ /**
+ * Create classpath picking JARs from the given path.
+ *
+ * @path Path.
+ * @return Classpath;
+ */
+ std::string ClasspathJars(const std::string& path)
+ {
+ std::string res = std::string();
+
+ DIR* dir = opendir(path.c_str());
+
+ if (dir)
+ {
+ struct dirent* entry;
+
+ while ((entry = readdir(dir)) != NULL)
+ {
+ if (strstr(entry->d_name, ".jar"))
+ {
+ res.append(path);
+ res.append("/");
+ res.append(entry->d_name);
+ res.append(":");
+ }
+ }
+
+ closedir(dir);
+ }
+
+ return res;
+ }
+
+ /**
+ * Create classpath picking compiled classes from the given path.
+ *
+ * @path Path.
+ * @return Classpath;
+ */
+ std::string ClasspathExploded(const std::string& path, bool down)
+ {
+ std::string res = std::string();
+
+ if (FileExists(path))
+ {
+ // 1. Append "target\classes".
+ std::string classesPath = path + "/target/classes";
+
+ if (FileExists(classesPath)) {
+ res += classesPath;
+ res += ":";
+ }
+
+ // 2. Append "target\test-classes"
+ std::string testClassesPath = path + "/target/test-classes";
+
+ if (FileExists(testClassesPath)) {
+ res += testClassesPath;
+ res += ":";
+ }
+
+ // 3. Append "target\libs"
+ std::string libsPath = path + "/target/libs";
+
+ if (FileExists(libsPath)) {
+ std::string libsCp = ClasspathJars(libsPath);
+ res += libsCp;
+ }
+
+ // 4. Do the same for child if needed.
+ if (down)
+ {
+ DIR* dir = opendir(path.c_str());
+
+ if (dir)
+ {
+ struct dirent* entry;
+
+ while ((entry = readdir(dir)) != NULL)
+ {
+ std::string entryPath = entry->d_name;
+
+ if (entryPath.compare(".") != 0 && entryPath.compare("..") != 0)
+ {
+ std::string entryFullPath = path + "/" + entryPath;
+
+ struct stat entryFullStat;
+
+ if (stat(entryFullPath.c_str(), &entryFullStat) != -1 && S_ISDIR(entryFullStat.st_mode))
+ {
+ std::string childCp = ClasspathExploded(entryFullPath, false);
+
+ res += childCp;
+ }
+ }
+ }
+
+ closedir(dir);
+ }
+ }
+ }
+
+ return res;
+ }
+
+ /**
+ * Helper function to create classpath based on GridGain home directory.
+ *
+ * @param home Home directory; expected to be valid.
+ * @param forceTest Force test classpath.
+ */
+ std::string CreateGridGainHomeClasspath(const std::string& home, bool forceTest)
+ {
+ std::string res = std::string();
+
+ // 1. Add exploded test directories.
+ if (forceTest)
+ {
+ std::string examplesPath = home + "/examples";
+ std::string examplesCp = ClasspathExploded(examplesPath, true);
+ res.append(examplesCp);
+
+ std::string modulesPath = home + "/modules";
+ std::string modulesCp = ClasspathExploded(modulesPath, true);
+ res.append(modulesCp);
+
+ std::string igniteExamplesPath = home + "/../incubator-ignite/examples";
+ std::string igniteExamplesCp = ClasspathExploded(igniteExamplesPath, true);
+ res.append(igniteExamplesCp);
+
+ std::string igniteModulesPath = home + "/../incubator-ignite/modules";
+ std::string igniteModulesCp = ClasspathExploded(igniteModulesPath, true);
+ res.append(igniteModulesCp);
+ }
+
+ // 2. Add regular jars from "libs" folder excluding "optional".
+ std::string libsPath = home + "/libs";
+
+ if (FileExists(libsPath))
+ {
+ res.append(ClasspathJars(libsPath));
+
+ // Append inner directories.
+ DIR* dir = opendir(libsPath.c_str());
+
+ if (dir)
+ {
+ struct dirent* entry;
+
+ while ((entry = readdir(dir)) != NULL)
+ {
+ std::string entryPath = entry->d_name;
+
+ if (entryPath.compare(".") != 0 && entryPath.compare("..") != 0 &&
+ entryPath.compare("optional") != 0)
+ {
+ std::string entryFullPath = libsPath;
+
+ entryFullPath.append("/");
+ entryFullPath.append(entryPath);
+
+ struct stat entryFullStat;
+
+ if (stat(entryFullPath.c_str(), &entryFullStat) != -1 &&
+ S_ISDIR(entryFullStat.st_mode))
+ res.append(ClasspathJars(entryFullPath));
+ }
+ }
+
+ closedir(dir);
+ }
+ }
+
+ // 3. Return.
+ return res;
+ }
+
+ char* CopyChars(const char* val)
+ {
+ if (val) {
+ size_t len = strlen(val);
+ char* dest = new char[len + 1];
+ strcpy(dest, val);
+ *(dest + len) = 0;
+ return dest;
+ }
+ else
+ return NULL;
+ }
+
+ void ReleaseChars(char* val)
+ {
+ if (val)
+ delete[] val;
+ }
+
+ std::string GetEnv(const std::string& name, bool* found)
+ {
+ char* val = std::getenv(name.c_str());
+
+ if (val) {
+ SetBoolResult(true, found);
+
+ return std::string(val);
+ }
+ else {
+ SetBoolResult(false, found);
+
+ return std::string();
+ }
+ }
+
+ bool FileExists(const std::string& path)
+ {
+ struct stat s;
+
+ int res = stat(path.c_str(), &s);
+
+ return res != -1;
+ }
+
+ std::string FindJvmLibrary(const std::string* path, bool* found)
+ {
+ SetBoolResult(true, found); // Optimistically assume that we will find it.
+
+ if (path) {
+ // If path is provided explicitly, then check only it.
+ if (FileExists(*path))
+ return std::string(path->data());
+ }
+ else
+ {
+ bool javaEnvFound;
+ std::string javaEnv = GetEnv(JAVA_HOME, &javaEnvFound);
+
+ if (javaEnvFound)
+ {
+ std::string javaDll = javaEnv + JAVA_DLL;
+
+ if (FileExists(javaDll))
+ return std::string(javaDll);
+ }
+ }
+
+ SetBoolResult(false, found);
+
+ return std::string();
+ }
+
+ bool LoadJvmLibrary(const std::string& path)
+ {
+ void* hnd = dlopen(path.c_str(), RTLD_LAZY);
+
+ return hnd != NULL;
+ }
+
+ std::string ResolveGridGainHome(const std::string* path, bool* found)
+ {
+ if (path)
+ // 1. Check passed argument.
+ return ResolveGridGainHome0(*path, false, found);
+ else
+ {
+ // 2. Check environment variable.
+ bool envFound;
+ std::string env = GetEnv(GRIDGAIN_HOME, &envFound);
+
+ if (envFound)
+ return ResolveGridGainHome0(env, false, found);
+ }
+
+ SetBoolResult(false, found);
+
+ return std::string();
+ }
+
+ std::string CreateGridGainClasspath(const std::string* usrCp, const std::string* home)
+ {
+ bool forceTest = false;
+
+ if (home)
+ {
+ bool envFound;
+ std::string env = GetEnv(GRIDGAIN_NATIVE_TEST_CLASSPATH, &envFound);
+
+ forceTest = envFound && env.compare("true") == 0;
+ }
+
+ return CreateGridGainClasspath(usrCp, home, forceTest);
+ }
+
+ std::string CreateGridGainClasspath(const std::string* usrCp, const std::string* home, bool forceTest)
+ {
+ // 1. Append user classpath if it exists.
+ std::string cp = std::string();
+
+ if (usrCp)
+ {
+ cp.append(*usrCp);
+
+ if (*cp.rbegin() != ':')
+ cp.append(":");
+ }
+
+ // 2. Append home classpath if home is defined.
+ if (home)
+ {
+ std::string homeCp = CreateGridGainHomeClasspath(*home, forceTest);
+
+ cp.append(homeCp);
+ }
+
+ // 3. Return.
+ return cp;
+ }
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/os/win/include/gridgain/impl/utils.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/os/win/include/gridgain/impl/utils.h b/modules/platform/src/main/cpp/core/os/win/include/gridgain/impl/utils.h
new file mode 100644
index 0000000..4fa906f
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/os/win/include/gridgain/impl/utils.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#ifndef GRIDGAIN_UTILS
+#define GRIDGAIN_UTILS
+
+#include <cstring>
+#include <string>
+
+#include <ignite/common/common.h>
+
+#ifdef GG_FRIEND
+ #define GG_FRIEND_EXPORT IGNITE_EXPORT
+#else
+ #define GG_FRIEND_EXPORT
+#endif
+
+namespace gridgain
+{
+ namespace impl
+ {
+ namespace utils
+ {
+ /**
+ * Copy characters.
+ *
+ * @param val Value.
+ * @return Result.
+ */
+ GG_FRIEND_EXPORT char* CopyChars(const char* val);
+
+ /**
+ * Release characters.
+ *
+ * @param val Value.
+ */
+ GG_FRIEND_EXPORT void ReleaseChars(char* val);
+
+ /**
+ * Read system environment variable taking thread-safety in count.
+ *
+ * @param name Environment variable name.
+ * @param found Whether environment variable with such name was found.
+ * @return Environment variable value.
+ */
+ GG_FRIEND_EXPORT std::string GetEnv(const std::string& name, bool* found);
+
+ /**
+ * Ensure that file on the given path exists in the system.
+ *
+ * @param path Path.
+ * @return True if file exists, false otherwise.
+ */
+ GG_FRIEND_EXPORT bool FileExists(const std::string& path);
+
+ /**
+ * Attempts to find JVM library to load it into the process later.
+ * First search is performed using the passed path argument (is not NULL).
+ * Then JRE_HOME is evaluated. Last, JAVA_HOME is evaluated.
+ *
+ * @param Explicitly defined path (optional).
+ * @param found Whether library was found.
+ * @return Path to the file.
+ */
+ GG_FRIEND_EXPORT std::string FindJvmLibrary(const std::string* path, bool* found);
+
+ /**
+ * Load JVM library into the process.
+ *
+ * @param path Optional path to the library.
+ * @return Whether load was successful.
+ */
+ GG_FRIEND_EXPORT bool LoadJvmLibrary(const std::string& path);
+
+ /**
+ * Resolve GRIDGAIN_HOME directory. Resolution is performed in several
+ * steps:
+ * 1) Check for path provided as argument.
+ * 2) Check for environment variable.
+ * 3) Check for current working directory.
+ * Result of these 3 checks are evaluated based on existence of certain
+ * predefined folders inside possible GG home. If they are found,
+ * GRIDGAIN_HOME is considered resolved.
+ *
+ * @param path Optional path to evaluate.
+ * @param found Whether GRIDGAIN_HOME home was found.
+ * @return Resolved GG home.
+ */
+ GG_FRIEND_EXPORT std::string ResolveGridGainHome(const std::string* path, bool* found);
+
+ /**
+ * Create GridGain classpath based on user input and home directory.
+ *
+ * @param usrCp User's classpath.
+ * @param home GridGain home directory.
+ * @return Classpath.
+ */
+ GG_FRIEND_EXPORT std::string CreateGridGainClasspath(const std::string* usrCp, const std::string* home);
+
+ /**
+ * Create GridGain classpath based on user input and home directory.
+ *
+ * @param usrCp User's classpath.
+ * @param home GridGain home directory.
+ * @param test Whether test classpath must be used.
+ * @return Classpath.
+ */
+ GG_FRIEND_EXPORT std::string CreateGridGainClasspath(const std::string* usrCp, const std::string* home, bool test);
+
+ /**
+ * Safe array which automatically reclaims occupied memory when out of scope.
+ */
+ template<typename T>
+ struct GG_FRIEND_EXPORT SafeArray
+ {
+ /** Target array. */
+ T* target;
+
+ /**
+ * Constructor.
+ */
+ SafeArray(int cap)
+ {
+ target = new T[cap];
+ }
+
+ /**
+ * Destructor.
+ */
+ ~SafeArray()
+ {
+ delete[] target;
+ }
+
+ IGNITE_NO_COPY_ASSIGNMENT(SafeArray);
+ };
+ }
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/os/win/src/impl/utils.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/os/win/src/impl/utils.cpp b/modules/platform/src/main/cpp/core/os/win/src/impl/utils.cpp
new file mode 100644
index 0000000..b61368f
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/os/win/src/impl/utils.cpp
@@ -0,0 +1,453 @@
+/*
+ * Copyright (C) GridGain Systems. All Rights Reserved.
+ * _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+#include <windows.h>
+
+#include "gridgain/impl/utils.h"
+
+namespace gridgain
+{
+ namespace impl
+ {
+ namespace utils
+ {
+ const char* JAVA_HOME = "JAVA_HOME";
+ const char* JAVA_DLL = "\\jre\\bin\\server\\jvm.dll";
+
+ const char* GRIDGAIN_HOME = "GRIDGAIN_HOME";
+
+ const char* PROBE_BIN = "\\bin";
+ const char* PROBE_EXAMPLES = "\\examples";
+
+ const char* GRIDGAIN_NATIVE_TEST_CLASSPATH = "GRIDGAIN_NATIVE_TEST_CLASSPATH";
+
+ /**
+ * Helper method to set boolean result to reference with proper NULL-check.
+ *
+ * @param res Result.
+ * @param outRes Where to set the result.
+ */
+ inline void SetBoolResult(bool res, bool* outRes)
+ {
+ if (outRes)
+ *outRes = res;
+ }
+
+ /**
+ * Check if string ends with the given ending.
+ *
+ * @param str String to check.
+ * @param ending Ending.
+ * @return Result.
+ */
+ inline bool StringEndsWith(const std::string& str, const std::string& ending)
+ {
+ if (str.length() > ending.length())
+ return str.compare(str.length() - ending.length(), ending.length(), ending) == 0;
+
+ return false;
+ }
+
+ /**
+ * Helper function for GG home resolution. Checks whether certain folders
+ * exist in the path. Optionally goes upwards in directory hierarchy.
+ *
+ * @param path Path to evaluate.
+ * @param up Whether to go upwards.
+ * @res Resolution result.
+ * @return Resolved directory.
+ */
+ std::string ResolveGridGainHome0(const std::string& path, bool up, bool* res)
+ {
+ DWORD attrs = GetFileAttributesA(path.c_str());
+
+ if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
+ {
+ // Remove trailing slashes, otherwise we will have an infinite loop.
+ std::string path0 = path;
+
+ while (true) {
+ char lastChar = *path0.rbegin();
+
+ if (lastChar == '/' || lastChar == '\\' || lastChar == ' ') {
+ size_t off = path0.find_last_of(lastChar);
+
+ path0.erase(off, 1);
+ }
+ else
+ break;
+ }
+
+ std::string binStr = path0 + PROBE_BIN;
+ DWORD binAttrs = GetFileAttributesA(binStr.c_str());
+
+ std::string examplesStr = path0 + PROBE_EXAMPLES;
+ DWORD examplesAttrs = GetFileAttributesA(examplesStr.c_str());
+
+ if (binAttrs != INVALID_FILE_ATTRIBUTES && (binAttrs & FILE_ATTRIBUTE_DIRECTORY) &&
+ examplesAttrs != INVALID_FILE_ATTRIBUTES && (examplesAttrs & FILE_ATTRIBUTE_DIRECTORY))
+ {
+ SetBoolResult(true, res);
+ return std::string(path0);
+ }
+
+ if (up)
+ {
+ // Evaluate parent directory.
+ size_t slashPos = path0.find_last_of("/\\");
+
+ if (slashPos != std::string::npos)
+ {
+ std::string parent = path0.substr(0, slashPos);
+
+ return ResolveGridGainHome0(parent, true, res);
+ }
+ }
+ }
+
+ SetBoolResult(false, res);
+
+ return std::string();
+ }
+
+ /**
+ * Create classpath picking JARs from the given path.
+ *
+ * @path Path.
+ * @return Classpath;
+ */
+ std::string ClasspathJars(const std::string& path)
+ {
+ std::string searchPath = path + "\\*.jar";
+
+ std::string res = std::string();
+
+ WIN32_FIND_DATAA findData;
+
+ HANDLE hnd = FindFirstFileA(searchPath.c_str(), &findData);
+
+ if (hnd != INVALID_HANDLE_VALUE)
+ {
+ do
+ {
+ res.append(path);
+ res.append("\\");
+ res.append(findData.cFileName);
+ res.append(";");
+ } while (FindNextFileA(hnd, &findData) != 0);
+
+ FindClose(hnd);
+ }
+
+ return res;
+ }
+
+ /**
+ * Create classpath picking compiled classes from the given path.
+ *
+ * @path Path.
+ * @return Classpath;
+ */
+ std::string ClasspathExploded(const std::string& path, bool down)
+ {
+ std::string res = std::string();
+
+ if (FileExists(path))
+ {
+ // 1. Append "target\classes".
+ std::string classesPath = path + "\\target\\classes";
+
+ if (FileExists(classesPath)) {
+ res.append(classesPath);
+ res.append(";");
+ }
+
+ // 2. Append "target\test-classes"
+ std::string testClassesPath = path + "\\target\\test-classes";
+
+ if (FileExists(testClassesPath)) {
+ res.append(testClassesPath);
+ res.append(";");
+ }
+
+ // 3. Append "target\libs"
+ std::string libsPath = path + "\\target\\libs";
+
+ if (FileExists(libsPath)) {
+ std::string libsCp = ClasspathJars(libsPath);
+ res.append(libsCp);
+ }
+
+ // 4. Do the same for child if needed.
+ if (down)
+ {
+ std::string searchPath = path + "\\*";
+
+ WIN32_FIND_DATAA findData;
+
+ HANDLE hnd = FindFirstFileA(searchPath.c_str(), &findData);
+
+ if (hnd != INVALID_HANDLE_VALUE)
+ {
+ do
+ {
+ if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+ {
+ std::string childPath = findData.cFileName;
+
+ if (childPath.compare(".") != 0 &&
+ childPath.compare("..") != 0)
+ {
+ std::string childCp =
+ ClasspathExploded(path + "\\" + childPath, false);
+
+ res.append(childCp);
+ }
+ }
+ } while (FindNextFileA(hnd, &findData) != 0);
+
+ FindClose(hnd);
+ }
+ }
+ }
+
+ return res;
+ }
+
+ /**
+ * Helper function to create classpath based on GridGain home directory.
+ *
+ * @param home Home directory; expected to be valid.
+ * @param forceTest Force test classpath.
+ */
+ std::string CreateGridGainHomeClasspath(const std::string& home, bool forceTest)
+ {
+ std::string res = std::string();
+
+ // 1. Add exploded test directories.
+ if (forceTest)
+ {
+ std::string examplesPath = home + "\\examples";
+ std::string examplesCp = ClasspathExploded(examplesPath, true);
+ res.append(examplesCp);
+
+ std::string modulesPath = home + "\\modules";
+ std::string modulesCp = ClasspathExploded(modulesPath, true);
+ res.append(modulesCp);
+
+ std::string igniteExamplesPath = home + "\\..\\incubator-ignite\\examples";
+ std::string igniteExamplesCp = ClasspathExploded(igniteExamplesPath, true);
+ res.append(igniteExamplesCp);
+
+ std::string igniteModulesPath = home + "\\..\\incubator-ignite\\modules";
+ std::string igniteModulesCp = ClasspathExploded(igniteModulesPath, true);
+ res.append(igniteModulesCp);
+ }
+
+ // 2. Add regular jars from "libs" folder excluding "optional".
+ std::string libsPath = home + "\\libs";
+
+ if (FileExists(libsPath))
+ {
+ res.append(ClasspathJars(libsPath));
+
+ // Append inner directories.
+ std::string libsSearchPath = libsPath + "\\*";
+
+ WIN32_FIND_DATAA libsFindData;
+
+ HANDLE libsHnd = FindFirstFileA(libsSearchPath.c_str(), &libsFindData);
+
+ if (libsHnd != INVALID_HANDLE_VALUE)
+ {
+ do
+ {
+ if (libsFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+ {
+ std::string libsChildPath = libsFindData.cFileName;
+
+ if (libsChildPath.compare(".") != 0 &&
+ libsChildPath.compare("..") != 0 &&
+ libsChildPath.compare("optional") != 0) {
+ std::string libsFolder = libsPath + "\\" + libsChildPath;
+
+ res.append(ClasspathJars(libsFolder));
+ }
+ }
+ } while (FindNextFileA(libsHnd, &libsFindData) != 0);
+
+ FindClose(libsHnd);
+ }
+ }
+
+ // 3. Return.
+ return res;
+ }
+
+ char* CopyChars(const char* val)
+ {
+ if (val) {
+ size_t len = strlen(val);
+ char* dest = new char[len + 1];
+ strcpy(dest, val);
+ *(dest + len) = 0;
+ return dest;
+ }
+ else
+ return NULL;
+ }
+
+ void ReleaseChars(char* val)
+ {
+ if (val)
+ delete[] val;
+ }
+
+ std::string GetEnv(const std::string& name, bool* found)
+ {
+ char res0[32767];
+
+ DWORD envRes = GetEnvironmentVariableA(name.c_str(), res0, 32767);
+
+ if (envRes != 0)
+ {
+ SetBoolResult(true, found);
+
+ return std::string(res0);
+ }
+ else
+ {
+ SetBoolResult(false, found);
+
+ return std::string();
+ }
+ }
+
+ bool FileExists(const std::string& path)
+ {
+ WIN32_FIND_DATAA findres;
+
+ HANDLE hnd = FindFirstFileA(path.c_str(), &findres);
+
+ if (hnd == INVALID_HANDLE_VALUE)
+ return false;
+ else
+ {
+ FindClose(hnd);
+
+ return true;
+ }
+ }
+
+ std::string FindJvmLibrary(const std::string* path, bool* found)
+ {
+ SetBoolResult(true, found); // Optimistically assume that we will find it.
+
+ if (path) {
+ // If path is provided explicitly, then check only it.
+ if (FileExists(*path))
+ return std::string(path->data());
+ }
+ else
+ {
+ bool javaEnvFound;
+ std::string javaEnv = GetEnv(JAVA_HOME, &javaEnvFound);
+
+ if (javaEnvFound)
+ {
+ std::string javaDll = javaEnv + JAVA_DLL;
+
+ if (FileExists(javaDll))
+ return std::string(javaDll);
+ }
+ }
+
+ *found = false;
+
+ return std::string();
+ }
+
+ bool LoadJvmLibrary(const std::string& path)
+ {
+ HMODULE mod = LoadLibraryA(path.c_str());
+
+ return mod != NULL;
+ }
+
+ std::string ResolveGridGainHome(const std::string* path, bool* found)
+ {
+ if (path)
+ // 1. Check passed argument.
+ return ResolveGridGainHome0(*path, false, found);
+ else
+ {
+ // 2. Check environment variable.
+ bool envFound;
+ std::string env = GetEnv(GRIDGAIN_HOME, &envFound);
+
+ if (envFound)
+ return ResolveGridGainHome0(env, false, found);
+
+ // 3. Check current work dir.
+ const DWORD curDirLen = GetCurrentDirectory(0, NULL);
+
+ char* curDir = new char[curDirLen];
+
+ GetCurrentDirectoryA(curDirLen, curDir);
+
+ std::string curDirStr = curDir;
+
+ delete[] curDir;
+
+ return ResolveGridGainHome0(curDirStr, true, found);
+ }
+ }
+
+ std::string CreateGridGainClasspath(const std::string* usrCp, const std::string* home)
+ {
+ bool forceTest = false;
+
+ if (home)
+ {
+ bool envFound;
+ std::string env = GetEnv(GRIDGAIN_NATIVE_TEST_CLASSPATH, &envFound);
+
+ forceTest = envFound && env.compare("true") == 0;
+ }
+
+ return CreateGridGainClasspath(usrCp, home, forceTest);
+ }
+
+ std::string CreateGridGainClasspath(const std::string* usrCp, const std::string* home, bool forceTest)
+ {
+ // 1. Append user classpath if it exists.
+ std::string cp = std::string();
+
+ if (usrCp)
+ {
+ cp.append(*usrCp);
+
+ if (*cp.rbegin() != ';')
+ cp.append(";");
+ }
+
+ // 2. Append home classpath if home is defined.
+ if (home)
+ {
+ std::string homeCp = CreateGridGainHomeClasspath(*home, forceTest);
+
+ cp.append(homeCp);
+ }
+
+ // 3. Return.
+ return cp;
+ }
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/project/README.TXT
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/project/README.TXT b/modules/platform/src/main/cpp/core/project/README.TXT
new file mode 100644
index 0000000..97f4c64
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/project/README.TXT
@@ -0,0 +1 @@
+Contains IDE projects artifacts.
http://git-wip-us.apache.org/repos/asf/ignite/blob/1e18fa32/modules/platform/src/main/cpp/core/project/vs/README.TXT
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/project/vs/README.TXT b/modules/platform/src/main/cpp/core/project/vs/README.TXT
new file mode 100644
index 0000000..f4fb456
--- /dev/null
+++ b/modules/platform/src/main/cpp/core/project/vs/README.TXT
@@ -0,0 +1 @@
+Contains Visual Studio project artifacts.
\ No newline at end of file