GncTxImport Class Reference

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

#include <gnc-import-tx.hpp>

Public Member Functions
	GncTxImport (GncImpFileFormat format=GncImpFileFormat::UNKNOWN)
	Constructor for GncTxImport.
	~GncTxImport ()
	Destructor for GncTxImport.
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.
GncImpFileFormat	file_format ()
void	multi_split (bool multi_split)
	Toggles the multi-split state of the importer and will subsequently sanitize the column_types list.
bool	multi_split ()
void	base_account (Account *base_account)
	Sets a base account.
Account *	base_account ()
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.
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	enable_escape (bool enable)
bool	enable_escape ()
void	settings (const CsvTransImpSettings &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 GncTxImport.
void	tokenize (bool guessColTypes)
	Splits a file into cells.
std::string	verify (bool with_acct_errors)
void	create_transactions ()
	This function will attempt to convert all tokenized lines into transactions using the column types the user has set.
bool	check_for_column_type (GncTransPropType type)
void	set_column_type (uint32_t position, GncTransPropType type, bool force=false)
std::vector< GncTransPropType >	column_types ()
std::set< std::string >	accounts ()

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.
std::multimap< time64, std::shared_ptr< DraftTransaction > >	m_transactions
	map of transaction objects created from parsed_lines and column_types, ordered by date

Detailed Description

The actual TxImport 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 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 transactions
• this list will then be passed on the generic importer for further processing

Definition at line 104 of file gnc-import-tx.hpp.

Constructor & Destructor Documentation

GncTxImport()

GncTxImport::GncTxImport

(

GncImpFileFormat

format = GncImpFileFormat::UNKNOWN

)

Constructor for GncTxImport.

Definition at line 65 of file gnc-import-tx.cpp.

{
    /* All of the data pointers are initially NULL. This is so that, if
     * gnc_csv_parse_data_free is called before all of the data is
     * initialized, only the data that needs to be freed is freed. */
    m_skip_errors = false;
    file_format(m_settings.m_file_format = format);
}

~GncTxImport()

GncTxImport::~GncTxImport

(

)

Destructor for GncTxImport.

Definition at line 76 of file gnc-import-tx.cpp.

{
}

Member Function Documentation

accounts()

std::set< std::string > GncTxImport::accounts

(

)

Definition at line 926 of file gnc-import-tx.cpp.

{
    auto accts = std::set<std::string>();
    auto acct_col_it = std::find (m_settings.m_column_types.begin(),
                           m_settings.m_column_types.end(), GncTransPropType::ACCOUNT);
    uint32_t acct_col = acct_col_it - m_settings.m_column_types.begin();
    auto tacct_col_it = std::find (m_settings.m_column_types.begin(),
                           m_settings.m_column_types.end(), GncTransPropType::TACCOUNT);
    uint32_t tacct_col = tacct_col_it - m_settings.m_column_types.begin();
 
    /* Iterate over all parsed lines */
    for (auto parsed_line : m_parsed_lines)
    {
        /* Skip current line if the user specified so */
        if ((std::get<PL_SKIP>(parsed_line)))
            continue;
 
        auto col_strs = std::get<PL_INPUT>(parsed_line);
        if ((acct_col_it != m_settings.m_column_types.end()) &&
            (acct_col < col_strs.size()) &&
            !col_strs[acct_col].empty())
            accts.insert(col_strs[acct_col]);
        if ((tacct_col_it != m_settings.m_column_types.end()) &&
            (tacct_col < col_strs.size()) &&
            !col_strs[tacct_col].empty())
            accts.insert(col_strs[tacct_col]);
    }
 
    return accts;
}

base_account() [1/2]

Account * GncTxImport::base_account

(

)

Definition at line 211 of file gnc-import-tx.cpp.

{ return m_settings.m_base_account; }

base_account() [2/2]

void GncTxImport::base_account

(

Account *

base_account

)

Sets a base account.

This is the account all import data relates to. As such at least one split of each transaction that will be generated will be in this account. When a base account is set, there can't be an account column selected in the import data. In multi-split mode the user has to select an account column so in that mode the base_account can't be set.

Parameters

base_account

Pointer to an account or NULL.

Definition at line 180 of file gnc-import-tx.cpp.

{
    if (m_settings.m_multi_split)
    {
        m_settings.m_base_account = nullptr;
        return;
    }
 
    auto base_account_is_new = m_settings.m_base_account == nullptr;
    m_settings.m_base_account = base_account;
 
    if (m_settings.m_base_account)
    {
        auto col_type_it = std::find (m_settings.m_column_types.begin(),
                m_settings.m_column_types.end(), GncTransPropType::ACCOUNT);
        if (col_type_it != m_settings.m_column_types.end())
            set_column_type(col_type_it - m_settings.m_column_types.begin(),
                            GncTransPropType::NONE);
 
        if (base_account_is_new)
        {
            /* Set default account for each line's split properties */
            for (auto line : m_parsed_lines)
                std::get<PL_PRESPLIT>(line)->set_account (m_settings.m_base_account);
        }
 
        /* Reparse all of the lines with the new base account's commodity. */
        tokenize(false);
    }
}

check_for_column_type()

bool GncTxImport::check_for_column_type

(

GncTransPropType

type

)

Definition at line 768 of file gnc-import-tx.cpp.

{
    return (std::find (m_settings.m_column_types.begin(),
                       m_settings.m_column_types.end(), type)
                        != m_settings.m_column_types.end());
}

column_types()

std::vector< GncTransPropType > GncTxImport::column_types

(

)

Definition at line 920 of file gnc-import-tx.cpp.

{
    return m_settings.m_column_types;
}

create_transactions()

void GncTxImport::create_transactions

(

)

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

Creates a list of transactions 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 740 of file gnc-import-tx.cpp.

{
    /* Start with verifying the current data. */
    auto verify_result = verify (true);
    if (!verify_result.empty())
        throw std::invalid_argument (verify_result);
 
    /* Drop all existing draft transactions */
    m_transactions.clear();
 
    m_parent = nullptr;
 
    /* 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_transaction (parsed_lines_it);
    }
}

currency_format() [1/2]

int GncTxImport::currency_format

(

)

Definition at line 240 of file gnc-import-tx.cpp.

{ return m_settings.m_currency_format; }

currency_format() [2/2]

void GncTxImport::currency_format

(

int

currency_format

)

Definition at line 227 of file gnc-import-tx.cpp.

{
    m_settings.m_currency_format = currency_format;
 
    /* Reparse all currency related columns */
    std::vector<GncTransPropType> commodities = {
        GncTransPropType::AMOUNT,
        GncTransPropType::AMOUNT_NEG,
        GncTransPropType::TAMOUNT,
        GncTransPropType::TAMOUNT_NEG,
        GncTransPropType::PRICE};
    reset_formatted_column (commodities);
}

date_format() [1/2]

int GncTxImport::date_format

(

)

Definition at line 252 of file gnc-import-tx.cpp.

{ return m_settings.m_date_format; }

date_format() [2/2]

void GncTxImport::date_format

(

int

date_format

)

Definition at line 242 of file gnc-import-tx.cpp.

{
    m_settings.m_date_format = date_format;
 
    /* Reparse all date related columns */
    std::vector<GncTransPropType> dates = { GncTransPropType::DATE,
            GncTransPropType::REC_DATE,
            GncTransPropType::TREC_DATE};
    reset_formatted_column (dates);
}

enable_escape() [1/2]

bool GncTxImport::enable_escape

(

)

Definition at line 327 of file gnc-import-tx.cpp.

{ return m_settings.m_enable_escape; }

enable_escape() [2/2]

void GncTxImport::enable_escape

(

bool

enable

)

Definition at line 319 of file gnc-import-tx.cpp.

{
    if (file_format() != GncImpFileFormat::CSV)
        return;
    m_settings.m_enable_escape = enable;
    auto csvtok = dynamic_cast<GncCsvTokenizer*>(m_tokenizer.get());
    csvtok->set_enable_escape (enable);
}

encoding() [1/2]

std::string GncTxImport::encoding

(

)

Definition at line 277 of file gnc-import-tx.cpp.

{ return m_settings.m_encoding; }

encoding() [2/2]

void GncTxImport::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 259 of file gnc-import-tx.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() [1/2]

GncImpFileFormat GncTxImport::file_format

(

)

Definition at line 132 of file gnc-import-tx.cpp.

{
    return m_settings.m_file_format;
}

file_format() [2/2]

void GncTxImport::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-tx.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)
    {
        if (!m_settings.m_separators.empty())
            separators (m_settings.m_separators);
        enable_escape (m_settings.m_enable_escape);
    }
    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);
    }
 
}

