GncPriceImport Class Reference

The actual PriceImport class It's intended to use in the following sequence of actions: More...

#include <gnc-import-price.hpp>

Public Member Functions
	GncPriceImport (GncImpFileFormat format=GncImpFileFormat::UNKNOWN)
	Constructor for GncPriceImport.
	~GncPriceImport ()
	Destructor for GncPriceImport.
void	file_format (GncImpFileFormat format)
	Sets the file format for the file to import, which may cause the file to be reloaded as well if the previously set file format was different and a filename was already set. More...
GncImpFileFormat	file_format ()
void	over_write (bool over)
bool	over_write ()
void	from_commodity (gnc_commodity *from_commodity)
	Sets a from commodity. More...
gnc_commodity *	from_commodity ()
void	to_currency (gnc_commodity *to_currency)
	Sets a to currency. More...
gnc_commodity *	to_currency ()
void	currency_format (int currency_format)
int	currency_format ()
void	date_format (int date_format)
int	date_format ()
void	encoding (const std::string &encoding)
	Converts raw file data using a new encoding. More...
std::string	encoding ()
void	update_skipped_lines (std::optional< uint32_t > start, std::optional< uint32_t > end, std::optional< bool > alt, std::optional< bool > errors)
uint32_t	skip_start_lines ()
uint32_t	skip_end_lines ()
bool	skip_alt_lines ()
bool	skip_err_lines ()
void	separators (std::string separators)
std::string	separators ()
void	settings (const CsvPriceImpSettings &settings)
bool	save_settings ()
void	settings_name (std::string name)
std::string	settings_name ()
void	load_file (const std::string &filename)
	Loads a file into a GncPriceImport. More...
void	tokenize (bool guessColTypes)
	Splits a file into cells. More...
std::string	verify ()
void	create_prices ()
	This function will attempt to convert all tokenized lines into prices using the column types the user has set. More...
bool	check_for_column_type (GncPricePropType type)
void	set_column_type_price (uint32_t position, GncPricePropType type, bool force=false)
std::vector< GncPricePropType >	column_types_price ()

Data Fields
std::unique_ptr< GncTokenizer >	m_tokenizer
	Will handle file loading/encoding conversion/splitting into fields.
std::vector< parse_line_t >	m_parsed_lines
	source file parsed into a two-dimensional array of strings. More...
int	m_prices_added
int	m_prices_duplicated
int	m_prices_replaced

Detailed Description

The actual PriceImport class It's intended to use in the following sequence of actions:

• set a file format
• load a file
• optionally convert it's encoding
• parse the file into lines, which in turn are split up in to columns the result of this step can be queried from tokenizer
• the user should now map the columns to types, which is stored in column_types
• last step is convert the mapped columns into a list of prices to add

Definition at line 82 of file gnc-import-price.hpp.

Member Function Documentation

create_prices()

void GncPriceImport::create_prices

(

)

This function will attempt to convert all tokenized lines into prices using the column types the user has set.

Creates a list of prices from parsed data.

The parsed data will first be validated. If any errors are found in lines that are marked for processing (ie not marked to skip) this function will throw an error.

Parameters

skip_errors

true skip over lines with errors

Exceptions

throws

std::invalid_argument if data validation or processing fails.

Definition at line 633 of file gnc-import-price.cpp.

{
    /* Start with verifying the current data. */
    auto verify_result = verify();
    if (!verify_result.empty())
        throw std::invalid_argument (verify_result);

    m_prices_added = 0;
    m_prices_duplicated = 0;
    m_prices_replaced = 0;

    /* Iterate over all parsed lines */
    for (auto parsed_lines_it = m_parsed_lines.begin();
            parsed_lines_it != m_parsed_lines.end();
            ++parsed_lines_it)
    {
        /* Skip current line if the user specified so */
        if ((std::get<PL_SKIP>(*parsed_lines_it)))
            continue;

        /* Should not throw anymore, otherwise verify needs revision */
        create_price (parsed_lines_it);
    }
    PINFO("Number of lines is %d, added %d, duplicated %d, replaced %d",
         (int)m_parsed_lines.size(), m_prices_added, m_prices_duplicated, m_prices_replaced);
}

