http://git-wip-us.apache.org/repos/asf/ignite/blob/58a665aa/modules/platform/src/main/cpp/core/include/ignite/portable/portable_type.h ---------------------------------------------------------------------- diff --git a/modules/platform/src/main/cpp/core/include/ignite/portable/portable_type.h b/modules/platform/src/main/cpp/core/include/ignite/portable/portable_type.h new file mode 100644 index 0000000..fb086ef --- /dev/null +++ b/modules/platform/src/main/cpp/core/include/ignite/portable/portable_type.h @@ -0,0 +1,293 @@ +/* + * 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. + */ + +#ifndef _IGNITE_PORTABLE_TYPE +#define _IGNITE_PORTABLE_TYPE + +#include <stdint.h> + +#include <ignite/common/common.h> + +#include "ignite/ignite_error.h" + +/** + * Start portable type definition. + */ +#define IGNITE_PORTABLE_TYPE_START(T) \ +template<> \ +struct PortableType<T> \ +{ + +/** + * End portable type definition. + */ +#define IGNITE_PORTABLE_TYPE_END \ +}; + +/** + * Implementation of GetTypeId() which returns predefined constant. + */ +#define IGNITE_PORTABLE_GET_TYPE_ID_AS_CONST(id) \ +int32_t GetTypeId() \ +{ \ + return id; \ +} + +/** + * Implementation of GetTypeId() which returns hash of passed type name. + */ +#define IGNITE_PORTABLE_GET_TYPE_ID_AS_HASH(typeName) \ +int32_t GetTypeId() \ +{ \ + return GetPortableStringHashCode(#typeName); \ +} + +/** + * Implementation of GetTypeName() which returns type name as is. + */ +#define IGNITE_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 IGNITE_PORTABLE_GET_FIELD_ID_AS_HASH \ +int32_t GetFieldId(const char* name) \ +{ \ + return GetPortableStringHashCode(name); \ +} + +/** + * Implementation of GetHashCode() function which always returns 0. + */ +#define IGNITE_PORTABLE_GET_HASH_CODE_ZERO(T) \ +int32_t GetHashCode(const T& obj) \ +{ \ + return 0; \ +} + +/** + * Implementation of IsNull() function which always returns false. + */ +#define IGNITE_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 IGNITE_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 IGNITE_PORTABLE_GET_NULL_DEFAULT_CTOR(T) \ +T GetNull() \ +{ \ + return T(); \ +} + +/** + * Implementation of GetNull() function which returns NULL pointer. + */ +#define IGNITE_PORTABLE_GET_NULL_NULLPTR(T) \ +T GetNull() \ +{ \ + return NULL; \ +} + +namespace ignite +{ + 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() + { + IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "GetTypeId function is not defined for portable type."); + } + + /** + * Get portable object type name. + * + * @return Type name. + */ + std::string GetTypeName() + { + IGNITE_ERROR_1(IgniteError::IGNITE_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) + { + IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Write function is not defined for portable type."); + } + + /** + * Read portable object. + * + * @param reader Reader. + * @return Object. + */ + T Read(PortableReader& reader) + { + IGNITE_ERROR_1(IgniteError::IGNITE_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() + { + IGNITE_ERROR_1(IgniteError::IGNITE_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/58a665aa/modules/platform/src/main/cpp/core/include/ignite/portable/portable_writer.h ---------------------------------------------------------------------- diff --git a/modules/platform/src/main/cpp/core/include/ignite/portable/portable_writer.h b/modules/platform/src/main/cpp/core/include/ignite/portable/portable_writer.h new file mode 100644 index 0000000..5dc9494 --- /dev/null +++ b/modules/platform/src/main/cpp/core/include/ignite/portable/portable_writer.h @@ -0,0 +1,335 @@ +/* + * 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. + */ + +#ifndef _IGNITE_PORTABLE_WRITER +#define _IGNITE_PORTABLE_WRITER + +#include <string> +#include <stdint.h> + +#include <ignite/common/common.h> + +#include "ignite/portable/portable_raw_writer.h" + +namespace ignite +{ + namespace portable + { + /** + * Portable writer. + */ + class IGNITE_IMPORT_EXPORT PortableWriter + { + public: + /** + * Constructor. + * + * @param impl Implementation. + */ + PortableWriter(ignite::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, IGNITE_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, ignite::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, IGNITE_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, ignite::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. */ + ignite::impl::portable::PortableWriterImpl* impl; + }; + } +} + +#endif \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/58a665aa/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..2ee13eff --- /dev/null +++ b/modules/platform/src/main/cpp/core/os/linux/include/Makefile.am @@ -0,0 +1,20 @@ +## +## 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. +## + +ACLOCAL_AMFLAGS = "-Im4" + +nobase_include_HEADERS = ignite/impl/utils.h http://git-wip-us.apache.org/repos/asf/ignite/blob/58a665aa/modules/platform/src/main/cpp/core/os/linux/include/ignite/impl/utils.h ---------------------------------------------------------------------- diff --git a/modules/platform/src/main/cpp/core/os/linux/include/ignite/impl/utils.h b/modules/platform/src/main/cpp/core/os/linux/include/ignite/impl/utils.h new file mode 100644 index 0000000..8bbd2f7 --- /dev/null +++ b/modules/platform/src/main/cpp/core/os/linux/include/ignite/impl/utils.h @@ -0,0 +1,155 @@ +/* + * 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. + */ + +#ifndef _IGNITE_UTILS +#define _IGNITE_UTILS + +#include <cstring> +#include <string> + +#include <ignite/common/common.h> + +#ifdef IGNITE_FRIEND + #define IGNITE_FRIEND_EXPORT IGNITE_EXPORT +#else + #define IGNITE_FRIEND_EXPORT +#endif + +namespace ignite +{ + namespace impl + { + namespace utils + { + /** + * Copy characters. + * + * @param val Value. + * @return Result. + */ + IGNITE_FRIEND_EXPORT char* CopyChars(const char* val); + + /** + * Release characters. + * + * @param val Value. + */ + IGNITE_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. + */ + IGNITE_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. + */ + IGNITE_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. + */ + IGNITE_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. + */ + IGNITE_FRIEND_EXPORT bool LoadJvmLibrary(const std::string& path); + + /** + * Resolve IGNITE_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, + * IGNITE_HOME is considered resolved. + * + * @param path Optional path to evaluate. + * @param found Whether IGNITE_HOME home was found. + * @return Resolved GG home. + */ + IGNITE_FRIEND_EXPORT std::string ResolveIgniteHome(const std::string* path, bool* found); + + /** + * Create Ignite classpath based on user input and home directory. + * + * @param usrCp User's classpath. + * @param home Ignite home directory. + * @return Classpath. + */ + IGNITE_FRIEND_EXPORT std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home); + + /** + * Create Ignite classpath based on user input and home directory. + * + * @param usrCp User's classpath. + * @param home Ignite home directory. + * @param test Whether test classpath must be used. + * @return Classpath. + */ + IGNITE_FRIEND_EXPORT std::string CreateIgniteClasspath(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 IGNITE_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/58a665aa/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..ec45eb6 --- /dev/null +++ b/modules/platform/src/main/cpp/core/os/linux/src/impl/utils.cpp @@ -0,0 +1,439 @@ +/* + * 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 <sys/stat.h> +#include <dirent.h> +#include <dlfcn.h> + +#include "ignite/impl/utils.h" + +namespace ignite +{ + namespace impl + { + namespace utils + { + const char* JAVA_HOME = "JAVA_HOME"; + const char* JAVA_DLL = "/jre/lib/amd64/server/libjvm.so"; + + const char* IGNITE_HOME = "IGNITE_HOME"; + + const char* PROBE_BIN = "/bin"; + const char* PROBE_EXAMPLES = "/examples"; + + const char* IGNITE_NATIVE_TEST_CLASSPATH = "IGNITE_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 ResolveIgniteHome0(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 ResolveIgniteHome0(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 Ignite home directory. + * + * @param home Home directory; expected to be valid. + * @param forceTest Force test classpath. + */ + std::string CreateIgniteHomeClasspath(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); + } + + // 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 ResolveIgniteHome(const std::string* path, bool* found) + { + if (path) + // 1. Check passed argument. + return ResolveIgniteHome0(*path, false, found); + else + { + // 2. Check environment variable. + bool envFound; + std::string env = GetEnv(IGNITE_HOME, &envFound); + + if (envFound) + return ResolveIgniteHome0(env, false, found); + } + + SetBoolResult(false, found); + + return std::string(); + } + + std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home) + { + bool forceTest = false; + + if (home) + { + bool envFound; + std::string env = GetEnv(IGNITE_NATIVE_TEST_CLASSPATH, &envFound); + + forceTest = envFound && env.compare("true") == 0; + } + + return CreateIgniteClasspath(usrCp, home, forceTest); + } + + std::string CreateIgniteClasspath(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 = CreateIgniteHomeClasspath(*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/58a665aa/modules/platform/src/main/cpp/core/os/win/include/ignite/impl/utils.h ---------------------------------------------------------------------- diff --git a/modules/platform/src/main/cpp/core/os/win/include/ignite/impl/utils.h b/modules/platform/src/main/cpp/core/os/win/include/ignite/impl/utils.h new file mode 100644 index 0000000..08e76ee --- /dev/null +++ b/modules/platform/src/main/cpp/core/os/win/include/ignite/impl/utils.h @@ -0,0 +1,155 @@ +/* + * 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. + */ + +#ifndef _IGNITE_UTILS +#define _IGNITE_UTILS + +#include <cstring> +#include <string> + +#include <ignite/common/common.h> + +#ifdef IGNITE_FRIEND + #define IGNITE_FRIEND_EXPORT IGNITE_EXPORT +#else + #define IGNITE_FRIEND_EXPORT +#endif + +namespace ignite +{ + namespace impl + { + namespace utils + { + /** + * Copy characters. + * + * @param val Value. + * @return Result. + */ + IGNITE_FRIEND_EXPORT char* CopyChars(const char* val); + + /** + * Release characters. + * + * @param val Value. + */ + IGNITE_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. + */ + IGNITE_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. + */ + IGNITE_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. + */ + IGNITE_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. + */ + IGNITE_FRIEND_EXPORT bool LoadJvmLibrary(const std::string& path); + + /** + * Resolve IGNITE_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, + * IGNITE_HOME is considered resolved. + * + * @param path Optional path to evaluate. + * @param found Whether IGNITE_HOME home was found. + * @return Resolved GG home. + */ + IGNITE_FRIEND_EXPORT std::string ResolveIgniteHome(const std::string* path, bool* found); + + /** + * Create Ignite classpath based on user input and home directory. + * + * @param usrCp User's classpath. + * @param home Ignite home directory. + * @return Classpath. + */ + IGNITE_FRIEND_EXPORT std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home); + + /** + * Create Ignite classpath based on user input and home directory. + * + * @param usrCp User's classpath. + * @param home Ignite home directory. + * @param test Whether test classpath must be used. + * @return Classpath. + */ + IGNITE_FRIEND_EXPORT std::string CreateIgniteClasspath(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 IGNITE_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/58a665aa/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..5a450c3 --- /dev/null +++ b/modules/platform/src/main/cpp/core/os/win/src/impl/utils.cpp @@ -0,0 +1,453 @@ +/* + * 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 <windows.h> + +#include "ignite/impl/utils.h" + +namespace ignite +{ + namespace impl + { + namespace utils + { + const char* JAVA_HOME = "JAVA_HOME"; + const char* JAVA_DLL = "\\jre\\bin\\server\\jvm.dll"; + + const char* IGNITE_HOME = "IGNITE_HOME"; + + const char* PROBE_BIN = "\\bin"; + const char* PROBE_EXAMPLES = "\\examples"; + + const char* IGNITE_NATIVE_TEST_CLASSPATH = "IGNITE_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 ResolveIgniteHome0(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 ResolveIgniteHome0(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 Ignite home directory. + * + * @param home Home directory; expected to be valid. + * @param forceTest Force test classpath. + */ + std::string CreateIgniteHomeClasspath(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); + } + + // 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 ResolveIgniteHome(const std::string* path, bool* found) + { + if (path) + // 1. Check passed argument. + return ResolveIgniteHome0(*path, false, found); + else + { + // 2. Check environment variable. + bool envFound; + std::string env = GetEnv(IGNITE_HOME, &envFound); + + if (envFound) + return ResolveIgniteHome0(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 ResolveIgniteHome0(curDirStr, true, found); + } + } + + std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home) + { + bool forceTest = false; + + if (home) + { + bool envFound; + std::string env = GetEnv(IGNITE_NATIVE_TEST_CLASSPATH, &envFound); + + forceTest = envFound && env.compare("true") == 0; + } + + return CreateIgniteClasspath(usrCp, home, forceTest); + } + + std::string CreateIgniteClasspath(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 = CreateIgniteHomeClasspath(*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/58a665aa/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/58a665aa/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 http://git-wip-us.apache.org/repos/asf/ignite/blob/58a665aa/modules/platform/src/main/cpp/core/project/vs/core.vcxproj ---------------------------------------------------------------------- diff --git a/modules/platform/src/main/cpp/core/project/vs/core.vcxproj b/modules/platform/src/main/cpp/core/project/vs/core.vcxproj new file mode 100644 index 0000000..58fa283 --- /dev/null +++ b/modules/platform/src/main/cpp/core/project/vs/core.vcxproj @@ -0,0 +1,272 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003";> + <ItemGroup Label="ProjectConfigurations"> + <ProjectConfiguration Include="Debug|Win32"> + <Configuration>Debug</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Debug|x64"> + <Configuration>Debug</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|Win32"> + <Configuration>Release</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|x64"> + <Configuration>Release</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + </ItemGroup> + <PropertyGroup Label="Globals"> + <ProjectGuid>{E2DEA693-F2EA-43C2-A813-053378F6E4DB}</ProjectGuid> + <RootNamespace>core</RootNamespace> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <UseDebugLibraries>true</UseDebugLibraries> + <PlatformToolset>v100</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + <WholeProgramOptimization>true</WholeProgramOptimization> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <UseDebugLibraries>true</UseDebugLibraries> + <PlatformToolset>v100</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + <WholeProgramOptimization>true</WholeProgramOptimization> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <UseDebugLibraries>false</UseDebugLibraries> + <PlatformToolset>v100</PlatformToolset> + <WholeProgramOptimization>true</WholeProgramOptimization> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <UseDebugLibraries>false</UseDebugLibraries> + <PlatformToolset>v100</PlatformToolset> + <WholeProgramOptimization>true</WholeProgramOptimization> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> + <ImportGroup Label="ExtensionSettings"> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <PropertyGroup Label="UserMacros" /> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <TargetName>ignite.core</TargetName> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <TargetName>ignite.core</TargetName> + <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir> + <IntDir>$(Platform)\$(Configuration)\</IntDir> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <TargetName>ignite.core</TargetName> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <TargetName>ignite.core</TargetName> + <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir> + <IntDir>$(Platform)\$(Configuration)\</IntDir> + </PropertyGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <ClCompile> + <WarningLevel>Level3</WarningLevel> + <Optimization>Disabled</Optimization> + <SDLCheck>false</SDLCheck> + <AdditionalIncludeDirectories>$(JAVA_HOME)\include;$(JAVA_HOME)\include\win32;$(ProjectDir)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\os\win\include</AdditionalIncludeDirectories> + <InlineFunctionExpansion>Disabled</InlineFunctionExpansion> + <IntrinsicFunctions>false</IntrinsicFunctions> + <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed> + <OmitFramePointers>false</OmitFramePointers> + <StringPooling>true</StringPooling> + <MinimalRebuild>false</MinimalRebuild> + <BasicRuntimeChecks>Default</BasicRuntimeChecks> + <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> + <BufferSecurityCheck>false</BufferSecurityCheck> + <FunctionLevelLinking>true</FunctionLevelLinking> + <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;IGNITE_FRIEND;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <WholeProgramOptimization>false</WholeProgramOptimization> + </ClCompile> + <Link> + <GenerateDebugInformation>true</GenerateDebugInformation> + <AdditionalLibraryDirectories>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <AdditionalDependencies>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OptimizeReferences>false</OptimizeReferences> + <EnableCOMDATFolding>false</EnableCOMDATFolding> + <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> + </Link> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <ClCompile> + <WarningLevel>Level3</WarningLevel> + <Optimization>Disabled</Optimization> + <SDLCheck>false</SDLCheck> + <AdditionalIncludeDirectories>$(JAVA_HOME)\include;$(JAVA_HOME)\include\win32;$(ProjectDir)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\os\win\include</AdditionalIncludeDirectories> + <InlineFunctionExpansion>Disabled</InlineFunctionExpansion> + <IntrinsicFunctions>false</IntrinsicFunctions> + <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed> + <OmitFramePointers>false</OmitFramePointers> + <StringPooling>true</StringPooling> + <MinimalRebuild>false</MinimalRebuild> + <BasicRuntimeChecks>Default</BasicRuntimeChecks> + <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> + <BufferSecurityCheck>false</BufferSecurityCheck> + <FunctionLevelLinking>true</FunctionLevelLinking> + <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;IGNITE_FRIEND;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <WholeProgramOptimization>false</WholeProgramOptimization> + </ClCompile> + <Link> + <GenerateDebugInformation>true</GenerateDebugInformation> + <AdditionalLibraryDirectories>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <AdditionalDependencies>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OptimizeReferences>false</OptimizeReferences> + <EnableCOMDATFolding>false</EnableCOMDATFolding> + <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> + </Link> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <ClCompile> + <WarningLevel>Level3</WarningLevel> + <Optimization>Full</Optimization> + <FunctionLevelLinking>true</FunctionLevelLinking> + <IntrinsicFunctions>true</IntrinsicFunctions> + <SDLCheck>false</SDLCheck> + <AdditionalIncludeDirectories>$(JAVA_HOME)\include;$(JAVA_HOME)\include\win32;$(ProjectDir)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\os\win\include</AdditionalIncludeDirectories> + <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion> + <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed> + <OmitFramePointers>true</OmitFramePointers> + <StringPooling>true</StringPooling> + <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> + <BufferSecurityCheck>false</BufferSecurityCheck> + <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;IGNITE_FRIEND;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + <Link> + <GenerateDebugInformation>true</GenerateDebugInformation> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <OptimizeReferences>true</OptimizeReferences> + <AdditionalLibraryDirectories>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <AdditionalDependencies>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalDependencies)</AdditionalDependencies> + </Link> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <ClCompile> + <WarningLevel>Level3</WarningLevel> + <Optimization>Full</Optimization> + <FunctionLevelLinking>true</FunctionLevelLinking> + <IntrinsicFunctions>true</IntrinsicFunctions> + <SDLCheck>false</SDLCheck> + <AdditionalIncludeDirectories>$(JAVA_HOME)\include;$(JAVA_HOME)\include\win32;$(ProjectDir)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\os\win\include</AdditionalIncludeDirectories> + <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion> + <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed> + <OmitFramePointers>true</OmitFramePointers> + <StringPooling>true</StringPooling> + <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> + <BufferSecurityCheck>false</BufferSecurityCheck> + <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;IGNITE_FRIEND;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + <Link> + <GenerateDebugInformation>true</GenerateDebugInformation> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <OptimizeReferences>true</OptimizeReferences> + <AdditionalLibraryDirectories>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <AdditionalDependencies>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalDependencies)</AdditionalDependencies> + </Link> + </ItemDefinitionGroup> + <ItemGroup> + <ClInclude Include="..\..\include\ignite\cache\cache.h" /> + <ClInclude Include="..\..\include\ignite\cache\cache_entry.h" /> + <ClInclude Include="..\..\include\ignite\cache\cache_peek_mode.h" /> + <ClInclude Include="..\..\include\ignite\cache\query\query.h" /> + <ClInclude Include="..\..\include\ignite\cache\query\query_argument.h" /> + <ClInclude Include="..\..\include\ignite\cache\query\query_cursor.h" /> + <ClInclude Include="..\..\include\ignite\cache\query\query_scan.h" /> + <ClInclude Include="..\..\include\ignite\cache\query\query_sql.h" /> + <ClInclude Include="..\..\include\ignite\cache\query\query_text.h" /> + <ClInclude Include="..\..\include\ignite\ignite.h" /> + <ClInclude Include="..\..\include\ignite\ignite_configuration.h" /> + <ClInclude Include="..\..\include\ignite\ignite_error.h" /> + <ClInclude Include="..\..\include\ignite\ignition.h" /> + <ClInclude Include="..\..\include\ignite\guid.h" /> + <ClInclude Include="..\..\include\ignite\impl\cache\cache_impl.h" /> + <ClInclude Include="..\..\include\ignite\impl\cache\query\query_impl.h" /> + <ClInclude Include="..\..\include\ignite\impl\ignite_environment.h" /> + <ClInclude Include="..\..\include\ignite\impl\ignite_impl.h" /> + <ClInclude Include="..\..\include\ignite\impl\handle_registry.h" /> + <ClInclude Include="..\..\include\ignite\impl\interop\interop.h" /> + <ClInclude Include="..\..\include\ignite\impl\interop\interop_input_stream.h" /> + <ClInclude Include="..\..\include\ignite\impl\interop\interop_memory.h" /> + <ClInclude Include="..\..\include\ignite\impl\interop\interop_output_stream.h" /> + <ClInclude Include="..\..\include\ignite\impl\operations.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_common.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_id_resolver.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_metadata_handler.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_metadata_manager.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_metadata_snapshot.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_metadata_updater.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_metadata_updater_impl.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_reader_impl.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_utils.h" /> + <ClInclude Include="..\..\include\ignite\impl\portable\portable_writer_impl.h" /> + <ClInclude Include="..\..\include\ignite\portable\portable.h" /> + <ClInclude Include="..\..\include\ignite\portable\portable_consts.h" /> + <ClInclude Include="..\..\include\ignite\portable\portable_containers.h" /> + <ClInclude Include="..\..\include\ignite\portable\portable_type.h" /> + <ClInclude Include="..\..\include\ignite\portable\portable_raw_reader.h" /> + <ClInclude Include="..\..\include\ignite\portable\portable_raw_writer.h" /> + <ClInclude Include="..\..\include\ignite\portable\portable_reader.h" /> + <ClInclude Include="..\..\include\ignite\portable\portable_writer.h" /> + <ClInclude Include="..\..\os\win\include\ignite\impl\utils.h" /> + </ItemGroup> + <ItemGroup> + <ClCompile Include="..\..\os\win\src\impl\utils.cpp" /> + <ClCompile Include="..\..\src\ignite.cpp" /> + <ClCompile Include="..\..\src\ignite_error.cpp" /> + <ClCompile Include="..\..\src\ignition.cpp" /> + <ClCompile Include="..\..\src\guid.cpp" /> + <ClCompile Include="..\..\src\impl\cache\cache_impl.cpp" /> + <ClCompile Include="..\..\src\impl\cache\query\query_impl.cpp" /> + <ClCompile Include="..\..\src\impl\ignite_environment.cpp" /> + <ClCompile Include="..\..\src\impl\ignite_impl.cpp" /> + <ClCompile Include="..\..\src\impl\handle_registry.cpp" /> + <ClCompile Include="..\..\src\impl\interop\interop_input_stream.cpp" /> + <ClCompile Include="..\..\src\impl\interop\interop_memory.cpp" /> + <ClCompile Include="..\..\src\impl\interop\interop_output_stream.cpp" /> + <ClCompile Include="..\..\src\impl\portable\portable_metadata_handler.cpp" /> + <ClCompile Include="..\..\src\impl\portable\portable_metadata_manager.cpp" /> + <ClCompile Include="..\..\src\impl\portable\portable_metadata_snapshot.cpp" /> + <ClCompile Include="..\..\src\impl\portable\portable_metadata_updater.cpp" /> + <ClCompile Include="..\..\src\impl\portable\portable_metadata_updater_impl.cpp" /> + <ClCompile Include="..\..\src\impl\portable\portable_reader_impl.cpp" /> + <ClCompile Include="..\..\src\impl\portable\portable_utils.cpp" /> + <ClCompile Include="..\..\src\impl\portable\portable_writer_impl.cpp" /> + <ClCompile Include="..\..\src\portable\portable_containers.cpp" /> + <ClCompile Include="..\..\src\portable\portable_type.cpp" /> + <ClCompile Include="..\..\src\portable\portable_raw_reader.cpp" /> + <ClCompile Include="..\..\src\portable\portable_raw_writer.cpp" /> + <ClCompile Include="..\..\src\portable\portable_reader.cpp" /> + <ClCompile Include="..\..\src\portable\portable_writer.cpp" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\common\project\vs\common.vcxproj"> + <Project>{4f7e4917-4612-4b96-9838-025711ade391}</Project> + </ProjectReference> + </ItemGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> + <ImportGroup Label="ExtensionTargets"> + </ImportGroup> +</Project> \ No newline at end of file
