OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

CSV import. Rename ColumnInfo to Column

Browse Source
This commit is contained in:
Bjørn Erik Jensen 2017-11-28 11:35:17 +01:00
parent 0334a5aec0
commit 622161776e
11 changed files with 69 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationCode/Commands/SummaryPlotCommands/RicPasteAsciiDataToSummaryPlotFeature.cpp
View File

@ -182,8 +182,8 @@ std::vector<RimAsciiDataCurve*> RicPasteAsciiDataToSummaryPlotFeature::parseCurv
for (size_t i = 0; i < parser.tableData().columnInfos().size(); i++)
{
const ColumnInfo* col = parser.columnInfo(i);
if (col->dataType != ColumnInfo::NUMERIC) continue;
const Column* col = parser.columnInfo(i);
if (col->dataType != Column::NUMERIC) continue;
RimAsciiDataCurve* curve = new RimAsciiDataCurve();
curve->setTimeSteps(parser.dateTimeColumn()->dateTimeValues);

4
ApplicationCode/Commands/SummaryPlotCommands/RicPasteAsciiDataToSummaryPlotFeatureUi.cpp
View File

@ -300,9 +300,9 @@ QList<caf::PdmOptionItemInfo> RicPasteAsciiDataToSummaryPlotFeatureUi::calculate
if (fieldNeedingOptions == &m_timeSeriesColumnName)
{
const std::vector<ColumnInfo>& columnInfoList = m_parser->tableData().columnInfos();
const std::vector<Column>& columnInfoList = m_parser->tableData().columnInfos();
for (const ColumnInfo& columnInfo : columnInfoList)
for (const Column& columnInfo : columnInfoList)
{
QString columnName = QString::fromStdString(columnInfo.columnName());
options.push_back(caf::PdmOptionItemInfo(columnName, columnName));

18
ApplicationCode/FileInterface/RifColumnBasedUserData.cpp
View File

@ -82,7 +82,7 @@ bool RifColumnBasedUserData::values(const RifEclipseSummaryAddress& resultAddres
{
std::pair<size_t, size_t> tableColIndices = search->second;
const ColumnInfo* ci = m_parser->columnInfo(tableColIndices.first, tableColIndices.second);
const Column* ci = m_parser->columnInfo(tableColIndices.first, tableColIndices.second);
if (!ci) return false;
if (!ci->values.empty())
@ -125,7 +125,7 @@ std::string RifColumnBasedUserData::unitName(const RifEclipseSummaryAddress& res
{
std::pair<size_t, size_t> tableColIndices = search->second;
const ColumnInfo* ci = m_parser->columnInfo(tableColIndices.first, tableColIndices.second);
const Column* ci = m_parser->columnInfo(tableColIndices.first, tableColIndices.second);
if (ci)
{
return ci->unitName;
@ -158,8 +158,8 @@ void RifColumnBasedUserData::buildTimeStepsAndMappings()
for (size_t columIndex = 0; columIndex < tableData.columnInfos().size(); columIndex++)
{
const ColumnInfo& ci = tableData.columnInfos()[columIndex];
if (ci.dataType == ColumnInfo::NUMERIC)
const Column& ci = tableData.columnInfos()[columIndex];
if (ci.dataType == Column::NUMERIC)
{
RifEclipseSummaryAddress sumAddress = ci.summaryAddress;
@ -188,7 +188,7 @@ std::vector<time_t> RifColumnBasedUserData::createTimeSteps(const TableData& tab
for (size_t columIndex = 0; columIndex < tableData.columnInfos().size(); columIndex++)
{
const ColumnInfo& ci = tableData.columnInfos()[columIndex];
const Column& ci = tableData.columnInfos()[columIndex];
if (dateColumnIndex == tableData.columnInfos().size() &&
RifEclipseUserDataKeywordTools::isDate(ci.summaryAddress.quantityName()))
@ -221,7 +221,7 @@ std::vector<time_t> RifColumnBasedUserData::createTimeSteps(const TableData& tab
// YEARX is interpreted as absolute decimal year (2014.32)
if (tsVector.empty() && yearXColumnIndex != tableData.columnInfos().size())
{
const ColumnInfo& ci = tableData.columnInfos()[yearXColumnIndex];
const Column& ci = tableData.columnInfos()[yearXColumnIndex];
for (const auto& timeStepValue : ci.values)
{
@ -233,7 +233,7 @@ std::vector<time_t> RifColumnBasedUserData::createTimeSteps(const TableData& tab
// DAYS is interpreted as decimal days since simulation start (23.32)
if (tsVector.empty() && daysColumnIndex != tableData.columnInfos().size())
{
const ColumnInfo& ci = tableData.columnInfos()[daysColumnIndex];
const Column& ci = tableData.columnInfos()[daysColumnIndex];
QDateTime simulationStartDate = tableData.findFirstDate();
@ -247,7 +247,7 @@ std::vector<time_t> RifColumnBasedUserData::createTimeSteps(const TableData& tab
// YEARS is interpreted as decimal years since simulation start (23.32)
if (tsVector.empty() && yearsColumnIndex != tableData.columnInfos().size())
{
const ColumnInfo& ci = tableData.columnInfos()[yearsColumnIndex];
const Column& ci = tableData.columnInfos()[yearsColumnIndex];
QDateTime simulationStartDate = tableData.findFirstDate();
@ -261,7 +261,7 @@ std::vector<time_t> RifColumnBasedUserData::createTimeSteps(const TableData& tab
// DATE is interpreted as date string (6-NOV-1997)
if (tsVector.empty() && dateColumnIndex != tableData.columnInfos().size())
{
const ColumnInfo& ci = tableData.columnInfos()[dateColumnIndex];
const Column& ci = tableData.columnInfos()[dateColumnIndex];
QString dateFormat;
for (auto s : ci.textValues)

6
ApplicationCode/FileInterface/RifColumnBasedUserDataParser.cpp
View File

@ -53,7 +53,7 @@ const std::vector<TableData>& RifColumnBasedUserDataParser::tableData() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const ColumnInfo* RifColumnBasedUserDataParser::columnInfo(size_t tableIndex, size_t columnIndex) const
const Column* RifColumnBasedUserDataParser::columnInfo(size_t tableIndex, size_t columnIndex) const
{
if (tableIndex >= m_tableDatas.size()) return nullptr;
@ -100,7 +100,7 @@ void RifColumnBasedUserDataParser::parseTableData(const QString& data)
}
}
std::vector<ColumnInfo>& columnInfos = table.columnInfos();
std::vector<Column>& columnInfos = table.columnInfos();
int columnCount = static_cast<int>(columnInfos.size());
if (columnCount == 0) break;
@ -131,7 +131,7 @@ void RifColumnBasedUserDataParser::parseTableData(const QString& data)
for (int i = 0; i < columnCount; i++)
{
if (columnInfos[i].dataType == ColumnInfo::TEXT)
if (columnInfos[i].dataType == Column::TEXT)
{
columnInfos[i].textValues.push_back(entries[i].toStdString());
}

4
ApplicationCode/FileInterface/RifColumnBasedUserDataParser.h
View File

@ -25,7 +25,7 @@
#include <vector>
class ColumnInfo;
class Column;
class TableData;
//==================================================================================================
@ -37,7 +37,7 @@ public:
RifColumnBasedUserDataParser(const QString& data, QString* errorText = nullptr);
const std::vector<TableData>& tableData() const;
const ColumnInfo* columnInfo(size_t tableIndex, size_t columnIndex) const;
const Column* columnInfo(size_t tableIndex, size_t columnIndex) const;
private:
void parseTableData(const QString& data);

10
ApplicationCode/FileInterface/RifCsvUserData.cpp
View File

@ -81,7 +81,7 @@ bool RifCsvUserData::values(const RifEclipseSummaryAddress& resultAddress, std::
{
size_t columnIndex = search->second;
const ColumnInfo* ci = m_parser->columnInfo(columnIndex);
const Column* ci = m_parser->columnInfo(columnIndex);
if (!ci) return false;
values->clear();
@ -121,7 +121,7 @@ std::string RifCsvUserData::unitName(const RifEclipseSummaryAddress& resultAddre
{
size_t columnIndex = search->second;
const ColumnInfo* ci = m_parser->columnInfo(columnIndex);
const Column* ci = m_parser->columnInfo(columnIndex);
if (ci)
{
return ci->unitName;
@ -153,8 +153,8 @@ void RifCsvUserData::buildTimeStepsAndMappings()
for (size_t columnIndex = 0; columnIndex < tableData.columnInfos().size(); columnIndex++)
{
const ColumnInfo& ci = tableData.columnInfos()[columnIndex];
if (ci.dataType == ColumnInfo::NUMERIC)
const Column& ci = tableData.columnInfos()[columnIndex];
if (ci.dataType == Column::NUMERIC)
{
RifEclipseSummaryAddress sumAddress = ci.summaryAddress;
@ -173,7 +173,7 @@ std::vector<time_t> RifCsvUserData::createTimeSteps(const TableData& tableData)
{
std::vector<time_t> tsVector;
const ColumnInfo& col = tableData.columnInfos()[0];
const Column& col = tableData.columnInfos()[0];
tsVector.reserve(col.dateTimeValues.size());
for (const QDateTime& qdt : col.dateTimeValues)

34
ApplicationCode/FileInterface/RifCsvUserDataParser.cpp
View File

@ -72,7 +72,7 @@ const TableData& RifCsvUserDataParser::tableData() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const ColumnInfo* RifCsvUserDataParser::columnInfo(size_t columnIndex) const
const Column* RifCsvUserDataParser::columnInfo(size_t columnIndex) const
{
if (columnIndex >= m_tableData.columnInfos().size()) return nullptr;
@ -82,11 +82,11 @@ const ColumnInfo* RifCsvUserDataParser::columnInfo(size_t columnIndex) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const ColumnInfo* RifCsvUserDataParser::dateTimeColumn() const
const Column* RifCsvUserDataParser::dateTimeColumn() const
{
for (const ColumnInfo& col : m_tableData.columnInfos())
for (const Column& col : m_tableData.columnInfos())
{
if (col.dataType == ColumnInfo::DATETIME)
if (col.dataType == Column::DATETIME)
{
return &col;
}
@ -100,7 +100,7 @@ const ColumnInfo* RifCsvUserDataParser::dateTimeColumn() const
bool RifCsvUserDataParser::parseColumnInfo(const AsciiDataParseOptions& parseOptions)
{
QTextStream* dataStream = openDataStream();
std::vector<ColumnInfo> columnInfoList;
std::vector<Column> columnInfoList;
bool result = parseColumnInfo(dataStream, parseOptions, &columnInfoList);
if (result)
@ -170,7 +170,7 @@ QString RifCsvUserDataParser::previewText(int lineCount, const AsciiDataParseOpt
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifCsvUserDataParser::parseColumnInfo(QTextStream* dataStream, const AsciiDataParseOptions& parseOptions, std::vector<ColumnInfo>* columnInfoList)
bool RifCsvUserDataParser::parseColumnInfo(QTextStream* dataStream, const AsciiDataParseOptions& parseOptions, std::vector<Column>* columnInfoList)
{
bool headerFound = false;
@ -190,7 +190,7 @@ bool RifCsvUserDataParser::parseColumnInfo(QTextStream* dataStream, const AsciiD
{
QString colName = lineColumns[iCol];
RifEclipseSummaryAddress addr = RifEclipseSummaryAddress::importedAddress(colName.toStdString());
ColumnInfo col = ColumnInfo::createColumnInfoFromCsvData(addr, "");
Column col = Column::createColumnInfoFromCsvData(addr, "");
columnInfoList->push_back(col);
}
@ -208,7 +208,7 @@ bool RifCsvUserDataParser::parseData(const AsciiDataParseOptions& parseOptions)
bool errors = false;
enum { FIRST_DATA_ROW, DATA_ROW } parseState = FIRST_DATA_ROW;
int colCount;
std::vector<ColumnInfo> columnInfoList;
std::vector<Column> columnInfoList;
QTextStream* dataStream = openDataStream();
@ -238,24 +238,24 @@ bool RifCsvUserDataParser::parseData(const AsciiDataParseOptions& parseOptions)
for (int iCol = 0; iCol < colCount; iCol++)
{
std::string colData = lineColumns[iCol].toStdString();
ColumnInfo& col = columnInfoList[iCol];
Column& col = columnInfoList[iCol];
// Determine column data type
if (col.dataType == ColumnInfo::NONE)
if (col.dataType == Column::NONE)
{
if (QString::fromStdString(col.summaryAddress.quantityName()) == parseOptions.timeSeriesColumnName)
{
col.dataType = ColumnInfo::DATETIME;
col.dataType = Column::DATETIME;
}
else
{
if (RiaStdStringTools::isNumber(colData, parseOptions.locale.decimalPoint().toAscii()))
{
col.dataType = ColumnInfo::NUMERIC;
col.dataType = Column::NUMERIC;
}
else
{
col.dataType = ColumnInfo::TEXT;
col.dataType = Column::TEXT;
}
}
}
@ -269,11 +269,11 @@ bool RifCsvUserDataParser::parseData(const AsciiDataParseOptions& parseOptions)
for (int iCol = 0; iCol < colCount; iCol++)
{
QString& colData = lineColumns[iCol];
ColumnInfo& col = columnInfoList[iCol];
Column& col = columnInfoList[iCol];
try
{
if (col.dataType == ColumnInfo::NUMERIC)
if (col.dataType == Column::NUMERIC)
{
bool parseOk = true;
double value = parseOptions.locale.toDouble(colData, &parseOk);
@ -292,11 +292,11 @@ bool RifCsvUserDataParser::parseData(const AsciiDataParseOptions& parseOptions)
}
col.values.push_back(value);
}
else if (col.dataType == ColumnInfo::TEXT)
else if (col.dataType == Column::TEXT)
{
col.textValues.push_back(colData.toStdString());
}
else if (col.dataType == ColumnInfo::DATETIME)
else if (col.dataType == Column::DATETIME)
{
QDateTime dt;
dt = tryParseDateTime(colData.toStdString(), parseOptions.dateTimeFormat);

8
ApplicationCode/FileInterface/RifCsvUserDataParser.h
View File

@ -31,7 +31,7 @@
#include <vector>
class ColumnInfo;
class Column;
class AsciiDataParseOptions;
//==================================================================================================
@ -46,8 +46,8 @@ public:
bool parse(const AsciiDataParseOptions& parseOptions);
const TableData& tableData() const;
const ColumnInfo* columnInfo(size_t columnIndex) const;
const ColumnInfo* dateTimeColumn() const;
const Column* columnInfo(size_t columnIndex) const;
const Column* dateTimeColumn() const;
bool parseColumnInfo(const AsciiDataParseOptions& parseOptions);
QString previewText(int lineCount, const AsciiDataParseOptions& parseOptions);
@ -64,7 +64,7 @@ protected:
private:
bool parseColumnInfo(QTextStream* dataStream,
const AsciiDataParseOptions& parseOptions,
std::vector<ColumnInfo>* columnInfoList);
std::vector<Column>* columnInfoList);
bool parseData(const AsciiDataParseOptions& parseOptions);
QString columnifyText(const QString& text, const QString& cellSeparator);
static QStringList splitLineAndTrim(const QString& line, const QString& separator);

24
ApplicationCode/FileInterface/RifEclipseUserDataParserTools.cpp
View File

@ -461,7 +461,7 @@ TableData RifEclipseUserDataParserTools::tableDataFromText(std::stringstream& st
}
std::vector<ColumnInfo> columnInfos;
std::vector<Column> columnInfos;
// Create string vectors for each column
{
@ -494,7 +494,7 @@ TableData RifEclipseUserDataParserTools::tableDataFromText(std::stringstream& st
RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress(quantity, columnHeader);
ColumnInfo ci = ColumnInfo::createColumnInfoFromRsmData(quantity, unit, adr);
Column ci = Column::createColumnInfoFromRsmData(quantity, unit, adr);
columnInfos.push_back(ci);
}
@ -563,7 +563,7 @@ bool RifEclipseUserDataParserTools::hasCompleteDataForAllHeaderColumns(const std
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<ColumnInfo> RifEclipseUserDataParserTools::columnInfoForFixedColumnWidth(std::stringstream& streamData)
std::vector<Column> RifEclipseUserDataParserTools::columnInfoForFixedColumnWidth(std::stringstream& streamData)
{
auto headerLines = RifEclipseUserDataParserTools::findValidHeaderLines(streamData);
@ -722,9 +722,9 @@ std::vector<std::vector<std::string>> RifEclipseUserDataParserTools::splitIntoCo
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<ColumnInfo> RifEclipseUserDataParserTools::columnInfoFromColumnHeaders(const std::vector<std::vector<std::string>>& columnData)
std::vector<Column> RifEclipseUserDataParserTools::columnInfoFromColumnHeaders(const std::vector<std::vector<std::string>>& columnData)
{
std::vector<ColumnInfo> table;
std::vector<Column> table;
bool isUnitsDetected = false;
bool isScalingDetected = false;
@ -774,7 +774,7 @@ std::vector<ColumnInfo> RifEclipseUserDataParserTools::columnInfoFromColumnHeade
RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress(quantity, restOfHeader);
ColumnInfo ci = ColumnInfo::createColumnInfoFromRsmData(quantity, unit, adr);
Column ci = Column::createColumnInfoFromRsmData(quantity, unit, adr);
table.push_back(ci);
}
@ -921,7 +921,7 @@ bool RifEclipseUserDataParserTools::isScalingText(const std::string& word)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string ColumnInfo::columnName() const
std::string Column::columnName() const
{
return summaryAddress.quantityName();
}
@ -929,7 +929,7 @@ std::string ColumnInfo::columnName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t ColumnInfo::itemCount() const
size_t Column::itemCount() const
{
switch (dataType)
{
@ -943,9 +943,9 @@ size_t ColumnInfo::itemCount() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
ColumnInfo ColumnInfo::createColumnInfoFromRsmData(const std::string& quantity, const std::string& unit, const RifEclipseSummaryAddress& adr)
Column Column::createColumnInfoFromRsmData(const std::string& quantity, const std::string& unit, const RifEclipseSummaryAddress& adr)
{
ColumnInfo ci(adr, unit);
Column ci(adr, unit);
if (RifEclipseUserDataKeywordTools::isDate(quantity))
{
@ -965,9 +965,9 @@ ColumnInfo ColumnInfo::createColumnInfoFromRsmData(const std::string& quantity,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
ColumnInfo ColumnInfo::createColumnInfoFromCsvData(const RifEclipseSummaryAddress& addr, const std::string& unit)
Column Column::createColumnInfoFromCsvData(const RifEclipseSummaryAddress& addr, const std::string& unit)
{
ColumnInfo col(addr, unit);
Column col(addr, unit);
return col;
}

22
ApplicationCode/FileInterface/RifEclipseUserDataParserTools.h
View File

@ -31,7 +31,7 @@
//==================================================================================================
///
//==================================================================================================
class ColumnInfo
class Column
{
public:
enum DataType
@ -42,13 +42,13 @@ public:
DATETIME
};
ColumnInfo()
Column()
: scaleFactor(1.0),
dataType(NONE)
{
}
ColumnInfo(const RifEclipseSummaryAddress& adr, const std::string& unit)
Column(const RifEclipseSummaryAddress& adr, const std::string& unit)
: summaryAddress(adr),
scaleFactor(1.0),
unitName(unit),
@ -60,8 +60,8 @@ public:
size_t itemCount() const;
public:
static ColumnInfo createColumnInfoFromRsmData(const std::string& quantity, const std::string& unit, const RifEclipseSummaryAddress& adr);
static ColumnInfo createColumnInfoFromCsvData(const RifEclipseSummaryAddress& addr, const std::string& unit);
static Column createColumnInfoFromRsmData(const std::string& quantity, const std::string& unit, const RifEclipseSummaryAddress& adr);
static Column createColumnInfoFromCsvData(const RifEclipseSummaryAddress& addr, const std::string& unit);
RifEclipseSummaryAddress summaryAddress;
std::string unitName;
@ -86,7 +86,7 @@ public:
TableData(const std::string& origin,
const std::string& startDate,
const std::vector<ColumnInfo>& columnInfos)
const std::vector<Column>& columnInfos)
: m_origin(origin),
m_startDate(startDate),
m_columnInfos(columnInfos)
@ -103,12 +103,12 @@ public:
return m_startDate;
}
std::vector<ColumnInfo>& columnInfos()
std::vector<Column>& columnInfos()
{
return m_columnInfos;
}
const std::vector<ColumnInfo>& columnInfos() const
const std::vector<Column>& columnInfos() const
{
return m_columnInfos;
}
@ -119,7 +119,7 @@ private:
std::string m_origin;
std::string m_startDate;
std::vector<ColumnInfo> m_columnInfos;
std::vector<Column> m_columnInfos;
};
//==================================================================================================
@ -149,10 +149,10 @@ public:
static bool isFixedWidthHeader(const std::string& lines);
static bool hasCompleteDataForAllHeaderColumns(const std::string& lines);
static std::vector<ColumnInfo> columnInfoForFixedColumnWidth(std::stringstream& streamData);
static std::vector<Column> columnInfoForFixedColumnWidth(std::stringstream& streamData);
static std::vector<std::string> findValidHeaderLines(std::stringstream& streamData);
static std::vector<std::vector<std::string>> splitIntoColumnHeaders(const std::vector<std::string>& headerLines);
static std::vector<ColumnInfo> columnInfoFromColumnHeaders(const std::vector<std::vector<std::string>>& columnData);
static std::vector<Column> columnInfoFromColumnHeaders(const std::vector<std::vector<std::string>>& columnData);
static std::vector<size_t> columnIndexForWords(const std::string& line);
static std::vector<TableData> mergeEqualTimeSteps(const std::vector<TableData>& tables);

4
ApplicationCode/FileInterface/RifReaderObservedData.cpp
View File

@ -105,8 +105,8 @@ bool RifReaderObservedData::values(const RifEclipseSummaryAddress& resultAddress
if (columnIndex != m_allResultAddresses.size())
{
const ColumnInfo* col = m_asciiParser->columnInfo(columnIndex);
if (col && col->dataType == ColumnInfo::NUMERIC)
const Column* col = m_asciiParser->columnInfo(columnIndex);
if (col && col->dataType == Column::NUMERIC)
{
for (auto& v : col->values)
{