initial import of rdata

Author: shun2wang

Common/utilenums.h

@@ -2,7 +2,7 @@
 #define UTILENUMS_H
 #include "enumutilities.h"
 
-DECLARE_ENUM(FileTypeBase,	jasp = 0, html, csv, txt, tsv, sav, zsav, ods, xls, xlsx, pdf, sas7bdat, sas7bcat, por, xpt, dta, database, empty, unknown );
+DECLARE_ENUM(FileTypeBase,	jasp = 0, html, csv, txt, tsv, sav, zsav, ods, xls, xlsx, pdf, sas7bdat, sas7bcat, por, xpt, dta, database, rdata, rds, empty, unknown );
 
 //const QStringList Database::dbTypes() const should be updated if DbType is changed.
 DECLARE_ENUM(DbType,		NOTCHOSEN, QDB2, /*QIBASE,*/ QMYSQL, QOCI, QODBC, QPSQL, QSQLITE /*, QSQLITE2, QTDS*/ );

Desktop/CMakeLists.txt

@@ -107,13 +107,16 @@ target_include_directories(
     ${PROJECT_SOURCE_DIR}/QMLComponents
     # ReadStat
     $<$<PLATFORM_ID:Windows>:${RTOOLS_LIBREADSTAT_H}>
+    # librdata
+    $<$<PLATFORM_ID:Windows>:${RTOOLS_LIBRDATA_H}>
     ${LIBREADSTAT_INCLUDE_DIRS}
     # JSONCPP
     $<$<PLATFORM_ID:Linux>:${_PKGCONFIG_LIB_JSONCPP_INCLUDEDIR}>
     $<$<BOOL:${FLATPAK_USED}>:/app/include/QtCore5Compat>
     $<$<BOOL:${FLATPAK_USED}>:/app/include/QtWebEngineQuick>
     $<$<BOOL:${FLATPAK_USED}>:/app/include/QtWebEngineCore>
     ${LIBFREEXL_INCLUDE_DIRS}
+    ${LIBRDATA_INCLUDE_DIRS}
 )
 
 target_link_libraries(
@@ -158,11 +161,16 @@ target_link_libraries(
     ${LIBREADSTAT_LIBRARIES}
     # MinGW's ReadStat
     $<$<PLATFORM_ID:Windows>:${RTOOLS_LIBREADSTAT_DLL_A}>
+    # librdata -----------------------------------
+    ${LIBRDATA_LIBRARIES}
+    $<$<PLATFORM_ID:Windows>:${RTOOLS_LIBRDATA_DLL_A}>
     # JSONCPP
          #$<$<PLATFORM_ID:Linux>:${_PKGCONFIG_LIB_JSONCPP_LIBRARIES}>
          #$<$<PLATFORM_ID:Linux>:${_PKGCONFIG_LIB_JSONCPP_LINK_LIBRARIES}>
     # R-Framework --------------------------------
     $<$<PLATFORM_ID:Darwin>:${_R_Framework}>
+    # librdata
+    ${LIBRDATA_LIBRARIES}
 )
 
 target_compile_definitions(JASP PUBLIC JASP_USES_QT_HERE)

Desktop/data/datasetloader.cpp

@@ -26,6 +26,7 @@
 #include "importers/odsimporter.h"
 #include "importers/readstatimporter.h"
 #include "importers/excelimporter.h"
+#include "importers/rdataimporter.h"
 
 
 #include <QFileInfo>
@@ -56,6 +57,8 @@ Importer* DataSetLoader::getImporter(const string & locator, const string &ext)
 	if( boost::iequals(ext,".xls") ||
 		boost::iequals(ext,".xlsx"))							return new ExcelImporter();
 	if(	ReadStatImporter::extSupported(ext))					return new ReadStatImporter(ext);
+	if( boost::iequals(ext,".rdata") ||
+        boost::iequals(ext,".rds"))                             return new RDataImporter(ext);
 
 	return nullptr; //If NULL then JASP will try to load it as a .jasp file (if the extension matches)
 }

Desktop/data/fileevent.cpp

