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
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++) for (size_t i = 0; i < parser.tableData().columnInfos().size(); i++)
{ {
const ColumnInfo* col = parser.columnInfo(i); const Column* col = parser.columnInfo(i);
if (col->dataType != ColumnInfo::NUMERIC) continue; if (col->dataType != Column::NUMERIC) continue;
RimAsciiDataCurve* curve = new RimAsciiDataCurve(); RimAsciiDataCurve* curve = new RimAsciiDataCurve();
curve->setTimeSteps(parser.dateTimeColumn()->dateTimeValues); 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) 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()); QString columnName = QString::fromStdString(columnInfo.columnName());
options.push_back(caf::PdmOptionItemInfo(columnName, 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; 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) return false;
if (!ci->values.empty()) if (!ci->values.empty())
@@ -125,7 +125,7 @@ std::string RifColumnBasedUserData::unitName(const RifEclipseSummaryAddress& res
{ {
std::pair<size_t, size_t> tableColIndices = search->second; 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) if (ci)
{ {
return ci->unitName; return ci->unitName;
@@ -158,8 +158,8 @@ void RifColumnBasedUserData::buildTimeStepsAndMappings()
for (size_t columIndex = 0; columIndex < tableData.columnInfos().size(); columIndex++) for (size_t columIndex = 0; columIndex < tableData.columnInfos().size(); columIndex++)
{ {
const ColumnInfo& ci = tableData.columnInfos()[columIndex]; const Column& ci = tableData.columnInfos()[columIndex];
if (ci.dataType == ColumnInfo::NUMERIC) if (ci.dataType == Column::NUMERIC)
{ {
RifEclipseSummaryAddress sumAddress = ci.summaryAddress; 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++) 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() && if (dateColumnIndex == tableData.columnInfos().size() &&
RifEclipseUserDataKeywordTools::isDate(ci.summaryAddress.quantityName())) 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) // YEARX is interpreted as absolute decimal year (2014.32)
if (tsVector.empty() && yearXColumnIndex != tableData.columnInfos().size()) 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) 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) // DAYS is interpreted as decimal days since simulation start (23.32)
if (tsVector.empty() && daysColumnIndex != tableData.columnInfos().size()) if (tsVector.empty() && daysColumnIndex != tableData.columnInfos().size())
{ {
const ColumnInfo& ci = tableData.columnInfos()[daysColumnIndex]; const Column& ci = tableData.columnInfos()[daysColumnIndex];
QDateTime simulationStartDate = tableData.findFirstDate(); 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) // YEARS is interpreted as decimal years since simulation start (23.32)
if (tsVector.empty() && yearsColumnIndex != tableData.columnInfos().size()) if (tsVector.empty() && yearsColumnIndex != tableData.columnInfos().size())
{ {
const ColumnInfo& ci = tableData.columnInfos()[yearsColumnIndex]; const Column& ci = tableData.columnInfos()[yearsColumnIndex];
QDateTime simulationStartDate = tableData.findFirstDate(); 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) // DATE is interpreted as date string (6-NOV-1997)
if (tsVector.empty() && dateColumnIndex != tableData.columnInfos().size()) if (tsVector.empty() && dateColumnIndex != tableData.columnInfos().size())
{ {
const ColumnInfo& ci = tableData.columnInfos()[dateColumnIndex]; const Column& ci = tableData.columnInfos()[dateColumnIndex];
QString dateFormat; QString dateFormat;
for (auto s : ci.textValues) 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; 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()); int columnCount = static_cast<int>(columnInfos.size());
if (columnCount == 0) break; if (columnCount == 0) break;
@@ -131,7 +131,7 @@ void RifColumnBasedUserDataParser::parseTableData(const QString& data)
for (int i = 0; i < columnCount; i++) 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()); columnInfos[i].textValues.push_back(entries[i].toStdString());
} }

4
ApplicationCode/FileInterface/RifColumnBasedUserDataParser.h
View File

@@ -25,7 +25,7 @@
#include <vector> #include <vector>
class ColumnInfo; class Column;
class TableData; class TableData;
//================================================================================================== //==================================================================================================
@@ -37,7 +37,7 @@ public:
RifColumnBasedUserDataParser(const QString& data, QString* errorText = nullptr); RifColumnBasedUserDataParser(const QString& data, QString* errorText = nullptr);
const std::vector<TableData>& tableData() const; 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: private:
void parseTableData(const QString& data); 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; size_t columnIndex = search->second;
const ColumnInfo* ci = m_parser->columnInfo(columnIndex); const Column* ci = m_parser->columnInfo(columnIndex);
if (!ci) return false; if (!ci) return false;
values->clear(); values->clear();
@@ -121,7 +121,7 @@ std::string RifCsvUserData::unitName(const RifEclipseSummaryAddress& resultAddre
{ {
size_t columnIndex = search->second; size_t columnIndex = search->second;
const ColumnInfo* ci = m_parser->columnInfo(columnIndex); const Column* ci = m_parser->columnInfo(columnIndex);
if (ci) if (ci)
{ {
return ci->unitName; return ci->unitName;
@@ -153,8 +153,8 @@ void RifCsvUserData::buildTimeStepsAndMappings()
for (size_t columnIndex = 0; columnIndex < tableData.columnInfos().size(); columnIndex++) for (size_t columnIndex = 0; columnIndex < tableData.columnInfos().size(); columnIndex++)
{ {
const ColumnInfo& ci = tableData.columnInfos()[columnIndex]; const Column& ci = tableData.columnInfos()[columnIndex];
if (ci.dataType == ColumnInfo::NUMERIC) if (ci.dataType == Column::NUMERIC)
{ {
RifEclipseSummaryAddress sumAddress = ci.summaryAddress; RifEclipseSummaryAddress sumAddress = ci.summaryAddress;
@@ -173,7 +173,7 @@ std::vector<time_t> RifCsvUserData::createTimeSteps(const TableData& tableData)
{ {
std::vector<time_t> tsVector; std::vector<time_t> tsVector;
const ColumnInfo& col = tableData.columnInfos()[0]; const Column& col = tableData.columnInfos()[0];
tsVector.reserve(col.dateTimeValues.size()); tsVector.reserve(col.dateTimeValues.size());
for (const QDateTime& qdt : col.dateTimeValues) 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; 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; return &col;
} }
@@ -100,7 +100,7 @@ const ColumnInfo* RifCsvUserDataParser::dateTimeColumn() const
bool RifCsvUserDataParser::parseColumnInfo(const AsciiDataParseOptions& parseOptions) bool RifCsvUserDataParser::parseColumnInfo(const AsciiDataParseOptions& parseOptions)
{ {
QTextStream* dataStream = openDataStream(); QTextStream* dataStream = openDataStream();
std::vector<ColumnInfo> columnInfoList; std::vector<Column> columnInfoList;
bool result = parseColumnInfo(dataStream, parseOptions, &columnInfoList); bool result = parseColumnInfo(dataStream, parseOptions, &columnInfoList);
if (result) 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; bool headerFound = false;
@@ -190,7 +190,7 @@ bool RifCsvUserDataParser::parseColumnInfo(QTextStream* dataStream, const AsciiD
{ {
QString colName = lineColumns[iCol]; QString colName = lineColumns[iCol];
RifEclipseSummaryAddress addr = RifEclipseSummaryAddress::importedAddress(colName.toStdString()); RifEclipseSummaryAddress addr = RifEclipseSummaryAddress::importedAddress(colName.toStdString());
ColumnInfo col = ColumnInfo::createColumnInfoFromCsvData(addr, ""); Column col = Column::createColumnInfoFromCsvData(addr, "");
columnInfoList->push_back(col); columnInfoList->push_back(col);
} }
@@ -208,7 +208,7 @@ bool RifCsvUserDataParser::parseData(const AsciiDataParseOptions& parseOptions)
bool errors = false; bool errors = false;
enum { FIRST_DATA_ROW, DATA_ROW } parseState = FIRST_DATA_ROW; enum { FIRST_DATA_ROW, DATA_ROW } parseState = FIRST_DATA_ROW;
int colCount; int colCount;
std::vector<ColumnInfo> columnInfoList; std::vector<Column> columnInfoList;
QTextStream* dataStream = openDataStream(); QTextStream* dataStream = openDataStream();
@@ -238,24 +238,24 @@ bool RifCsvUserDataParser::parseData(const AsciiDataParseOptions& parseOptions)
for (int iCol = 0; iCol < colCount; iCol++) for (int iCol = 0; iCol < colCount; iCol++)
{ {
std::string colData = lineColumns[iCol].toStdString(); std::string colData = lineColumns[iCol].toStdString();
ColumnInfo& col = columnInfoList[iCol]; Column& col = columnInfoList[iCol];
// Determine column data type // Determine column data type
if (col.dataType == ColumnInfo::NONE) if (col.dataType == Column::NONE)
{ {
if (QString::fromStdString(col.summaryAddress.quantityName()) == parseOptions.timeSeriesColumnName) if (QString::fromStdString(col.summaryAddress.quantityName()) == parseOptions.timeSeriesColumnName)
{ {
col.dataType = ColumnInfo::DATETIME; col.dataType = Column::DATETIME;
} }
else else
{ {
if (RiaStdStringTools::isNumber(colData, parseOptions.locale.decimalPoint().toAscii())) if (RiaStdStringTools::isNumber(colData, parseOptions.locale.decimalPoint().toAscii()))
{ {
col.dataType = ColumnInfo::NUMERIC; col.dataType = Column::NUMERIC;
} }
else 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++) for (int iCol = 0; iCol < colCount; iCol++)
{ {
QString& colData = lineColumns[iCol]; QString& colData = lineColumns[iCol];
ColumnInfo& col = columnInfoList[iCol]; Column& col = columnInfoList[iCol];
try try
{ {
if (col.dataType == ColumnInfo::NUMERIC) if (col.dataType == Column::NUMERIC)
{ {
bool parseOk = true; bool parseOk = true;
double value = parseOptions.locale.toDouble(colData, &parseOk); double value = parseOptions.locale.toDouble(colData, &parseOk);
@@ -292,11 +292,11 @@ bool RifCsvUserDataParser::parseData(const AsciiDataParseOptions& parseOptions)
} }
col.values.push_back(value); col.values.push_back(value);
} }
else if (col.dataType == ColumnInfo::TEXT) else if (col.dataType == Column::TEXT)
{ {
col.textValues.push_back(colData.toStdString()); col.textValues.push_back(colData.toStdString());
} }
else if (col.dataType == ColumnInfo::DATETIME) else if (col.dataType == Column::DATETIME)
{ {
QDateTime dt; QDateTime dt;
dt = tryParseDateTime(colData.toStdString(), parseOptions.dateTimeFormat); dt = tryParseDateTime(colData.toStdString(), parseOptions.dateTimeFormat);

8
ApplicationCode/FileInterface/RifCsvUserDataParser.h
View File

@@ -31,7 +31,7 @@
#include <vector> #include <vector>
class ColumnInfo; class Column;
class AsciiDataParseOptions; class AsciiDataParseOptions;
//================================================================================================== //==================================================================================================
@@ -46,8 +46,8 @@ public:
bool parse(const AsciiDataParseOptions& parseOptions); bool parse(const AsciiDataParseOptions& parseOptions);
const TableData& tableData() const; const TableData& tableData() const;
const ColumnInfo* columnInfo(size_t columnIndex) const; const Column* columnInfo(size_t columnIndex) const;
const ColumnInfo* dateTimeColumn() const; const Column* dateTimeColumn() const;
bool parseColumnInfo(const AsciiDataParseOptions& parseOptions); bool parseColumnInfo(const AsciiDataParseOptions& parseOptions);
QString previewText(int lineCount, const AsciiDataParseOptions& parseOptions); QString previewText(int lineCount, const AsciiDataParseOptions& parseOptions);
@@ -64,7 +64,7 @@ protected:
private: private:
bool parseColumnInfo(QTextStream* dataStream, bool parseColumnInfo(QTextStream* dataStream,
const AsciiDataParseOptions& parseOptions, const AsciiDataParseOptions& parseOptions,
std::vector<ColumnInfo>* columnInfoList); std::vector<Column>* columnInfoList);
bool parseData(const AsciiDataParseOptions& parseOptions); bool parseData(const AsciiDataParseOptions& parseOptions);
QString columnifyText(const QString& text, const QString& cellSeparator); QString columnifyText(const QString& text, const QString& cellSeparator);
static QStringList splitLineAndTrim(const QString& line, const QString& separator); 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 // Create string vectors for each column
{ {
@@ -494,7 +494,7 @@ TableData RifEclipseUserDataParserTools::tableDataFromText(std::stringstream& st
RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress(quantity, columnHeader); RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress(quantity, columnHeader);
ColumnInfo ci = ColumnInfo::createColumnInfoFromRsmData(quantity, unit, adr); Column ci = Column::createColumnInfoFromRsmData(quantity, unit, adr);
columnInfos.push_back(ci); 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); 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 isUnitsDetected = false;
bool isScalingDetected = false; bool isScalingDetected = false;
@@ -774,7 +774,7 @@ std::vector<ColumnInfo> RifEclipseUserDataParserTools::columnInfoFromColumnHeade
RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress(quantity, restOfHeader); RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress(quantity, restOfHeader);
ColumnInfo ci = ColumnInfo::createColumnInfoFromRsmData(quantity, unit, adr); Column ci = Column::createColumnInfoFromRsmData(quantity, unit, adr);
table.push_back(ci); 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(); return summaryAddress.quantityName();
} }
@@ -929,7 +929,7 @@ std::string ColumnInfo::columnName() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
size_t ColumnInfo::itemCount() const size_t Column::itemCount() const
{ {
switch (dataType) 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)) 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; return col;
} }

22
ApplicationCode/FileInterface/RifEclipseUserDataParserTools.h
View File

@@ -31,7 +31,7 @@
//================================================================================================== //==================================================================================================
/// ///
//================================================================================================== //==================================================================================================
class ColumnInfo class Column
{ {
public: public:
enum DataType enum DataType
@@ -42,13 +42,13 @@ public:
DATETIME DATETIME
}; };
ColumnInfo() Column()
: scaleFactor(1.0), : scaleFactor(1.0),
dataType(NONE) dataType(NONE)
{ {
} }
ColumnInfo(const RifEclipseSummaryAddress& adr, const std::string& unit) Column(const RifEclipseSummaryAddress& adr, const std::string& unit)
: summaryAddress(adr), : summaryAddress(adr),
scaleFactor(1.0), scaleFactor(1.0),
unitName(unit), unitName(unit),
@@ -60,8 +60,8 @@ public:
size_t itemCount() const; size_t itemCount() const;
public: public:
static ColumnInfo createColumnInfoFromRsmData(const std::string& quantity, const std::string& unit, const RifEclipseSummaryAddress& adr); static Column createColumnInfoFromRsmData(const std::string& quantity, const std::string& unit, const RifEclipseSummaryAddress& adr);
static ColumnInfo createColumnInfoFromCsvData(const RifEclipseSummaryAddress& addr, const std::string& unit); static Column createColumnInfoFromCsvData(const RifEclipseSummaryAddress& addr, const std::string& unit);
RifEclipseSummaryAddress summaryAddress; RifEclipseSummaryAddress summaryAddress;
std::string unitName; std::string unitName;
@@ -86,7 +86,7 @@ public:
TableData(const std::string& origin, TableData(const std::string& origin,
const std::string& startDate, const std::string& startDate,
const std::vector<ColumnInfo>& columnInfos) const std::vector<Column>& columnInfos)
: m_origin(origin), : m_origin(origin),
m_startDate(startDate), m_startDate(startDate),
m_columnInfos(columnInfos) m_columnInfos(columnInfos)
@@ -103,12 +103,12 @@ public:
return m_startDate; return m_startDate;
} }
std::vector<ColumnInfo>& columnInfos() std::vector<Column>& columnInfos()
{ {
return m_columnInfos; return m_columnInfos;
} }
const std::vector<ColumnInfo>& columnInfos() const const std::vector<Column>& columnInfos() const
{ {
return m_columnInfos; return m_columnInfos;
} }
@@ -119,7 +119,7 @@ private:
std::string m_origin; std::string m_origin;
std::string m_startDate; 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 isFixedWidthHeader(const std::string& lines);
static bool hasCompleteDataForAllHeaderColumns(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::string> findValidHeaderLines(std::stringstream& streamData);
static std::vector<std::vector<std::string>> splitIntoColumnHeaders(const std::vector<std::string>& headerLines); 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<size_t> columnIndexForWords(const std::string& line);
static std::vector<TableData> mergeEqualTimeSteps(const std::vector<TableData>& tables); 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()) if (columnIndex != m_allResultAddresses.size())
{ {
const ColumnInfo* col = m_asciiParser->columnInfo(columnIndex); const Column* col = m_asciiParser->columnInfo(columnIndex);
if (col && col->dataType == ColumnInfo::NUMERIC) if (col && col->dataType == Column::NUMERIC)
{ {
for (auto& v : col->values) for (auto& v : col->values)
{ {