load_file()

void GncTxImport::load_file

(

const std::string &

filename

)

Loads a file into a GncTxImport.

This is the first function that must be called after creating a new GncTxImport. 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 393 of file gnc-import-tx.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;
    }
}

multi_split() [1/2]

bool GncTxImport::multi_split

(

)

Definition at line 169 of file gnc-import-tx.cpp.

{ return m_settings.m_multi_split; }

multi_split() [2/2]

void GncTxImport::multi_split

(

bool

multi_split

)

Toggles the multi-split state of the importer and will subsequently sanitize the column_types list.

All types that don't make sense in the new state are reset to type GncTransPropType::NONE. Additionally the interpretation of the columns with transaction properties changes when changing multi-split mode. So this function will force a reparsing of the transaction properties (if there are any) by resetting the first column with a transaction property it encounters.

Parameters

multi_split

Boolean value with desired state (multi-split vs two-split).

Definition at line 148 of file gnc-import-tx.cpp.

{
    auto trans_prop_seen = false;
    m_settings.m_multi_split = multi_split;
    for (uint32_t i = 0; i < m_settings.m_column_types.size(); i++)
    {
        auto old_prop = m_settings.m_column_types[i];
        auto is_trans_prop = ((old_prop > GncTransPropType::NONE)
                && (old_prop <= GncTransPropType::TRANS_PROPS));
        auto san_prop = sanitize_trans_prop (old_prop, m_settings.m_multi_split);
        if (san_prop != old_prop)
            set_column_type (i, san_prop);
        else if (is_trans_prop && !trans_prop_seen)
            set_column_type (i, old_prop, true);
        trans_prop_seen |= is_trans_prop;
 
    }
    if (m_settings.m_multi_split)
        m_settings.m_base_account = nullptr;
}