@@ -119,7 +119,7 @@ const std::string FileEvent::databaseStr() const
 
 QString FileEvent::getProgressMsg() const
 {
-	//jasp = 0, html, csv, txt, tsv, sav, zsav, ods, pdf, sas7bdat, sas7bcat, por, xpt, empty, unknown
+	//jasp = 0, html, csv, txt, tsv, sav, zsav, ods, xls, xlsx, pdf, sas7bdat, sas7bcat, por, xpt, dta, database, rdata, rds, empty, unknown
 	switch(_operation)
 	{
 	case FileEvent::FileOpen:
@@ -139,6 +139,8 @@ QString FileEvent::getProgressMsg() const
 		case Utils::FileType::sas7bcat:	return tr("Importing SAS File");
 		case Utils::FileType::dta:		return tr("Importing STATA File");
 		case Utils::FileType::jasp:		return tr("Loading JASP File");
+		case Utils::FileType::rdata:
+		case Utils::FileType::rds:      return tr("Loading R Data File");
 		default:						return tr("Loading File");
 		}
 		break;

Desktop/data/importers/rdata/rdataimportcolumn.cpp

@@ -0,0 +1,48 @@
+//
+// Copyright (C) 2013-2025 University of Amsterdam
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "rdataimportcolumn.h"
+#include "timers.h"
+
+RDataImportColumn::RDataImportColumn(ImportDataSet* importDataSet, std::string name) : ImportColumn(importDataSet, name)
+{
+}
+
+RDataImportColumn::RDataImportColumn(ImportDataSet *importDataSet, std::string name, long reserve) : ImportColumn(importDataSet, name)
+{
+	_data.reserve(reserve);
+}
+
+RDataImportColumn::~RDataImportColumn()
+{
+	JASPTIMER_SCOPE(RDataImportColumn::~RDataImportColumn());
+}
+
+size_t RDataImportColumn::size() const
+{
+	return _data.size();
+}
+
+void RDataImportColumn::addValue(const std::string &value)
+{
+	_data.push_back(value);
+}
+
+const std::vector<std::string> &RDataImportColumn::getValues() const
+{
+	return _data;
+}

Desktop/data/importers/rdata/rdataimportcolumn.h

@@ -0,0 +1,39 @@
+//
+// Copyright (C) 2013-2025 University of Amsterdam
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef RDATAIMPORTCOLUMN_H
+#define RDATAIMPORTCOLUMN_H
+
+#include "data/importers/importcolumn.h"
+
+class RDataImportColumn : public ImportColumn
+{
+public:
+	RDataImportColumn(ImportDataSet *importDataSet, std::string name);
+	RDataImportColumn(ImportDataSet *importDataSet, std::string name, long reserve);
+	~RDataImportColumn() override;
+
+	size_t 			size() const override;
+	const stringvec &allValuesAsStrings() const override { return _data; }
+	void 			addValue(const std::string &value);
+	const stringvec &getValues() const;
+
+private:
+	stringvec _data;
+};
+
+#endif // RDATAIMPORTCOLUMN_H

Desktop/data/importers/rdata/readrdata.cpp

@@ -0,0 +1,179 @@
+//
+// Copyright (C) 2013-2025 University of Amsterdam
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "readrdata.h"
+#include "log.h"
+
+RDataReader::RDataReader(const std::string &locator)
+{
+	_filePath = locator;
+}
+
+void RDataReader::open()
+{
+	_parser = rdata_parser_init();
+
+	if (!_parser)
+	{
+		Log::log() << "Failed to initialize parser" << std::endl;
+		throw std::runtime_error("Could not access file");
+	}
+
+	if (_filePath.empty())
+		throw std::invalid_argument("File path cannot be empty.");
+		
+	rdata_set_table_handler(_parser, &_tableHandler);
+	rdata_set_column_handler(_parser, &_columnHandler);
+	rdata_set_text_value_handler(_parser, &_textValueHandler);
+	rdata_set_column_name_handler(_parser, &_columnNameHandler);
+	// rdata_set_value_label_handler(_parser, &_valueLabelHandler);
+
+	rdata_error_t result = rdata_parse(_parser, _filePath.c_str(), &_context);
+
+	_rowCount = _context.row_count;
+	_colCount = _context.column_count;
+	_columnNames = _context.column_names;
+	_column_data = _context.column_data;
+
+	std::cout << "Total Columns: " << _colCount << ", Total Rows: " << _rowCount << std::endl;
+
+	if (result != RDATA_OK)
+	{
+		std::cerr << "Failed to parse file: " << rdata_error_message(result) << std::endl;
+	}
+
+	if (_parser)
+	{
+		rdata_parser_free(_parser);
+		_parser = nullptr;
+	}
+}
+
+int RDataReader::_tableHandler(const char *name, void *ctx)
+{
+	RDataCtx *context = static_cast<RDataCtx *>(ctx);
+	if (!name)
+	{
+		context->table_name = "DEF_table_name";
+	}
+	else
+	{
+		context->table_name = name;
+		// Log::log() << "Table Name: " << name << std::endl;
+	}
+	return 0;
+}
+
+int RDataReader::_columnHandler(const char *name, rdata_type_t type, void *data, long count, void *ctx)
+{
+
+	RDataCtx *context = static_cast<RDataCtx *>(ctx);
+	// Log::log() << "Column name: " << name << ", Type: " << type << ", Count: " << count << std::endl;
+
+	context->column_count++;
+
+	if (count > context->row_count)
+	{
+		context->row_count = count;
+	}
+
+	stringvec column_values;
+
+	if (type == RDATA_TYPE_STRING)
+	{
+		// Initialize an empty vector for string type to be filled in _textValueHandler
+		context->column_data.emplace_back(stringvec(count, ""));
+	}
+	else
+	{
+		switch (type)
+		{
+		case RDATA_TYPE_INT32:
+		case RDATA_TYPE_LOGICAL:
+		{
+			int32_t *values = static_cast<int32_t *>(data);
+			for (size_t i = 0; i < count; i++)
+				column_values.push_back(std::to_string(values[i]));
+			break;
+		}
+		case RDATA_TYPE_REAL:
+		{
+			double *values = static_cast<double *>(data);
+			for (size_t i = 0; i < count; i++)
+			{
+				if (std::isnan(values[i]))
+					column_values.push_back("NA");
+				else
+					column_values.push_back(std::to_string(values[i]));
+			}
+			break;
+		}
+		default:
+			Log::log() << "Unsupported data type for column: " << name << std::endl;
+			break;
+		}
+
+		context->column_data.push_back(column_values);
+	}
+
+	return 0;
+}
+
+int RDataReader::_columnNameHandler(const char *value, int index, void *ctx)
+{
+	RDataCtx *context = static_cast<RDataCtx *>(ctx);
+
+	if (index >= context->column_names.size())
+	{
+		context->column_names.resize(index + 1);
+	}
+
+	context->column_names[index] = value ? value : "Unnamed_Column";
+	// Log::log() << "Column name [Index " << index << "]: " << context->column_names[index] << std::endl;
+	return 0;
+}
+
+void RDataReader::_errorHandler(const char *error_message, void *ctx)
+{
+	Log::log() << "Error: " << error_message << std::endl;
+}
+
+int RDataReader::_textValueHandler(const char *value, int index, void *ctx)
+{
+	RDataCtx *context = static_cast<RDataCtx *>(ctx);
+
+	if (context->column_data.empty())
+	{
+		Log::log() << "Error: _textValueHandler called before _columnHandler." << std::endl;
+		return 1; // Abort processing
+	}
+
+	size_t column_index = context->column_data.size() - 1;
+	if (index >= context->column_data[column_index].size())
+	{
+		context->column_data[column_index].resize(index + 1, "");
+	}
+
+	context->column_data[column_index][index] = value ? value : "NA";
+
+	return 0;
+}
+
+int RDataReader::_valueLabelHandler(const char *value, int index, void *ctx)
+{
+	return 0;
+}