Change "foo.h" to "foo.hpp"

tightdb_jni/src/TableSpecUtil.cpp

@@ -1,13 +1,13 @@
-#include "util.h"
-#include "TableSpecUtil.h"
-#include "columntypeutil.h"
+#include "util.hpp"
+#include "TableSpecUtil.hpp"
+#include "columntypeutil.hpp"
 
 using namespace tightdb;
 
-jclass GetClassTableSpec(JNIEnv* env) 
+jclass GetClassTableSpec(JNIEnv* env)
 {
-	static jclass myClass = GetClass(env, "com/tightdb/TableSpec");
-	return myClass;
+    static jclass myClass = GetClass(env, "com/tightdb/TableSpec");
+    return myClass;
 }
 
 jmethodID GetTableSpecMethodID(JNIEnv* env, const char* methodStr, const char* typeStr)
@@ -26,41 +26,41 @@ jmethodID GetTableSpecMethodID(JNIEnv* env, const char* methodStr, const char* t
 
 jlong Java_com_tightdb_TableSpec_getColumnCount(JNIEnv* env, jobject jTableSpec)
 {
-	static jmethodID jGetColumnCountMethodId = GetTableSpecMethodID(env, "getColumnCount", "()J");
-	if (jGetColumnCountMethodId)
-	    return env->CallLongMethod(jTableSpec, jGetColumnCountMethodId);
+    static jmethodID jGetColumnCountMethodId = GetTableSpecMethodID(env, "getColumnCount", "()J");
+    if (jGetColumnCountMethodId)
+        return env->CallLongMethod(jTableSpec, jGetColumnCountMethodId);
     return 0;
 }
 
 jobject Java_com_tightdb_TableSpec_getColumnType(JNIEnv* env, jobject jTableSpec, jlong columnIndex)
 {
-	static jmethodID jGetColumnTypeMethodId = GetTableSpecMethodID(env, "getColumnType", "(J)Lcom/tightdb/ColumnType;");
-	if (jGetColumnTypeMethodId)
+    static jmethodID jGetColumnTypeMethodId = GetTableSpecMethodID(env, "getColumnType", "(J)Lcom/tightdb/ColumnType;");
+    if (jGetColumnTypeMethodId)
         return env->CallObjectMethod(jTableSpec, jGetColumnTypeMethodId, columnIndex);
     return NULL;
 }
 
 jstring Java_com_tightdb_TableSpec_getColumnName(JNIEnv* env, jobject jTableSpec, jlong columnIndex)
 {
-	static jmethodID jGetColumnNameMethodId = GetTableSpecMethodID(env, "getColumnName", "(J)Ljava/lang/String;");
-	if (jGetColumnNameMethodId)
-    	return (jstring)env->CallObjectMethod(jTableSpec, jGetColumnNameMethodId, columnIndex);
-	return NULL; 
+    static jmethodID jGetColumnNameMethodId = GetTableSpecMethodID(env, "getColumnName", "(J)Ljava/lang/String;");
+    if (jGetColumnNameMethodId)
+        return (jstring)env->CallObjectMethod(jTableSpec, jGetColumnNameMethodId, columnIndex);
+    return NULL;
 }
 
 jobject Java_com_tightdb_TableSpec_getTableSpec(JNIEnv* env, jobject jTableSpec, jlong columnIndex)
 {
-	static jmethodID jGetTableSpecMethodId = GetTableSpecMethodID(env, "getSubtableSpec", "(J)Lcom/tightdb/TableSpec;");
-	if (jGetTableSpecMethodId)
+    static jmethodID jGetTableSpecMethodId = GetTableSpecMethodID(env, "getSubtableSpec", "(J)Lcom/tightdb/TableSpec;");
+    if (jGetTableSpecMethodId)
         return env->CallObjectMethod(jTableSpec, jGetTableSpecMethodId, columnIndex);
     return NULL;
 }
 
 jlong Java_com_tightdb_TableSpec_getColumnIndex(JNIEnv* env, jobject jTableSpec, jstring columnName)
 {
-	static jmethodID jGetColumnIndexMethodId = GetTableSpecMethodID(env, "getColumnIndex", "(Ljava/lang/String;)J");
-	if (jGetColumnIndexMethodId)
-	    return env->CallLongMethod(jTableSpec, jGetColumnIndexMethodId, columnName);
+    static jmethodID jGetColumnIndexMethodId = GetTableSpecMethodID(env, "getColumnIndex", "(Ljava/lang/String;)J");
+    if (jGetColumnIndexMethodId)
+        return env->CallLongMethod(jTableSpec, jGetColumnIndexMethodId, columnName);
     return 0;
 }
 
@@ -70,7 +70,7 @@ void updateSpecFromJSpec(JNIEnv* env, Spec& spec, jobject jTableSpec)
     for (jlong i = 0; i < columnCount; ++i) {
         jstring jColumnName = Java_com_tightdb_TableSpec_getColumnName(env, jTableSpec, i);
         JStringAccessor columnName(env, jColumnName);
-        if (!columnName) 
+        if (!columnName)
             return;
 
         jobject jColumnType   = Java_com_tightdb_TableSpec_getColumnType(env, jTableSpec, i);
@@ -88,23 +88,23 @@ void updateSpecFromJSpec(JNIEnv* env, Spec& spec, jobject jTableSpec)
 
 void UpdateJTableSpecFromSpec(JNIEnv* env, const Spec& spec, jobject jTableSpec)
 {
-	static jmethodID jAddColumnMethodId = GetTableSpecMethodID(env, "addColumn", "(ILjava/lang/String;)V");
-	static jmethodID jAddSubtableColumnMethodId = GetTableSpecMethodID(env, "addSubtableColumn", "(Ljava/lang/String;)Lcom/tightdb/TableSpec;");
-	
+    static jmethodID jAddColumnMethodId = GetTableSpecMethodID(env, "addColumn", "(ILjava/lang/String;)V");
+    static jmethodID jAddSubtableColumnMethodId = GetTableSpecMethodID(env, "addSubtableColumn", "(Ljava/lang/String;)Lcom/tightdb/TableSpec;");
+
     if (jAddColumnMethodId == NULL || jAddSubtableColumnMethodId == NULL) {
-		return;
-	}
+        return;
+    }
 
-	size_t columnCount = spec.get_column_count();
-	for(size_t i = 0; i < columnCount; ++i) {
-		DataType colType = spec.get_column_type(i);
-		StringData colName = spec.get_column_name(i);
-		if (colType == type_Table) {
-			jobject jSubTableSpec = env->CallObjectMethod(jTableSpec, jAddSubtableColumnMethodId, to_jstring(env, colName));
-			const Spec& subTableSpec = spec.get_subtable_spec(i);
-			UpdateJTableSpecFromSpec(env, subTableSpec, jSubTableSpec);
-		} else {
-			env->CallVoidMethod(jTableSpec, jAddColumnMethodId, static_cast<jint>(colType), to_jstring(env, colName));
-		}
-	}
+    size_t columnCount = spec.get_column_count();
+    for(size_t i = 0; i < columnCount; ++i) {
+        DataType colType = spec.get_column_type(i);
+        StringData colName = spec.get_column_name(i);
+        if (colType == type_Table) {
+            jobject jSubTableSpec = env->CallObjectMethod(jTableSpec, jAddSubtableColumnMethodId, to_jstring(env, colName));
+            const Spec& subTableSpec = spec.get_subtable_spec(i);
+            UpdateJTableSpecFromSpec(env, subTableSpec, jSubTableSpec);
+        } else {
+            env->CallVoidMethod(jTableSpec, jAddColumnMethodId, static_cast<jint>(colType), to_jstring(env, colName));
+        }
+    }
 }

tightdb_jni/src/TableSpecUtil.h → tightdb_jni/src/TableSpecUtil.hpp

@@ -11,19 +11,19 @@ extern "C" {
 #endif
 
 jlong Java_com_tightdb_TableSpec_getColumnCount(
-	JNIEnv* env, jobject jTableSpec);
+    JNIEnv* env, jobject jTableSpec);
 
 jobject Java_com_tightdb_TableSpec_getColumnType(
-	JNIEnv* env, jobject jTableSpec, jlong columnIndex);
+    JNIEnv* env, jobject jTableSpec, jlong columnIndex);
 
 jstring Java_com_tightdb_TableSpec_getColumnName(
-	JNIEnv* env, jobject jTableSpec, jlong columnIndex);
+    JNIEnv* env, jobject jTableSpec, jlong columnIndex);
 
 jobject Java_com_tightdb_TableSpec_getTableSpec(
-	JNIEnv* env, jobject jTableSpec, jlong columnIndex);
+    JNIEnv* env, jobject jTableSpec, jlong columnIndex);
 
 jlong Java_com_tightdb_TableSpec_getColumnIndex(
-	JNIEnv* env, jobject jTableSpec, jstring columnName);
+    JNIEnv* env, jobject jTableSpec, jstring columnName);
 
 void updateSpecFromJSpec(JNIEnv* env, Spec& spec, jobject jTableSpec);
 void UpdateJTableSpecFromSpec(JNIEnv* env, const Spec& spec, jobject jTableSpec);