save_settings()

bool GncTxImport::save_settings

(

)

Definition at line 365 of file gnc-import-tx.cpp.

{
 
    if (preset_is_reserved_name (m_settings.m_name))
        return true;
 
    /* separators are already copied to m_settings in the separators
     * function above. However this is not the case for the column
     * widths in fw mode, so do this now.
     */
    if (file_format() == GncImpFileFormat::FIXED_WIDTH)
    {
        auto fwtok = dynamic_cast<GncFwTokenizer*>(m_tokenizer.get());
        m_settings.m_column_widths = fwtok->get_columns();
    }
 
    return m_settings.save();
}

separators() [1/2]

std::string GncTxImport::separators

(

)

Definition at line 317 of file gnc-import-tx.cpp.

{ return m_settings.m_separators; }

separators() [2/2]

void GncTxImport::separators

(

std::string

separators

)

Definition at line 307 of file gnc-import-tx.cpp.

{
    if (file_format() != GncImpFileFormat::CSV)
        return;
 
    m_settings.m_separators = separators;
    auto csvtok = dynamic_cast<GncCsvTokenizer*>(m_tokenizer.get());
    csvtok->set_separators (separators);
 
}

set_column_type()

void GncTxImport::set_column_type	(	uint32_t	position,
		GncTransPropType	type,
		bool	force = false
	)

Definition at line 889 of file gnc-import-tx.cpp.

