Java: no namespace indent

src/java/Class.hxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2018 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -36,47 +36,49 @@
 #include <cassert>
 
 namespace Java {
-	/**
-	 * Wrapper for a local "jclass" reference.
-	 */
-	class Class : public LocalRef<jclass> {
-	public:
-		Class(JNIEnv *env, jclass cls) noexcept
-			:LocalRef<jclass>(env, cls) {}
 
-		Class(JNIEnv *env, const char *name) noexcept
+/**
-			:LocalRef<jclass>(env, env->FindClass(name)) {}
+ * Wrapper for a local "jclass" reference.
-	};
+ */
+class Class : public LocalRef<jclass> {
+public:
+	Class(JNIEnv *env, jclass cls) noexcept
+		:LocalRef<jclass>(env, cls) {}
 
-	/**
+	Class(JNIEnv *env, const char *name) noexcept
-	 * Wrapper for a global "jclass" reference.
+		:LocalRef<jclass>(env, env->FindClass(name)) {}
-	 */
+};
-	class TrivialClass : public TrivialRef<jclass> {
-	public:
-		void Find(JNIEnv *env, const char *name) noexcept {
-			assert(env != nullptr);
-			assert(name != nullptr);
 
-			jclass cls = env->FindClass(name);
+/**
-			assert(cls != nullptr);
+ * Wrapper for a global "jclass" reference.
+ */
+class TrivialClass : public TrivialRef<jclass> {
+public:
+	void Find(JNIEnv *env, const char *name) noexcept {
+		assert(env != nullptr);
+		assert(name != nullptr);
 
-			Set(env, cls);
+		jclass cls = env->FindClass(name);
-			env->DeleteLocalRef(cls);
+		assert(cls != nullptr);
-		}
 
-		bool FindOptional(JNIEnv *env, const char *name) noexcept {
+		Set(env, cls);
-			assert(env != nullptr);
+		env->DeleteLocalRef(cls);
-			assert(name != nullptr);
+	}
 
-			jclass cls = env->FindClass(name);
+	bool FindOptional(JNIEnv *env, const char *name) noexcept {
-			if (DiscardException(env))
+		assert(env != nullptr);
-				return false;
+		assert(name != nullptr);
 
-			Set(env, cls);
+		jclass cls = env->FindClass(name);
-			env->DeleteLocalRef(cls);
+		if (DiscardException(env))
-			return true;
+			return false;
-		}
+
-	};
+		Set(env, cls);
-}
+		env->DeleteLocalRef(cls);
+		return true;
+	}
+};
+
+} // namespace Java
 
 #endif

src/java/Exception.cxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2019 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions

src/java/Exception.hxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2019 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -35,28 +35,30 @@
 #include <jni.h>
 
 namespace Java {
-	class Exception : public std::runtime_error {
-	public:
-		explicit Exception(JNIEnv *env, jthrowable e) noexcept;
-	};
 
-	/**
+class Exception : public std::runtime_error {
-	 * Check if a Java exception has occurred, and if yes, convert
+public:
-	 * it to a C++ #Exception and throw that.
+	explicit Exception(JNIEnv *env, jthrowable e) noexcept;
-	 */
+};
-	void RethrowException(JNIEnv *env);
 
-	/**
+/**
-	 * Check if an exception has occurred, and discard it.
+ * Check if a Java exception has occurred, and if yes, convert
-	 *
+ * it to a C++ #Exception and throw that.
-	 * @return true if an exception was found (and discarded)
+ */
-	 */
+void RethrowException(JNIEnv *env);
-	static inline bool DiscardException(JNIEnv *env) noexcept {
+
-		bool result = env->ExceptionCheck();
+/**
-		if (result)
+ * Check if an exception has occurred, and discard it.
-			env->ExceptionClear();
+ *
-		return result;
+ * @return true if an exception was found (and discarded)
-	}
+ */
+static inline bool DiscardException(JNIEnv *env) noexcept {
+	bool result = env->ExceptionCheck();
+	if (result)
+		env->ExceptionClear();
+	return result;
 }
 
+} // namespace Java
+
 #endif

