QofSession Struct Reference

Public Member Functions
	QofSessionImpl (QofBook *book=nullptr) noexcept
void	begin (const char *new_uri, SessionOpenMode mode) noexcept
	Begin this session.
void	swap_books (QofSessionImpl &) noexcept
	Swap books with another session.
void	ensure_all_data_loaded () noexcept
void	load (QofPercentageFunc) noexcept
void	save (QofPercentageFunc) noexcept
void	safe_save (QofPercentageFunc) noexcept
bool	save_in_progress () const noexcept
bool	export_session (QofSessionImpl &real_session, QofPercentageFunc) noexcept
bool	events_pending () const noexcept
bool	process_events () const noexcept
void	clear_error () noexcept
QofBackendError	pop_error () noexcept
std::string const &	get_uri () const noexcept
	We return by reference so that a pointer to the data of the string lives long enough to make it back to C code.
QofBackendError	get_error () noexcept
	Returns and clears the local cached error.
const std::string &	get_error_message () const noexcept
QofBook *	get_book () const noexcept
QofBackend *	get_backend () const noexcept
const std::string &	get_file_path () const noexcept
bool	is_saving () const noexcept
void	end () noexcept
	Terminates the current backend.
void	destroy_backend () noexcept

Friends
void	qof_session_load_backend (QofSession *, const char *)
char const *	qof_session_get_uri (QofSession *)
void	qof_session_set_uri (QofSession *, char const *)

Detailed Description

Definition at line 37 of file qofsession.hpp.

Constructor & Destructor Documentation

QofSessionImpl()

QofSession::QofSessionImpl ( QofBook *  book = nullptr )

noexcept

Definition at line 119 of file qofsession.cpp.

  : m_backend {},
    m_book {book},
    m_uri {},
    m_saving {false},
    m_last_err {},
    m_error_message {}
{
}

~QofSessionImpl()

QofSession::~QofSessionImpl ( )

noexcept

Definition at line 129 of file qofsession.cpp.

{
    ENTER ("sess=%p uri=%s", this, m_uri.c_str ());
    end ();
    destroy_backend ();
    qof_book_set_backend (m_book, nullptr);
    qof_book_destroy (m_book);
    m_book = nullptr;
    LEAVE ("sess=%p", this);
}

Member Function Documentation

begin()

void QofSession::begin ( const char *  new_uri, SessionOpenMode  mode  )

noexcept

Begin this session.

Definition at line 251 of file qofsession.cpp.

{
 
 
    ENTER (" sess=%p mode=%d, URI=%s", this, mode, new_uri);
    clear_error ();
    /* Check to see if this session is already open */
    if (m_uri.size ())
    {
        if (ERR_BACKEND_NO_ERR != get_error ())
            push_error (ERR_BACKEND_LOCKED, {});
        LEAVE("push error book is already open ");
        return;
    }
 
    /* seriously invalid */
    if (!new_uri)
    {
        if (ERR_BACKEND_NO_ERR != get_error ())
            push_error (ERR_BACKEND_BAD_URL, {});
        LEAVE("push error missing new_uri");
        return;
    }
 
    char * scheme {g_uri_parse_scheme (new_uri)};
    char * filename {nullptr};
    if (g_strcmp0 (scheme, "file") == 0)
        filename = gnc_uri_get_path(new_uri);
    else if (!scheme)
        filename = g_strdup (new_uri);
 
    if (filename && g_file_test (filename, G_FILE_TEST_IS_DIR))
    {
        if (ERR_BACKEND_NO_ERR == get_error ())
            push_error (ERR_BACKEND_BAD_URL, {});
        g_free (filename);
        g_free (scheme);
        LEAVE("Can't open a directory");
        return;
    }
    /* destroy the old backend */
    destroy_backend ();
    /* Store the session URL  */
    m_uri = new_uri;
    m_creating = mode == SESSION_NEW_STORE || mode == SESSION_NEW_OVERWRITE;
    if (filename)
        load_backend ("file");
    else                       /* access method found, load appropriate backend */
        load_backend (scheme);
    g_free (filename);
    g_free (scheme);
 
    /* No backend was found. That's bad. */
    if (m_backend == nullptr)
    {
        m_uri = {};
        if (ERR_BACKEND_NO_ERR == get_error ())
            push_error (ERR_BACKEND_BAD_URL, {});
        LEAVE (" BAD: no backend: sess=%p book-id=%s",
               this,  new_uri);
        return;
    }
 
    /* If there's a begin method, call that. */
    m_backend->session_begin(this, m_uri.c_str(), mode);
    PINFO ("Done running session_begin on backend");
    QofBackendError const err {m_backend->get_error()};
    auto msg (m_backend->get_message());
    if (err != ERR_BACKEND_NO_ERR)
    {
        m_uri = {};
        push_error (err, msg);
        LEAVE (" backend error %d %s", err, msg.empty() ? "(null)" : msg.c_str());
        return;
    }
    if (!msg.empty())
    {
        PWARN("%s", msg.c_str());
    }
 
    LEAVE (" sess=%p book-id=%s", this,  new_uri);
}