{
    if (position >= m_settings.m_column_types.size())
        return;
 
    auto old_type = m_settings.m_column_types[position];
    if ((type == old_type) && !force)
        return; /* Nothing to do */
 
    // Column types except amount and negated amount should be unique,
    // so remove any previous occurrence of the new type
    if (!is_multi_col_prop(type))
        std::replace(m_settings.m_column_types.begin(), m_settings.m_column_types.end(),
            type, GncTransPropType::NONE);
 
    m_settings.m_column_types.at (position) = type;
 
    // If the user has set an Account column, we can't have a base account set
    if (type == GncTransPropType::ACCOUNT)
        base_account (nullptr);
 
    /* Update the preparsed data */
    m_parent = nullptr;
    m_multi_currency = false;
    for (auto& parsed_lines_it: m_parsed_lines)
    {
        update_pre_trans_props (parsed_lines_it, position, old_type, type);
        update_pre_split_props (parsed_lines_it, position, old_type, type);
    }
}

settings()

void GncTxImport::settings

(

const CsvTransImpSettings &

settings

)

Definition at line 329 of file gnc-import-tx.cpp.

{
    /* First apply file format as this may recreate the tokenizer */
    file_format (settings.m_file_format);
    /* Only then apply the other settings */
    m_settings = settings;
    multi_split (m_settings.m_multi_split);
    base_account (m_settings.m_base_account);
    encoding (m_settings.m_encoding);
 
    if (file_format() == GncImpFileFormat::CSV)
    {
        separators (m_settings.m_separators);
        enable_escape (m_settings.m_enable_escape);
    }
    else if (file_format() == GncImpFileFormat::FIXED_WIDTH)
    {
        auto fwtok = dynamic_cast<GncFwTokenizer*>(m_tokenizer.get());
        fwtok->columns (m_settings.m_column_widths);
    }
    try
    {
        tokenize(false);
    }
    catch (...)
    { };
 
    /* Tokenizing will clear column types, reset them here
     * based on the loaded settings.
     */
    std::copy_n (settings.m_column_types.begin(),
            std::min (m_settings.m_column_types.size(), settings.m_column_types.size()),
            m_settings.m_column_types.begin());
 
}

settings_name() [1/2]

std::string GncTxImport::settings_name

(

)

Definition at line 385 of file gnc-import-tx.cpp.

{ return m_settings.m_name; }

settings_name() [2/2]

void GncTxImport::settings_name

(

std::string

name

)

Definition at line 384 of file gnc-import-tx.cpp.

{ m_settings.m_name = name; }

skip_alt_lines()

bool GncTxImport::skip_alt_lines

(

)

Definition at line 304 of file gnc-import-tx.cpp.

{ return m_settings.m_skip_alt_lines; }

skip_end_lines()

uint32_t GncTxImport::skip_end_lines

(

)

Definition at line 303 of file gnc-import-tx.cpp.

{ return m_settings.m_skip_end_lines; }

skip_err_lines()

bool GncTxImport::skip_err_lines

(

)

Definition at line 305 of file gnc-import-tx.cpp.

{ return m_skip_errors; }

skip_start_lines()

uint32_t GncTxImport::skip_start_lines

(

)

Definition at line 302 of file gnc-import-tx.cpp.

{ return m_settings.m_skip_start_lines; }

tokenize()

void GncTxImport::tokenize

(

bool

guessColTypes

)

Splits a file into cells.

This requires having an encoding that works (see GncTxImport::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 GncTransPropType::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 421 of file gnc-import-tx.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)
        {
            auto pretrans = std::make_shared<GncPreTrans>(date_format(), m_settings.m_multi_split);
            auto presplit = std::make_shared<GncPreSplit>(date_format(), currency_format());
            presplit->set_pre_trans (std::move (pretrans));
            m_parsed_lines.push_back (std::make_tuple (tokenized_line, ErrMap(),
                                      presplit->get_pre_trans(), std::move (presplit), false));
        }
        if (length > max_cols)
            max_cols = length;
    }
 
    /* If it failed, generate an error. */
    if (m_parsed_lines.size() == 0)
    {
        throw (std::range_error (N_("There was an error parsing the file.")));
        return;
    }
 
    m_settings.m_column_types.resize(max_cols, GncTransPropType::NONE);
 
    /* Force reinterpretation of already set columns and/or base_account */
    for (uint32_t i = 0; i < m_settings.m_column_types.size(); i++)
        set_column_type (i, m_settings.m_column_types[i], true);
    if (m_settings.m_base_account)
    {
        for (auto line : m_parsed_lines)
            std::get<PL_PRESPLIT>(line)->set_account (m_settings.m_base_account);
    }
 
    if (guessColTypes)
    {
        /* Guess column_types based
         * on the contents of each column. */
        /* TODO Make it actually guess. */
    }
}

