Modernize code base

native/jni/utils/Android.mk

@@ -9,6 +9,7 @@ LOCAL_SRC_FILES := \
 	selinux.cpp \
 	logging.cpp \
 	xwrap.cpp \
+	CharArray.cpp \
 	vector.c
 
 include $(BUILD_STATIC_LIBRARY)

native/jni/utils/CharArray.cpp

@@ -0,0 +1,99 @@
+#include "CharArray.h"
+#include "utils.h"
+
+CharArray::CharArray() : _buf(nullptr), _size(0){}
+
+CharArray::CharArray(const char *s) : CharArray() {
+	this->operator=(s);
+}
+
+CharArray::CharArray(const CharArray &s) : CharArray() {
+	this->operator=(s);
+}
+
+CharArray::CharArray(size_t i) {
+	_size = i;
+	_buf = new char[i](); /* Zero initialize */
+}
+
+CharArray::~CharArray() {
+	delete[] _buf;
+}
+
+CharArray::operator char *() {
+	return _buf;
+}
+
+CharArray::operator const char *() const {
+	return _buf;
+}
+
+const char *CharArray::c_str() const {
+	return _buf;
+}
+
+size_t CharArray::length() const {
+	return strlen(_buf);
+}
+
+size_t CharArray::size() const {
+	return _size;
+}
+
+CharArray &CharArray::operator=(const CharArray &s) {
+	delete[] _buf;
+	_size = s._size;
+	_buf = new char[_size];
+	memcpy(_buf, s._buf, _size);
+	return *this;
+}
+
+CharArray &CharArray::operator=(const char *s) {
+	delete[] _buf;
+	_buf = strdup2(s, &_size);
+	return *this;
+}
+
+CharArray &CharArray::operator=(CharArray &&s) {
+	delete[] _buf;
+	_size = s._size;
+	_buf = s._buf;
+	s._buf = nullptr;
+	s._size = 0;
+	return *this;
+}
+
+bool CharArray::operator==(const char *s) const {
+	if (_buf == nullptr || s == nullptr)
+		return false;
+	return strcmp(_buf, s) == 0;
+}
+
+bool CharArray::operator==(char *s) const {
+	return *this == (const char *) s;
+}
+
+bool CharArray::operator!=(const char *s) const {
+	return !(*this == s);
+}
+
+int CharArray::compare(const char *s) const {
+	return strcmp(_buf, s);
+}
+
+int CharArray::compare(const char *s, size_t len) const {
+	return strncmp(_buf, s, len);
+}
+
+bool CharArray::contains(const char *s) const {
+	return strstr(_buf, s) != nullptr;
+}
+
+bool CharArray::starts_with(const char *s) const {
+	return compare(s, strlen(s)) == 0;
+}
+
+bool CharArray::empty() const {
+	return _buf == nullptr || _buf[0] == '\0';
+}
+

native/jni/utils/file.cpp

@@ -388,7 +388,7 @@ void write_zero(int fd, size_t size) {
 	lseek(fd, pos + size, SEEK_SET);
 }
 