src/java/File.hxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2018 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -37,30 +37,32 @@
 class AllocatedPath;
 
 namespace Java {
+
+/**
+ * Wrapper for a java.io.File object.
+ */
+class File : public LocalObject {
+	static jmethodID getAbsolutePath_method;
+
+public:
+	gcc_nonnull_all
+	static void Initialise(JNIEnv *env) noexcept;
+
+	gcc_nonnull_all
+	static jstring getAbsolutePath(JNIEnv *env, jobject file) noexcept {
+		return (jstring)env->CallObjectMethod(file,
+						      getAbsolutePath_method);
+	}
+
 	/**
-	 * Wrapper for a java.io.File object.
+	 * Invoke File.getAbsolutePath() and release the
+	 * specified File reference.
 	 */
-	class File : public LocalObject {
+	gcc_pure gcc_nonnull_all
-		static jmethodID getAbsolutePath_method;
+	static AllocatedPath ToAbsolutePath(JNIEnv *env,
+					    jobject file) noexcept;
+};
 
-	public:
+} // namespace Java
-		gcc_nonnull_all
-		static void Initialise(JNIEnv *env) noexcept;
-
-		gcc_nonnull_all
-		static jstring getAbsolutePath(JNIEnv *env, jobject file) noexcept {
-			return (jstring)env->CallObjectMethod(file,
-							      getAbsolutePath_method);
-		}
-
-		/**
-		 * Invoke File.getAbsolutePath() and release the
-		 * specified File reference.
-		 */
-		gcc_pure gcc_nonnull_all
-		static AllocatedPath ToAbsolutePath(JNIEnv *env,
-						    jobject file) noexcept;
-	};
-}
 
 #endif

src/java/Global.cxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2018 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -30,10 +30,12 @@
 #include "Global.hxx"
 
 namespace Java {
-	JavaVM *jvm;
 
-	void Init(JNIEnv *env) noexcept
+JavaVM *jvm;
-	{
+
-		env->GetJavaVM(&jvm);
+void Init(JNIEnv *env) noexcept
-	}
+{
+	env->GetJavaVM(&jvm);
 }
+
+} // namespace Java

src/java/Global.hxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2018 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -35,24 +35,26 @@
 #include <jni.h>
 
 namespace Java {
-	extern JavaVM *jvm;
 
-	void Init(JNIEnv *env) noexcept;
+extern JavaVM *jvm;
 
-	static inline void
+void Init(JNIEnv *env) noexcept;
-	DetachCurrentThread() noexcept
-	{
-		if (jvm != nullptr)
-			jvm->DetachCurrentThread();
-	}
 
-	static inline gcc_pure
+static inline void
-	JNIEnv *GetEnv() noexcept
+DetachCurrentThread() noexcept
-	{
+{
-		JNIEnv *env;
+	if (jvm != nullptr)
-		jvm->AttachCurrentThread(&env, nullptr);
+		jvm->DetachCurrentThread();
-		return env;
-	}
 }
 
+static inline gcc_pure
+JNIEnv *GetEnv() noexcept
+{
+	JNIEnv *env;
+	jvm->AttachCurrentThread(&env, nullptr);
+	return env;
+}
+
+} // namespace Java
+
 #endif