encoding()

void GncPriceImport::encoding

(

const std::string &

encoding

)

Converts raw file data using a new encoding.

This function must be called after load_file only if load_file guessed the wrong encoding.

Parameters

encoding

Encoding that data should be translated using

Definition at line 231 of file gnc-import-price.cpp.

{
    // TODO investigate if we can catch conversion errors and report them
    if (m_tokenizer)
    {
        m_tokenizer->encoding(encoding); // May throw
        try
        {
            tokenize(false);
        }
        catch (...)
        { };
    }

    m_settings.m_encoding = encoding;
}

file_format()

void GncPriceImport::file_format

(

GncImpFileFormat

format

)

Sets the file format for the file to import, which may cause the file to be reloaded as well if the previously set file format was different and a filename was already set.

Parameters

format

the new format to set

Exceptions

std::ifstream::failure

if file reloading fails

Definition at line 87 of file gnc-import-price.cpp.

{
    if (m_tokenizer && m_settings.m_file_format == format)
        return;

    auto new_encoding = std::string("UTF-8");
    auto new_imp_file = std::string();

    // Recover common settings from old tokenizer
    if (m_tokenizer)
    {
        new_encoding = m_tokenizer->encoding();
        new_imp_file = m_tokenizer->current_file();
        if (file_format() == GncImpFileFormat::FIXED_WIDTH)
        {
            auto fwtok = dynamic_cast<GncFwTokenizer*>(m_tokenizer.get());
            if (!fwtok->get_columns().empty())
                m_settings.m_column_widths = fwtok->get_columns();
        }
    }

    m_settings.m_file_format = format;
    m_tokenizer = gnc_tokenizer_factory(m_settings.m_file_format);

    // Set up new tokenizer with common settings
    // recovered from old tokenizer
    m_tokenizer->encoding(new_encoding);
    load_file(new_imp_file);

    // Restore potentially previously set separators or column_widths
    if ((file_format() == GncImpFileFormat::CSV)
        && !m_settings.m_separators.empty())
        separators (m_settings.m_separators);
    else if ((file_format() == GncImpFileFormat::FIXED_WIDTH)
        && !m_settings.m_column_widths.empty())
    {
        auto fwtok = dynamic_cast<GncFwTokenizer*>(m_tokenizer.get());
        fwtok->columns (m_settings.m_column_widths);
    }
}

from_commodity()

void GncPriceImport::from_commodity

(

gnc_commodity *

from_commodity

)

Sets a from commodity.

This is the commodity all import data relates to. When a from commodity is set, there can't be any from columns selected in the import data.

Parameters

from_commodity

pointer to a commodity or NULL.

Definition at line 144 of file gnc-import-price.cpp.

{
    m_settings.m_from_commodity = from_commodity;
    if (m_settings.m_from_commodity)
    {
        auto col_type_sym = std::find (m_settings.m_column_types_price.begin(),
                m_settings.m_column_types_price.end(), GncPricePropType::FROM_SYMBOL);

        if (col_type_sym != m_settings.m_column_types_price.end())
            set_column_type_price (col_type_sym -m_settings.m_column_types_price.begin(),
                            GncPricePropType::NONE);

        auto col_type_name = std::find (m_settings.m_column_types_price.begin(),
                m_settings.m_column_types_price.end(), GncPricePropType::FROM_NAMESPACE);

        if (col_type_name != m_settings.m_column_types_price.end())
            set_column_type_price (col_type_name -m_settings.m_column_types_price.begin(),
                            GncPricePropType::NONE);

        // force a refresh of the to_currency if the from_commodity is changed
        std::vector<GncPricePropType> commodities = { GncPricePropType::TO_CURRENCY };
        reset_formatted_column (commodities);
    }
}