clear_error()

void QofSession::clear_error ( )

noexcept

Definition at line 348 of file qofsession.cpp.

{
    m_last_err = ERR_BACKEND_NO_ERR;
    m_error_message = {};
 
    /* pop the stack on the backend as well. */
    if (auto backend = qof_book_get_backend (m_book))
    {
        QofBackendError err = ERR_BACKEND_NO_ERR;
        do
            err = backend->get_error();
        while (err != ERR_BACKEND_NO_ERR);
    }
}

destroy_backend()

void QofSession::destroy_backend ( )

noexcept

Definition at line 153 of file qofsession.cpp.

{
    if (m_backend)
    {
        clear_error ();
        delete m_backend;
        m_backend = nullptr;
        qof_book_set_backend (m_book, nullptr);
    }
}

end()

void QofSession::end ( )

noexcept

Terminates the current backend.

Definition at line 335 of file qofsession.cpp.

{
    ENTER ("sess=%p uri=%s", this, m_uri.c_str ());
    if (m_backend != nullptr)
        m_backend->session_end();
    clear_error ();
    m_uri.clear();
    LEAVE ("sess=%p uri=%s", this, m_uri.c_str ());
}

ensure_all_data_loaded()

void QofSession::ensure_all_data_loaded ( )

noexcept

Definition at line 495 of file qofsession.cpp.

{
    if (!(m_backend && m_book)) return;
    if (qof_book_get_backend (m_book) != m_backend)
        qof_book_set_backend (m_book, m_backend);
    m_backend->load(m_book, LOAD_TYPE_LOAD_ALL);
    push_error (m_backend->get_error(), {});
}

events_pending()

bool QofSession::events_pending ( ) const

noexcept

Definition at line 519 of file qofsession.cpp.

{
    return false;
}

export_session()

bool QofSession::export_session ( QofSessionImpl &  real_session, QofPercentageFunc  percentage_func  )

noexcept

Definition at line 535 of file qofsession.cpp.

{
    auto real_book = real_session.get_book ();
    ENTER ("tmp_session=%p real_session=%p book=%p uri=%s",
           this, &real_session, real_book, m_uri.c_str ());
 
    /* There must be a backend or else.  (It should always be the file
     * backend too.)
     */
    if (!m_backend) return false;
 
    m_backend->set_percentage(percentage_func);
 
    m_backend->export_coa(real_book);
    auto err = m_backend->get_error();
    if (err != ERR_BACKEND_NO_ERR)
        return false;
    return true;
}

get_book()

QofBook * QofSession::get_book ( ) const

noexcept

Definition at line 400 of file qofsession.cpp.

{
    if (!m_book) return nullptr;
    if (qof_book_is_open (m_book))
        return m_book;
    return nullptr;
}

get_error()

QofBackendError QofSession::get_error ( )

noexcept

Returns and clears the local cached error.

If there is no local error, we check for an error in the backend.

Definition at line 371 of file qofsession.cpp.

{
    /* if we have a local error, return that. */
    if (m_last_err != ERR_BACKEND_NO_ERR)
        return m_last_err;
    auto qof_be = qof_book_get_backend (m_book);
    if (qof_be == nullptr) return ERR_BACKEND_NO_ERR;
 
    m_last_err = qof_be->get_error();
    return m_last_err;
}

get_error_message()

const std::string & QofSession::get_error_message ( ) const

noexcept

Definition at line 384 of file qofsession.cpp.

{
    return m_error_message;
}

get_file_path()

const std::string & QofSession::get_file_path ( ) const

noexcept

Definition at line 415 of file qofsession.cpp.

{
    auto backend = qof_book_get_backend (m_book);
    if (!backend) return empty_string;
    return backend->get_uri();
}

get_uri()

std::string const & QofSession::get_uri ( ) const

noexcept

We return by reference so that a pointer to the data of the string lives long enough to make it back to C code.

Definition at line 423 of file qofsession.cpp.

{
    return m_uri;
}

is_saving()

bool QofSession::is_saving ( ) const

noexcept

Definition at line 429 of file qofsession.cpp.

{
    return m_saving;
}

load()

void QofSession::load ( QofPercentageFunc  percentage_func )

noexcept

Definition at line 199 of file qofsession.cpp.