update_skipped_lines()

void GncTxImport::update_skipped_lines	(	std::optional< uint32_t >	start,
		std::optional< uint32_t >	end,
		std::optional< bool >	alt,
		std::optional< bool >	errors
	)

Definition at line 279 of file gnc-import-tx.cpp.

{
    if (start)
        m_settings.m_skip_start_lines = *start;
    if (end)
        m_settings.m_skip_end_lines = *end;
    if (alt)
        m_settings.m_skip_alt_lines = *alt;
    if (errors)
        m_skip_errors = *errors;
 
    for (uint32_t i = 0; i < m_parsed_lines.size(); i++)
    {
        std::get<PL_SKIP>(m_parsed_lines[i]) =
            ((i < skip_start_lines()) ||             // start rows to skip
             (i >= m_parsed_lines.size() - skip_end_lines()) ||          // end rows to skip
             (((i - skip_start_lines()) % 2 == 1) && // skip every second row...
                  skip_alt_lines()) ||                   // ...if requested
             (m_skip_errors && !std::get<PL_ERROR>(m_parsed_lines[i]).empty())); // skip lines with errors
    }
}

verify()

std::string GncTxImport::verify

(

bool

with_acct_errors

)

Definition at line 568 of file gnc-import-tx.cpp.

{
    auto newline = std::string();
    auto error_msg = ErrorList();
 
    /* Check if the import file did actually contain any information */
    if (m_parsed_lines.size() == 0)
    {
        error_msg.add_error(_("No valid data found in the selected file. It may be empty or the selected encoding is wrong."));
        return error_msg.str();
    }
 
    /* Check if at least one line is selected for importing */
    auto skip_alt_offset = m_settings.m_skip_alt_lines ? 1 : 0;
    if (m_settings.m_skip_start_lines + m_settings.m_skip_end_lines + skip_alt_offset >= m_parsed_lines.size())
    {
        error_msg.add_error(_("No lines are selected for importing. Please reduce the number of lines to skip."));
        return error_msg.str();
    }
 
    verify_column_selections (error_msg);
 
    update_skipped_lines (std::nullopt, std::nullopt, std::nullopt, std::nullopt);
 
    auto have_line_errors = false;
    for (auto line : m_parsed_lines)
    {
        auto errors = std::get<PL_ERROR>(line);
        if (std::get<PL_SKIP>(line))
            continue;
        if (with_acct_errors && !errors.empty())
        {
            have_line_errors = true;
            break;
        }
        auto non_acct_error = [](ErrPair curr_err)
        {
            return !((curr_err.first == GncTransPropType::ACCOUNT) ||
                     (curr_err.first == GncTransPropType::TACCOUNT));
        };
        if (!with_acct_errors &&
            std::any_of(errors.cbegin(), errors.cend(), non_acct_error))
        {
            have_line_errors = true;
            break;
        }
    }
 
    if (have_line_errors)
        error_msg.add_error( _("Not all fields could be parsed. Please correct the issues reported for each line or adjust the lines to skip."));
 
    return error_msg.str();
}

Field Documentation

m_parsed_lines

std::vector<parse_line_t> GncTxImport::m_parsed_lines

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

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

Definition at line 166 of file gnc-import-tx.hpp.

m_tokenizer

std::unique_ptr<GncTokenizer> GncTxImport::m_tokenizer

Will handle file loading/encoding conversion/splitting into fields.

Definition at line 165 of file gnc-import-tx.hpp.

m_transactions

std::multimap<time64, std::shared_ptr<DraftTransaction> > GncTxImport::m_transactions

map of transaction objects created from parsed_lines and column_types, ordered by date

Definition at line 169 of file gnc-import-tx.hpp.

---

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

• gnc-import-tx.hpp
• gnc-import-tx.cpp