load_file()

void GncPriceImport::load_file

(

const std::string &

filename

)

Loads a file into a GncPriceImport.

This is the first function that must be called after creating a new GncPriceImport. As long as this function didn't run successfully, the importer can't proceed.

Parameters

filename

Name of the file that should be opened

Exceptions

may	throw std::ifstream::failure on any io error

Definition at line 348 of file gnc-import-price.cpp.

{
    /* Get the raw data first and handle an error if one occurs. */
    try
    {
        m_tokenizer->load_file (filename);
        return;
    }
    catch (std::ifstream::failure& ios_err)
    {
        // Just log the error and pass it on the call stack for proper handling
        PWARN ("Error: %s", ios_err.what());
        throw;
    }
}

to_currency()

void GncPriceImport::to_currency

(

gnc_commodity *

to_currency

)

Sets a to currency.

This is the to currency all import data relates to. When a to currency is set, there can't be any to currency columns selected in the import data.

Parameters

to_currency

pointer to a commodity or NULL.

Definition at line 175 of file gnc-import-price.cpp.

{
    m_settings.m_to_currency = to_currency;
    if (m_settings.m_to_currency)
    {
        auto col_type_currency = std::find (m_settings.m_column_types_price.begin(),
                m_settings.m_column_types_price.end(), GncPricePropType::TO_CURRENCY);

        if (col_type_currency != m_settings.m_column_types_price.end())
            set_column_type_price (col_type_currency -m_settings.m_column_types_price.begin(),
                            GncPricePropType::NONE);

        // force a refresh of the from_commodity if the to_currency is changed
        // either namespace or symbol will be sufice
        std::vector<GncPricePropType> commodities = { GncPricePropType::FROM_SYMBOL };
        reset_formatted_column (commodities);
    }
}

tokenize()

void GncPriceImport::tokenize

(

bool

guessColTypes

)

Splits a file into cells.

This requires having an encoding that works (see GncPriceImport::convert_encoding). Tokenizing related options should be set to the user's selections before calling this function. Notes: - this function must be called with guessColTypes set to true once before calling it with guessColTypes set to false.

• if guessColTypes is true, all the column types will be set GncPricePropType::NONE right now as real guessing isn't implemented yet

  Parameters

  guessColTypes

  true to guess what the types of columns are based on the cell contents

  Exceptions

  std::range_error

  if tokenizing failed

Definition at line 375 of file gnc-import-price.cpp.

{
    if (!m_tokenizer)
        return;

    uint32_t max_cols = 0;
    m_tokenizer->tokenize();
    m_parsed_lines.clear();
    for (auto tokenized_line : m_tokenizer->get_tokens())
    {
        auto length = tokenized_line.size();
        if (length > 0)
            m_parsed_lines.push_back (std::make_tuple (tokenized_line, std::string(),
                    std::make_shared<GncImportPrice>(date_format(), currency_format()),
                    false));
        if (length > max_cols)
            max_cols = length;
    }

    /* If it failed, generate an error. */
    if (m_parsed_lines.size() == 0)
    {
        throw (std::range_error ("Tokenizing failed."));
        return;
    }

    m_settings.m_column_types_price.resize(max_cols, GncPricePropType::NONE);

    /* Force reinterpretation of already set columns and/or base_account */
    for (uint32_t i = 0; i < m_settings.m_column_types_price.size(); i++)
        set_column_type_price (i, m_settings.m_column_types_price[i], true);

    if (guessColTypes)
    {
        /* Guess column_types based
         * on the contents of each column. */
        /* TODO Make it actually guess. */
    }
}

Field Documentation

m_parsed_lines

std::vector<parse_line_t> GncPriceImport::m_parsed_lines

source file parsed into a two-dimensional array of strings.

Per line also holds possible error messages and objects with extracted price properties.

Definition at line 142 of file gnc-import-price.hpp.

---

The documentation for this class was generated from the following files:

• gnc-import-price.hpp
• gnc-import-price.cpp