-int file_to_array(const char *filename, Array<char *> &arr) {
+int file_to_array(const char *filename, Array<CharArray> &arr) {
 	if (access(filename, R_OK) != 0)
 		return 1;
 	char *line = nullptr;
@@ -404,8 +404,8 @@ int file_to_array(const char *filename, Array<char *> &arr) {
 		if (line[read - 1] == '\n')
 			line[read - 1] = '\0';
 		arr.push_back(line);
-		line = nullptr;
 	}
 	fclose(fp);
+	free(line);
 	return 0;
 }

native/jni/utils/include/CharArray.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <string.h>
+
+/* A wrapper around char array */
+class CharArray {
+public:
+	CharArray();
+	CharArray(const char *s);
+	CharArray(const CharArray &s);
+	CharArray(size_t i);
+	~CharArray();
+
+	CharArray &operator=(const CharArray &s);
+	CharArray &operator=(CharArray &&s);
+	CharArray &operator=(const char *s);
+
+	operator char *();
+	operator const char *() const;
+	bool operator==(char *s) const;
+	bool operator==(const char *s) const;
+	bool operator!=(const char *s) const;
+	int compare(const char *s) const;
+	int compare(const char *s, size_t len) const;
+	bool starts_with(const char *s) const;
+	bool contains(const char *s) const;
+	bool empty() const;
+	const char *c_str() const;
+	size_t length() const;
+	size_t size() const;
+
+	/* These 2 ops are incompatible with implicit char* conversion */
+//	char &operator[](size_t i);
+//	const char &operator[](size_t i) const;
+
+private:
+	char *_buf;
+	size_t _size;
+};

native/jni/utils/include/array.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stdlib.h>
+#include "cpputils.h"
 
 template <class T>
 class Array {
@@ -72,7 +73,7 @@ public:
 		if (_capacity) {
 			_data = new T[_capacity];
 			for(int i = 0; i < _size; ++i)
-				_data[i] = (T&&) a[i];
+				_data[i] = utils::move(a[i]);
 		}
 		return *this;
 	}
@@ -101,7 +102,7 @@ public:
 	void push_back(T&& x) {
 		if(_size == _capacity)
 			expand();
-		_data[_size] = (T&&) x;
+		_data[_size] = utils::move(x);
 		++_size;
 	}
 
@@ -114,7 +115,7 @@ public:
 		if (_size == 0 || d < _data || d >= _data + _size)
 			return false;
 		for (; d < _data + _size - 1; ++d)
-			*d = (T&&) *(d + 1);
+			*d = utils::move(*(d + 1));
 		--_size;
 		return true;
 
@@ -130,9 +131,16 @@ public:
 		return false;
 	}
 
-	void clear() { _size = 0; }
+	void clear(bool dealloc = false) {
+		_size = 0;
+		if (dealloc) {
+			_capacity = 0;
+			delete [] _data;
+			_data = nullptr;
+		}
+	}
 
-	void sort() const {
+	void sort() {
 		qsort(_data, _size, sizeof(T), compare);
 	}
 
@@ -161,7 +169,7 @@ private:
 		T* temp = _data;
 		_data = new T[_capacity];
 		for(int i = 0; i < _size; ++i)
-			_data[i] = (T&&) temp[i];
+			_data[i] = utils::move(temp[i]);
 		delete [] temp;
 	}
 };

native/jni/utils/include/cpputils.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace utils {
+	template< class T > struct remove_reference      {typedef T type;};
+	template< class T > struct remove_reference<T&>  {typedef T type;};
+	template< class T > struct remove_reference<T&&> {typedef T type;};
+
+	template< class T >
+	constexpr typename remove_reference<T>::type&& move( T&& t ) noexcept {
+		return static_cast<typename remove_reference<T>::type&&>(t);
+	}
+}

native/jni/utils/include/utils.h

@@ -12,9 +12,15 @@
 #include <sys/stat.h>
 
 #ifdef __cplusplus
-// C++ only
+
 #include "array.h"
-int file_to_array(const char* filename, Array<char *> &arr);
+#include "CharArray.h"
+#include "cpputils.h"
+
+int file_to_array(const char *filename, Array<CharArray> &arr);
+char *strdup2(const char *s, size_t *size = nullptr);
+
+
 extern "C" {
 #endif
 

native/jni/utils/misc.cpp

@@ -268,3 +268,11 @@ int exec_command(int err, int *fd, void (*cb)(void), const char *argv0, ...) {
 	va_end(argv);
 	return pid;
 }
+
+char *strdup2(const char *s, size_t *size) {
+	size_t l = strlen(s) + 1;
+	char *buf = new char[l];
+	memcpy(buf, s, l);
+	if (size) *size = l;
+	return buf;
+}