{
    /* We must have an empty book to load into or bad things will happen. */
    g_return_if_fail(m_book && qof_book_empty(m_book));
 
    if (!m_uri.size ()) return;
    ENTER ("sess=%p uri=%s", this, m_uri.c_str ());
 
    /* At this point, we should are supposed to have a valid book
     * id and a lock on the file. */
    clear_error ();
 
    /* This code should be sufficient to initialize *any* backend,
     * whether http, postgres, or anything else that might come along.
     * Basically, the idea is that by now, a backend has already been
     * created & set up.  At this point, we only need to get the
     * top-level account group out of the backend, and that is a
     * generic, backend-independent operation.
     */
    qof_book_set_backend (m_book, m_backend);
 
    /* Starting the session should result in a bunch of accounts
     * and currencies being downloaded, but probably no transactions;
     * The GUI will need to do a query for that.
     */
    if (m_backend)
    {
        m_backend->set_percentage(percentage_func);
        m_backend->load (m_book, LOAD_TYPE_INITIAL_LOAD);
        push_error (m_backend->get_error(), {});
    }
 
    auto err = get_error ();
    if ((err != ERR_BACKEND_NO_ERR) &&
        (err != ERR_FILEIO_FILE_TOO_OLD) &&
        (err != ERR_FILEIO_NO_ENCODING) &&
        (err != ERR_FILEIO_FILE_UPGRADE) &&
        (err != ERR_SQL_DB_TOO_OLD) &&
        (err != ERR_SQL_DB_TOO_NEW))
    {
        // Something failed, delete and restore new ones.
        destroy_backend();
        qof_book_destroy (m_book);
        m_book = qof_book_new();
        LEAVE ("error from backend %d", get_error ());
        return;
    }
 
    LEAVE ("sess = %p, uri=%s", this, m_uri.c_str ());
}

pop_error()

QofBackendError QofSession::pop_error ( )

noexcept

Definition at line 390 of file qofsession.cpp.

{
    QofBackendError err {get_error ()};
    clear_error ();
    return err;
}

process_events()

bool QofSession::process_events ( ) const

noexcept

Definition at line 525 of file qofsession.cpp.

{
    return false;
}

safe_save()

void QofSession::safe_save ( QofPercentageFunc  percentage_func )

noexcept

Definition at line 478 of file qofsession.cpp.

{
    if (!(m_backend && m_book)) return;
    if (qof_book_get_backend (m_book) != m_backend)
        qof_book_set_backend (m_book, m_backend);
    m_backend->set_percentage(percentage_func);
    m_backend->safe_sync(get_book ());
    auto err = m_backend->get_error();
    auto msg = m_backend->get_message();
    if (err != ERR_BACKEND_NO_ERR)
    {
        m_uri = "";
        push_error (err, msg);
    }
}

save()

void QofSession::save ( QofPercentageFunc  percentage_func )

noexcept

Definition at line 437 of file qofsession.cpp.

{
    if (!qof_book_session_not_saved (m_book)) //Clean book, nothing to do.
        return;
    m_saving = true;
    ENTER ("sess=%p uri=%s", this, m_uri.c_str ());
 
    /* If there is a backend, the book is dirty, and the backend is reachable
     * (i.e. we can communicate with it), then synchronize with the backend.  If
     * we cannot contact the backend (e.g.  because we've gone offline, the
     * network has crashed, etc.)  then raise an error so that the controlling
     * dialog can offer the user a chance to save in a different way.
     */
    if (m_backend)
    {
        /* if invoked as SaveAs(), then backend not yet set */
        if (qof_book_get_backend (m_book) != m_backend)
            qof_book_set_backend (m_book, m_backend);
        m_backend->set_percentage(percentage_func);
        m_backend->sync(m_book);
        auto err = m_backend->get_error();
        if (err != ERR_BACKEND_NO_ERR)
        {
            push_error (err, {});
            m_saving = false;
            return;
        }
        /* If we got to here, then the backend saved everything
        * just fine, and we are done. So return. */
        clear_error ();
        LEAVE("Success");
    }
    else
    {
        push_error (ERR_BACKEND_NO_HANDLER, "failed to load backend");
        LEAVE("error -- No backend!");
    }
    m_saving = false;
}

swap_books()

void QofSession::swap_books ( QofSessionImpl &  other )

noexcept

Swap books with another session.

Definition at line 505 of file qofsession.cpp.

{
    ENTER ("sess1=%p sess2=%p", this, &other);
    // don't swap (that is, double-swap) read_only flags
    if (m_book && other.m_book)
        qof_book_swap_books_readonly (m_book, other.m_book);
    std::swap (m_book, other.m_book);
    auto mybackend = qof_book_get_backend (m_book);
    qof_book_set_backend (m_book, qof_book_get_backend (other.m_book));
    qof_book_set_backend (other.m_book, mybackend);
    LEAVE (" ");
}

Friends And Related Symbol Documentation

qof_session_load_backend

void qof_session_load_backend ( QofSession *  session, const char *  access_method  )

friend

Definition at line 688 of file qofsession.cpp.

{
    session->load_backend (access_method);
}

qof_session_set_uri

void qof_session_set_uri ( QofSession *  session, char const *  uri  )

friend

Definition at line 705 of file qofsession.cpp.

{
    if (!uri)
        session->m_uri = "";
    else
        session->m_uri = uri;
}

---

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

• qofsession.hpp
• qofsession.cpp