tightdb_jni/src/columntypeutil.cpp

@@ -1,5 +1,5 @@
-#include "util.h"
-#include "columntypeutil.h"
+#include "util.hpp"
+#include "columntypeutil.hpp"
 
 
 static jfieldID GetFieldIDColumnType(JNIEnv* env, const char* methodStr, const char* typeStr)
@@ -29,18 +29,18 @@ DataType GetColumnTypeFromJColumnType(JNIEnv* env, jobject jColumnType)
 jobject GetJColumnTypeFromColumnType(JNIEnv* env, DataType columnType)
 {
     TR((env, "jni: Enter GetJColumnTypeFromColumnType(%d)\n", columnType));
-	static jclass jColumnTypeClass = GetClass(env, "com/tightdb/ColumnType");
+    static jclass jColumnTypeClass = GetClass(env, "com/tightdb/ColumnType");
 
-	if (jColumnTypeClass == NULL) {
-	    TR((env, "--class is NULL\n"));
+    if (jColumnTypeClass == NULL) {
+        TR((env, "--class is NULL\n"));
         return NULL;
     }
     TR((env, "---2\n"));
-    
+
     // Couldn't figure out how to create a new enum on Java side and return as object...
     // A workaround in java to not check for the correct ColumnTypeTable works.
     /*
-	jmethodID jColumnTypeConsId2 = env->GetMethodID(jColumnTypeClass, "<init>", "()V");
+    jmethodID jColumnTypeConsId2 = env->GetMethodID(jColumnTypeClass, "<init>", "()V");
     if (jColumnTypeConsId2) {
         TR((env, "-GOT INIT\n"));
         return NULL;
@@ -49,26 +49,26 @@ jobject GetJColumnTypeFromColumnType(JNIEnv* env, DataType columnType)
 
    /*
     jfieldID subtable_id = env->GetStaticFieldID(jColumnTypeClass, "ColumnTypeTable", "LColumnType;");
-	if (!subtable_id) {
+    if (!subtable_id) {
         TR((env, "--subtable_id is NULL\n"));
         return NULL;
     }
-    
+
     jobject jColumnTypeConsId = env->GetStaticObjectField(jColumnTypeClass, subtable_id);
     if (jColumnTypeConsId == NULL) {
         TR((env, "---2.5"));
         ThrowException(env, NoSuchMethod, "ColumnType", "<init>");
-    	return NULL;
-	}
-    return jColumnTypeConsId; 
+        return NULL;
+    }
+    return jColumnTypeConsId;
     */
     TR((env, "---3\n"));
     return NULL;
-	//jobject jColumnType = env->NewObject(jColumnTypeClass, jColumnTypeConsId, 
+    //jobject jColumnType = env->NewObject(jColumnTypeClass, jColumnTypeConsId,
                                        //  static_cast<jint>(columnType));
     //jobject jColumnType = env->NewObject(jColumnTypeClass, jColumnTypeConsId);
-                                         
+
     //TR((env, "jni: New ColumnType %d.\n", columnType));
-	//return jColumnType;
-    
+    //return jColumnType;
+
 }

tightdb_jni/src/com_tightdb_Group.cpp

@@ -1,18 +1,18 @@
-#include "util.h"
-#include "com_tightdb_Group.h"
+#include "util.hpp"
+#include "com_tightdb_Group.hpp"
 
 using namespace tightdb;
 
 JNIEXPORT jlong JNICALL Java_com_tightdb_Group_createNative__(
-	JNIEnv* env, jobject)
+    JNIEnv* env, jobject)
 {
-	Group *ptr = new Group();
+    Group *ptr = new Group();
     TR((env, "Group::createNative(): %x.\n", ptr));
     return reinterpret_cast<jlong>(ptr);
 }
 
 JNIEXPORT jlong JNICALL Java_com_tightdb_Group_createNative__Ljava_lang_String_2Z(
-	JNIEnv* env, jobject, jstring jFileName, jboolean readOnly)
+    JNIEnv* env, jobject, jstring jFileName, jboolean readOnly)
 {
     TR((env, "Group::createNative(file): "));
     const char* fileNameCharPtr = env->GetStringUTFChars(jFileName, NULL);
@@ -39,10 +39,10 @@ JNIEXPORT jlong JNICALL Java_com_tightdb_Group_createNative__Ljava_lang_String_2
 }
 
 JNIEXPORT jlong JNICALL Java_com_tightdb_Group_createNative___3B(
-	JNIEnv* env, jobject, jbyteArray jData)
+    JNIEnv* env, jobject, jbyteArray jData)
 {
     TR((env, "Group::createNative(byteArray): "));
-	jsize byteArrayLength = env->GetArrayLength(jData);
+    jsize byteArrayLength = env->GetArrayLength(jData);
     if (byteArrayLength == 0)
         return 0;
     jbyte* buf = static_cast<jbyte*>(malloc(S(byteArrayLength)*sizeof(jbyte)));
@@ -73,7 +73,7 @@ JNIEXPORT jlong JNICALL Java_com_tightdb_Group_createNative___3B(
 }
 
 JNIEXPORT jlong JNICALL Java_com_tightdb_Group_createNative__Ljava_nio_ByteBuffer_2(
-	JNIEnv* env, jobject, jobject jByteBuffer)
+    JNIEnv* env, jobject, jobject jByteBuffer)
 {
     TR((env, "Group::createNative(binaryData): "));
     BinaryData bin;
@@ -104,21 +104,21 @@ JNIEXPORT jlong JNICALL Java_com_tightdb_Group_createNative__Ljava_nio_ByteBuffe
 }
 
 JNIEXPORT void JNICALL Java_com_tightdb_Group_nativeClose(
-	JNIEnv* env, jobject, jlong nativeGroupPtr)
+    JNIEnv* env, jobject, jlong nativeGroupPtr)
 {
     TR((env, "Group::nativeClose(%x)\n", nativeGroupPtr));
     Group* grp = G(nativeGroupPtr);
     delete grp;
 }
 
 JNIEXPORT jlong JNICALL Java_com_tightdb_Group_nativeSize(
-	JNIEnv*, jobject, jlong nativeGroupPtr)
+    JNIEnv*, jobject, jlong nativeGroupPtr)
 {
     return static_cast<jlong>( G(nativeGroupPtr)->size() );
 }
 
 JNIEXPORT jboolean JNICALL Java_com_tightdb_Group_nativeHasTable(
-	JNIEnv* env, jobject, jlong nativeGroupPtr, jstring jTableName)
+    JNIEnv* env, jobject, jlong nativeGroupPtr, jstring jTableName)
 {
     JStringAccessor tableName(env, jTableName);
     if (tableName) {
@@ -130,13 +130,13 @@ JNIEXPORT jboolean JNICALL Java_com_tightdb_Group_nativeHasTable(
 }
 
 JNIEXPORT jstring JNICALL Java_com_tightdb_Group_nativeGetTableName(
-	JNIEnv* env, jobject, jlong nativeGroupPtr, jint index)
+    JNIEnv* env, jobject, jlong nativeGroupPtr, jint index)
 {
     return to_jstring(env, G(nativeGroupPtr)->get_table_name(index));
 }
 
 JNIEXPORT jlong JNICALL Java_com_tightdb_Group_nativeGetTableNativePtr(
-	JNIEnv *env, jobject, jlong nativeGroupPtr, jstring name)
+    JNIEnv *env, jobject, jlong nativeGroupPtr, jstring name)
 {
     JStringAccessor tableName(env, name);
     if (tableName) {
@@ -148,7 +148,7 @@ JNIEXPORT jlong JNICALL Java_com_tightdb_Group_nativeGetTableNativePtr(
 }
 
 JNIEXPORT void JNICALL Java_com_tightdb_Group_nativeWriteToFile(
-	JNIEnv* env, jobject, jlong nativeGroupPtr, jstring jFileName)
+    JNIEnv* env, jobject, jlong nativeGroupPtr, jstring jFileName)
 {
     const char* fileNameCharPtr = env->GetStringUTFChars(jFileName, NULL);
     if (fileNameCharPtr) {
@@ -165,14 +165,14 @@ JNIEXPORT void JNICALL Java_com_tightdb_Group_nativeWriteToFile(
             // not declared 'noexcept' must be considered as being
             // able to throw anything derived from std::exception.
             ThrowException(env, IOFailed, fileNameCharPtr);
-	    env->ReleaseStringUTFChars(jFileName, fileNameCharPtr);
+        env->ReleaseStringUTFChars(jFileName, fileNameCharPtr);
         }
     }
     // (exception is thrown by GetStringUTFChars if it fails.)
 }
 
 JNIEXPORT jbyteArray JNICALL Java_com_tightdb_Group_nativeWriteToMem(
-	JNIEnv* env, jobject, jlong nativeGroupPtr)
+    JNIEnv* env, jobject, jlong nativeGroupPtr)
 {
     TR((env, "nativeWriteToMem(%x)\n", nativeGroupPtr));
     Group::BufferSpec buffer = G(nativeGroupPtr)->write_to_mem(); // FIXME: May throw at least std::bad_alloc
@@ -193,7 +193,7 @@ JNIEXPORT jbyteArray JNICALL Java_com_tightdb_Group_nativeWriteToMem(
 }
 
 JNIEXPORT jobject JNICALL Java_com_tightdb_Group_nativeWriteToByteBuffer(
-	JNIEnv* env, jobject, jlong nativeGroupPtr)
+    JNIEnv* env, jobject, jlong nativeGroupPtr)
 {
     TR((env, "nativeWriteToByteBuffer(%x)\n", nativeGroupPtr));
     Group::BufferSpec buffer = G(nativeGroupPtr)->write_to_mem(); // FIXME: May throw at least std::bad_alloc

tightdb_jni/src/com_tightdb_SharedGroup.cpp

@@ -1,9 +1,11 @@
 #include <iostream>
+
 #include <jni.h>
+
 #include <tightdb/group_shared.hpp>
 
-#include "util.h"
-#include "com_tightdb_SharedGroup.h"
+#include "util.hpp"
+#include "com_tightdb_SharedGroup.hpp"
 
 using namespace std;
 using namespace tightdb;