src/java/Object.hxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2019 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -37,40 +37,42 @@
 #include <cassert>
 
 namespace Java {
+
+/**
+ * Wrapper for a local "jobject" reference.
+ */
+typedef LocalRef<jobject> LocalObject;
+
+class GlobalObject : public GlobalRef<jobject> {
+public:
 	/**
-	 * Wrapper for a local "jobject" reference.
+	 * Constructs an uninitialized object.  The method
+	 * set() must be called before it is destructed.
 	 */
-	typedef LocalRef<jobject> LocalObject;
+	GlobalObject() = default;
 
-	class GlobalObject : public GlobalRef<jobject> {
+	GlobalObject(JNIEnv *env, jobject obj) noexcept
-	public:
+		:GlobalRef<jobject>(env, obj) {}
-		/**
+};
-		 * Constructs an uninitialized object.  The method
-		 * set() must be called before it is destructed.
-		 */
-		GlobalObject() = default;
 
-		GlobalObject(JNIEnv *env, jobject obj) noexcept
+/**
-			:GlobalRef<jobject>(env, obj) {}
+ * Utilities for java.net.Object.
-	};
+ */
+class Object {
+	static jmethodID toString_method;
 
-	/**
+public:
-	 * Utilities for java.net.Object.
+	static void Initialise(JNIEnv *env);
-	 */
-	class Object {
-		static jmethodID toString_method;
 
-	public:
+	static jstring toString(JNIEnv *env, jobject o) {
-		static void Initialise(JNIEnv *env);
+		assert(env != nullptr);
+		assert(o != nullptr);
+		assert(toString_method != nullptr);
 
-		static jstring toString(JNIEnv *env, jobject o) {
+		return (jstring)env->CallObjectMethod(o, toString_method);
-			assert(env != nullptr);
+	}
-			assert(o != nullptr);
+};
-			assert(toString_method != nullptr);
 
-			return (jstring)env->CallObjectMethod(o, toString_method);
+} // namespace Java
-		}
-	};
-}
 
 #endif

src/java/Ref.hxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2018 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -38,170 +38,172 @@
 #include <utility>
 
 namespace Java {
-	/**
-	 * Hold a local reference on a JNI object.
-	 */
-	template<typename T>
-	class LocalRef {
-		JNIEnv *env;
-		T value = nullptr;
 
-	public:
+/**
-		LocalRef() noexcept = default;
+ * Hold a local reference on a JNI object.
+ */
+template<typename T>
+class LocalRef {
+	JNIEnv *env;
+	T value = nullptr;
 
-		/**
+public:
-		 * The local reference is obtained by the caller.  May
+	LocalRef() noexcept = default;
-		 * be nullptr.
-		 */
-		LocalRef(JNIEnv *_env, T _value) noexcept
-			:env(_env), value(_value)
-		{
-			assert(env != nullptr);
-		}
-
-		LocalRef(LocalRef &&src) noexcept
-			:env(src.env),
-			 value(std::exchange(src.value, nullptr)) {}
-
-		~LocalRef() noexcept {
-			if (value != nullptr)
-				env->DeleteLocalRef(value);
-		}
-
-		LocalRef &operator=(LocalRef &&src) noexcept {
-			using std::swap;
-			swap(env, src.env);
-			swap(value, src.value);
-			return *this;
-		}
-
-		JNIEnv *GetEnv() const noexcept {
-			return env;
-		}
-
-		operator bool() const noexcept {
-			return value != nullptr;
-		}
-
-		T Get() const noexcept {
-			return value;
-		}
-
-		operator T() const noexcept {
-			return value;
-		}
-	};
 
 	/**
-	 * Hold a global reference on a JNI object.
+	 * The local reference is obtained by the caller.  May
+	 * be nullptr.
 	 */
-	template<typename T>
+	LocalRef(JNIEnv *_env, T _value) noexcept
-	class GlobalRef {
+		:env(_env), value(_value)
-		T value;
+	{
+		assert(env != nullptr);
+	}
 
-	public:
+	LocalRef(LocalRef &&src) noexcept
-		/**
+		:env(src.env),
-		 * Constructs an uninitialized object.  The method
+		 value(std::exchange(src.value, nullptr)) {}
-		 * set() must be called before it is destructed.
-		 */
-		GlobalRef() = default;
 
-		GlobalRef(JNIEnv *env, T _value) noexcept
+	~LocalRef() noexcept {
-			:value(_value)
+		if (value != nullptr)
-		{
+			env->DeleteLocalRef(value);
-			assert(env != nullptr);
+	}
-			assert(value != nullptr);
 
-			value = (T)env->NewGlobalRef(value);
+	LocalRef &operator=(LocalRef &&src) noexcept {
-		}
+		using std::swap;
+		swap(env, src.env);
+		swap(value, src.value);
+		return *this;
+	}
 
-		~GlobalRef() noexcept {
+	JNIEnv *GetEnv() const noexcept {
-			GetEnv()->DeleteGlobalRef(value);
+		return env;
-		}
+	}
 
-		GlobalRef(const GlobalRef &other) = delete;
+	operator bool() const noexcept {
-		GlobalRef &operator=(const GlobalRef &other) = delete;
+		return value != nullptr;
+	}
 
-		/**
+	T Get() const noexcept {
-		 * Sets the object, ignoring the previous value.  This
+		return value;
-		 * is only allowed once after the default constructor
+	}
-		 * was used.
-		 */
-		void Set(JNIEnv *env, T _value) noexcept {
-			assert(_value != nullptr);
 
-			value = (T)env->NewGlobalRef(_value);
+	operator T() const noexcept {
-		}
+		return value;
+	}
+};
 
-		T Get() const noexcept {
+/**
-			return value;
+ * Hold a global reference on a JNI object.
-		}
+ */
+template<typename T>
+class GlobalRef {
+	T value;
 
-		operator T() const noexcept {
+public:
-			return value;
+	/**
-		}
+	 * Constructs an uninitialized object.  The method
-	};
+	 * set() must be called before it is destructed.
+	 */
+	GlobalRef() = default;
+
+	GlobalRef(JNIEnv *env, T _value) noexcept
+		:value(_value)
+	{
+		assert(env != nullptr);
+		assert(value != nullptr);
+
+		value = (T)env->NewGlobalRef(value);
+	}
+
+	~GlobalRef() noexcept {
+		GetEnv()->DeleteGlobalRef(value);
+	}
+
+	GlobalRef(const GlobalRef &other) = delete;
+	GlobalRef &operator=(const GlobalRef &other) = delete;
 
 	/**
-	 * Container for a global reference to a JNI object that gets
+	 * Sets the object, ignoring the previous value.  This
-	 * initialised and deinitialised explicitly.  Since there is
+	 * is only allowed once after the default constructor
-	 * no implicit initialisation in the default constructor, this
+	 * was used.
-	 * is a trivial C++ class.  It should only be used for global
-	 * variables that are implicitly initialised with zeroes.
 	 */
-	template<typename T>
+	void Set(JNIEnv *env, T _value) noexcept {
-	class TrivialRef {
+		assert(_value != nullptr);
-		T value;
 
-	public:
+		value = (T)env->NewGlobalRef(_value);
-		TrivialRef() = default;
+	}
 
-		TrivialRef(const TrivialRef &other) = delete;
+	T Get() const noexcept {
-		TrivialRef &operator=(const TrivialRef &other) = delete;
+		return value;
+	}
 
-		bool IsDefined() const noexcept {
+	operator T() const noexcept {
-			return value != nullptr;
+		return value;
-		}
+	}
+};
 
-		/**
+/**
-		 * Obtain a global reference on the specified object
+ * Container for a global reference to a JNI object that gets
-		 * and store it.  This object must not be set already.
+ * initialised and deinitialised explicitly.  Since there is
-		 */
+ * no implicit initialisation in the default constructor, this
-		void Set(JNIEnv *env, T _value) noexcept {
+ * is a trivial C++ class.  It should only be used for global
-			assert(value == nullptr);
+ * variables that are implicitly initialised with zeroes.
-			assert(_value != nullptr);
+ */
+template<typename T>
+class TrivialRef {
+	T value;
 
-			value = (T)env->NewGlobalRef(_value);
+public:
-		}
+	TrivialRef() = default;
 
-		/**
+	TrivialRef(const TrivialRef &other) = delete;
-		 * Release the global reference and clear this object.
+	TrivialRef &operator=(const TrivialRef &other) = delete;
-		 */
-		void Clear(JNIEnv *env) noexcept {
-			assert(value != nullptr);
 
-			env->DeleteGlobalRef(value);
+	bool IsDefined() const noexcept {
-			value = nullptr;
+		return value != nullptr;
-		}
+	}
 
-		/**
+	/**
-		 * Release the global reference and clear this object.
+	 * Obtain a global reference on the specified object
-		 * It is allowed to call this method without ever
+	 * and store it.  This object must not be set already.
-		 * calling Set().
+	 */
-		 */
+	void Set(JNIEnv *env, T _value) noexcept {
-		void ClearOptional(JNIEnv *env) noexcept {
+		assert(value == nullptr);
-			if (value != nullptr)
+		assert(_value != nullptr);
-				Clear(env);
-		}
 
-		T Get() const noexcept {
+		value = (T)env->NewGlobalRef(_value);
-			return value;
+	}
-		}
 
-		operator T() const noexcept {
+	/**
-			return value;
+	 * Release the global reference and clear this object.
-		}
+	 */
-	};
+	void Clear(JNIEnv *env) noexcept {
-}
+		assert(value != nullptr);
+
+		env->DeleteGlobalRef(value);
+		value = nullptr;
+	}
+
+	/**
+	 * Release the global reference and clear this object.
+	 * It is allowed to call this method without ever
+	 * calling Set().
+	 */
+	void ClearOptional(JNIEnv *env) noexcept {
+		if (value != nullptr)
+			Clear(env);
+	}
+
+	T Get() const noexcept {
+		return value;
+	}
+
+	operator T() const noexcept {
+		return value;
+	}
+};
+
+} // namespace Java
 
 #endif

src/java/String.hxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2019 Max Kellermann <max.kellermann@gmail.com>
+ * Copyright 2010-2021 Max Kellermann <max.kellermann@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -38,45 +38,47 @@
 #include <string>
 
 namespace Java {
+
+/**
+ * Wrapper for a local "jstring" reference.
+ */
+class String : public LocalRef<jstring> {
+public:
+	String(JNIEnv *env, jstring value) noexcept
+		:LocalRef<jstring>(env, value) {}
+
+	String(JNIEnv *_env, const char *_value) noexcept
+		:LocalRef<jstring>(_env, _env->NewStringUTF(_value)) {}
+
 	/**
-	 * Wrapper for a local "jstring" reference.
+	 * Copy the value to the specified buffer.  Truncates
+	 * the value if it does not fit into the buffer.
+	 *
+	 * @return a pointer to the terminating null byte,
+	 * nullptr on error
 	 */
-	class String : public LocalRef<jstring> {
+	static char *CopyTo(JNIEnv *env, jstring value,
-	public:
+			    char *buffer, size_t max_size) noexcept;
-		String(JNIEnv *env, jstring value) noexcept
-			:LocalRef<jstring>(env, value) {}
 
-		String(JNIEnv *_env, const char *_value) noexcept
+	/**
-			:LocalRef<jstring>(_env, _env->NewStringUTF(_value)) {}
+	 * Copy the value to the specified buffer.  Truncates
+	 * the value if it does not fit into the buffer.
+	 *
+	 * @return a pointer to the terminating null byte,
+	 * nullptr on error
+	 */
+	char *CopyTo(JNIEnv *env,
+		     char *buffer, size_t max_size) noexcept {
+		return CopyTo(env, Get(), buffer, max_size);
+	}
 
-		/**
+	static std::string ToString(JNIEnv *env, jstring s) noexcept;
-		 * Copy the value to the specified buffer.  Truncates
-		 * the value if it does not fit into the buffer.
-		 *
-		 * @return a pointer to the terminating null byte,
-		 * nullptr on error
-		 */
-		static char *CopyTo(JNIEnv *env, jstring value,
-				    char *buffer, size_t max_size) noexcept;
 
-		/**
+	std::string ToString() const noexcept {
-		 * Copy the value to the specified buffer.  Truncates
+		return ToString(GetEnv(), Get());
-		 * the value if it does not fit into the buffer.
+	}
-		 *
+};
-		 * @return a pointer to the terminating null byte,
-		 * nullptr on error
-		 */
-		char *CopyTo(JNIEnv *env,
-			     char *buffer, size_t max_size) noexcept {
-			return CopyTo(env, Get(), buffer, max_size);
-		}
 
-		static std::string ToString(JNIEnv *env, jstring s) noexcept;
+} // namespace Java
-
-		std::string ToString() const noexcept {
-			return ToString(GetEnv(), Get());
-		}
-	};
-}
 
 #endif