diff options
Diffstat (limited to 'src/cache.cc')
| -rw-r--r-- | src/cache.cc | 896 |
1 files changed, 0 insertions, 896 deletions
diff --git a/src/cache.cc b/src/cache.cc deleted file mode 100644 index a085e9a3..00000000 --- a/src/cache.cc +++ /dev/null @@ -1,896 +0,0 @@ -/* - * Copyright (c) 2003-2009, John Wiegley. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * - Neither the name of New Artisans LLC nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "cache.h" -#include "binary.h" - -namespace ledger { - -using namespace binary; - -#if 0 -void read_xact(const char *& data, xact_t * xact) -{ - read_number(data, xact->_date); - read_number(data, xact->_date_eff); - xact->account = accounts[read_long<account_t::ident_t>(data) - 1]; - - unsigned char flag = read_number<unsigned char>(data); - if (flag == 0) { - xact->amount.read(data); - } - else if (flag == 1) { - xact->amount.read(data); - xact->amount_expr = expr_t(); - xact->amount_expr->set_text(read_string(data)); - } - else { - xact->amount_expr = expr_t(); - xact->amount_expr->read(data); - } - - if (read_bool(data)) { - xact->cost = amount_t(); - xact->cost->read(data); - - xact->cost_expr = expr_t(); - xact->cost_expr->read(data); - } else { - xact->cost = none; - } - - read_number(data, xact->state); - xact->set_flags(read_number<xact_t::flags_t>(data)); - xact->add_flags(XACT_BULK_ALLOC); - read_string(data, xact->note); - - // jww (2009-02-01): Use istream_pos_type - xact->beg_pos = read_long<unsigned long>(data); - read_long(data, xact->beg_line); - xact->end_pos = read_long<unsigned long>(data); - read_long(data, xact->end_line); - - xact->data = NULL; - - if (xact->amount_expr) - expr_t::compute_amount(xact->amount_expr.get(), xact->amount, xact); -} - -void write_amount(std::ostream& out, amount_t& amt) -{ - amt.write(out, ++bigints_index); - bigints_count++; -} - -void write_xact(std::ostream& out, xact_t * xact, - bool ignore_calculated) -{ - write_number(out, xact->_date); - write_number(out, xact->_date_eff); - write_long(out, xact->account->ident); - - if (ignore_calculated && xact->has_flags(XACT_CALCULATED)) { - write_number<unsigned char>(out, 0); - amount_t temp; - write_amount(out, temp); - } - else if (xact->amount_expr) { - write_number<unsigned char>(out, 2); - // jww (2008-07-30): Um, is this right? - xact->amount_expr->write(out); - } - else if (! xact->amount_expr->text().empty()) { - write_number<unsigned char>(out, 1); - write_amount(out, xact->amount); - write_string(out, xact->amount_expr->text()); - } - else { - write_number<unsigned char>(out, 0); - write_amount(out, xact->amount); - } - - if (xact->cost && - (! (ignore_calculated && xact->has_flags(XACT_CALCULATED)))) { - write_bool(out, true); - write_amount(out, *xact->cost); - // jww (2008-07-30): What if there is no cost expression? - xact->cost_expr->write(out); - } else { - write_bool(out, false); - } - - write_number(out, xact->state); - write_number(out, xact->flags()); - write_string(out, xact->note); - - write_long(out, xact->beg_pos); - write_long(out, xact->beg_line); - write_long(out, xact->end_pos); - write_long(out, xact->end_line); -} - -void read_entry_base(const char *& data, entry_base_t * entry, - xact_t *& xact_pool, bool& finalize) -{ - read_long(data, entry->src_idx); - // jww (2008-07-31): Use istream_pos_type - entry->beg_pos = read_long<unsigned long>(data); - read_long(data, entry->beg_line); - entry->end_pos = read_long<unsigned long>(data); - read_long(data, entry->end_line); - - bool ignore_calculated = read_bool(data); - - for (std::size_t i = 0, count = read_long<std::size_t>(data); - i < count; - i++) { - new(xact_pool) xact_t; - read_xact(data, xact_pool); - if (ignore_calculated && xact_pool->has_flags(XACT_CALCULATED)) - finalize = true; - entry->add_xact(xact_pool++); - } -} - -void write_entry_base(std::ostream& out, entry_base_t * entry) -{ - write_long(out, entry->src_idx); - write_long(out, entry->beg_pos); - write_long(out, entry->beg_line); - write_long(out, entry->end_pos); - write_long(out, entry->end_line); - - bool ignore_calculated = false; - foreach (transaction_t * xact, entry->xacts) - if (xact->amount_expr) { - ignore_calculated = true; - break; - } - - write_bool(out, ignore_calculated); - - write_long(out, entry->xacts.size()); - foreach (transaction_t * xact, entry->xacts) - write_xact(out, xact, ignore_calculated); -} - -void read_entry(const char *& data, entry_t * entry, - xact_t *& xact_pool, bool& finalize) -{ - read_entry_base(data, entry, xact_pool, finalize); - read_number(data, entry->_date); - read_number(data, entry->_date_eff); - read_string(data, entry->code); - read_string(data, entry->payee); -} - -void write_entry(std::ostream& out, entry_t * entry) -{ - write_entry_base(out, entry); - write_number(out, entry->_date); - write_number(out, entry->_date_eff); - write_string(out, entry->code); - write_string(out, entry->payee); -} - -void read_auto_entry(const char *& data, auto_entry_t * entry, - xact_t *& xact_pool) -{ - bool ignore; - read_entry_base(data, entry, xact_pool, ignore); - - expr_t expr; - expr.read(data); - entry->predicate = item_predicate<xact_t>(expr); -} - -void write_auto_entry(std::ostream& out, auto_entry_t * entry) -{ - write_entry_base(out, entry); - entry->predicate.predicate.write(out); -} - -void read_period_entry(const char *& data, period_entry_t * entry, - xact_t *& xact_pool, bool& finalize) -{ - read_entry_base(data, entry, xact_pool, finalize); - read_string(data, &entry->period_string); - std::istringstream stream(entry->period_string); - entry->period.parse(stream); -} - -void write_period_entry(std::ostream& out, period_entry_t * entry) -{ - write_entry_base(out, entry); - write_string(out, entry->period_string); -} - -commodity_t::base_t * read_commodity_base(const char *& data) -{ - string str; - - read_string(data, str); - - std::auto_ptr<commodity_t::base_t> commodity(new commodity_t::base_t(str)); - - read_string(data, str); - if (! str.empty()) - commodity->name = str; - - read_string(data, str); - if (! str.empty()) - commodity->note = str; - - read_number(data, commodity->precision); - commodity_t::base_t::flags_t flags; - read_number(data, flags); - commodity->set_flags(flags); - - return commodity.release(); -} - -void write_commodity_base(std::ostream& out, commodity_t::base_t * commodity) -{ - // jww (2008-04-22): Not using this anymore? - //commodity->ident = ++base_commodity_index; - - write_string(out, commodity->symbol); - // jww (2008-04-22): What to do with optional members? - write_string(out, *commodity->name); - write_string(out, *commodity->note); - write_number(out, commodity->precision); - write_number(out, commodity->flags()); -} - -void read_commodity_base_extra(const char *& data, - commodity_t::ident_t ident) -{ - commodity_t::base_t * commodity = base_commodities[ident]; - - bool read_history = false; - // jww (2008-07-31): create a function read_size which does - // read_long<std::size_t>. Don't use read_number<std::size_t>, but it - // wastes too much space. - for (std::size_t i = 0, count = read_long<std::size_t>(data); - i < count; - i++) { - datetime_t when; - read_number(data, when); - amount_t amt; - amt.read(data); - - // Upon insertion, amt will be copied, which will cause the amount to be - // duplicated (and thus not lost when the journal's item_pool is deleted). - if (! commodity->history) - commodity->history = commodity_t::history_t(); - commodity->history->prices.insert(commodity_t::history_t::value_type(when, amt)); - - read_history = true; - } - if (read_history) - read_number(data, commodity->history->last_lookup); - - if (read_bool(data)) { - amount_t amt; - amt.read(data); - commodity->smaller = amount_t(amt); - } - - if (read_bool(data)) { - amount_t amt; - amt.read(data); - commodity->larger = amount_t(amt); - } -} - -void write_commodity_base_extra(std::ostream& out, - commodity_t::base_t * commodity) -{ -#if 0 - // jww (2008-04-22): What did bogus_time used to do? - if (commodity->history && commodity->history->bogus_time) - commodity->remove_price(commodity->history->bogus_time); -#endif - - if (! commodity->history) { - write_long<std::size_t>(out, 0); - } else { - write_long<std::size_t>(out, commodity->history->prices.size()); - foreach (commodity_t::history_map::value_type& pair, - commodity->history->prices) { - write_number(out, pair.first); - write_amount(out, pair.second); - } - write_number(out, commodity->history->last_lookup); - } - - if (commodity->smaller) { - write_bool(out, true); - write_amount(out, *commodity->smaller); - } else { - write_bool(out, false); - } - - if (commodity->larger) { - write_bool(out, true); - write_amount(out, *commodity->larger); - } else { - write_bool(out, false); - } -} - -commodity_t * read_commodity(const char *& data) -{ - commodity_t::base_t * base = - base_commodities[read_long<commodity_t::ident_t>(data) - 1]; - - commodity_t * commodity = - new commodity_t(amount_t::current_pool, - shared_ptr<commodity_t::base_t>(base)); - - *commodities_next++ = commodity; - - string str; - read_string(data, str); - if (! str.empty()) - commodity->qualified_symbol = str; - commodity->annotated = false; - - return commodity; -} - -void write_commodity(std::ostream& out, commodity_t * commodity) -{ - commodity->ident = ++commodity_index; - - // jww (2008-04-22): Is this used anymore? - //write_long(out, commodity->base->ident); - // jww (2008-04-22): Optional! - write_string(out, *commodity->qualified_symbol); -} - -commodity_t * read_commodity_annotated(const char *& data) -{ - commodity_t * commodity = - commodities[read_long<commodity_t::ident_t>(data) - 1]; - - annotation_t details; - - string str; - read_string(data, str); - - // This read-and-then-assign causes a new amount to be allocated which does - // not live within the bulk allocation pool, since that pool will be deleted - // *before* the commodities are destroyed. - amount_t amt; - amt.read(data); - details.price = amt; - -#if 0 - // jww (2008-04-22): These are optional members! - read_number(data, details.date); - read_string(data, details.tag); -#endif - - annotated_commodity_t * ann_comm = - new annotated_commodity_t(commodity, details); - *commodities_next++ = ann_comm; - - if (! str.empty()) - ann_comm->qualified_symbol = str; - - return ann_comm; -} - -void write_commodity_annotated(std::ostream& out, - commodity_t * commodity) -{ - commodity->ident = ++commodity_index; - - // jww (2008-04-22): No longer needed? - //write_long(out, commodity->base->ident); - // jww (2008-04-22): Optional! - write_string(out, *commodity->qualified_symbol); - - annotated_commodity_t * ann_comm = - static_cast<annotated_commodity_t *>(commodity); - - // jww (2008-04-22): No longer needed? - //write_long(out, ann_comm->base->ident); - // jww (2008-04-22): Make a write_annotation_details function; and optional! - if (ann_comm->details.price) { - write_bool(out, true); - write_amount(out, *ann_comm->details.price); - } else { - write_bool(out, false); - } - - if (ann_comm->details.date) { - write_bool(out, true); - ann_comm->details.date->write(out); - } else { - write_bool(out, false); - } - - if (ann_comm->details.tag) { - write_bool(out, true); - ann_comm->details.tag->write(out); - } else { - write_bool(out, false); - } -} - -inline -account_t * read_account(const char *& data, account_t * master = NULL) -{ - account_t * acct = new account_t(NULL); - - accounts[account_ident++] = acct; - - account_t::ident_t id; - read_long(data, id); // parent id - if (id == 0xffffffff) - acct->parent = NULL; - else - acct->parent = accounts[id - 1]; - - read_string(data, acct->name); - read_string(data, acct->note); - read_number(data, acct->depth); - - // If all of the subaccounts will be added to a different master - // account, throw away what we've learned about the recorded - // journal's own master account. - - if (master && acct != master) { - checked_delete(acct); - acct = master; - } - - for (std::size_t i = 0, count = read_long<std::size_t>(data); - i < count; - i++) { - account_t * child = read_account(data); - child->parent = acct; - assert(acct != child); - acct->add_account(child); - } - - return acct; -} - -namespace { - inline account_t::ident_t count_accounts(account_t * account) - { - account_t::ident_t count = 1; - - foreach (accounts_map::value_type& pair, account->accounts) - count += count_accounts(pair.second); - - return count; - } -} - -void write_account(std::ostream& out, account_t * account) -{ - account->ident = ++account_ident; - - if (account->parent) - write_long(out, account->parent->ident); - else - write_long<account_t::ident_t>(out, 0xffffffff); - - write_string(out, account->name); - write_string(out, account->note); - write_number(out, account->depth); - - write_number<std::size_t>(out, account->accounts.size()); - - foreach (accounts_map::value_type& pair, account->accounts) - write_account(out, pair.second); -} - -std::size_t read_journal(std::istream& in, - const path& file, - journal_t& journal, - account_t * master) -{ - using namespace binary; - - // Read in the files that participated in this journal, so that they - // can be checked for changes on reading. - - if (! file.empty()) { - for (unsigned short i = 0, count = read_number<unsigned short>(in); - i < count; - i++) { - path pathname = read_string(in); - std::time_t old_mtime; - read_number(in, old_mtime); - struct stat info; - // jww (2008-04-22): can this be done differently now? - stat(pathname.string().c_str(), &info); - if (std::difftime(info.st_mtime, old_mtime) > 0) - return 0; - - sources.push_back(pathname); - } - - // Make sure that the cache uses the same price database, - // otherwise it means that LEDGER_PRICE_DB has been changed, and - // we should ignore this cache file. - if (read_bool(in)) { - string pathname; - read_string(in, pathname); - if (! price_db || - price_db->string() != std::string(pathname)) - return 0; - } - } - - // jww (2008-07-31): bind master to session.master - - if (read_bool(data)) - basket = accounts[read_long<account_t::ident_t>(data) - 1]; - - // Read in the entries and xacts - - for (std::size_t i = 0; i < count; i++) { - new(entry_pool) entry_t; - bool finalize = false; - read_entry(data, entry_pool, xact_pool, finalize); - entry_pool->journal = &journal; - if (finalize && ! entry_pool->finalize()) - continue; - entries.push_back(entry_pool++); - } - - for (std::size_t i = 0; i < auto_count; i++) { - auto_entry_t * auto_entry = new auto_entry_t; - read_auto_entry(data, auto_entry, xact_pool); - auto_entry->journal = &journal; - auto_entries.push_back(auto_entry); - } - - for (std::size_t i = 0; i < period_count; i++) { - period_entry_t * period_entry = new period_entry_t; - bool finalize = false; - read_period_entry(data, period_entry, xact_pool, finalize); - period_entry->journal = &journal; - if (finalize && ! period_entry->finalize()) - continue; - period_entries.push_back(period_entry); - } - - VERIFY(journal.valid()); - - return count; -} - -std::pair<std::size_t, std::size_t> -write_journal(std::ostream& out, const journal_t& journal) -{ - using namespace binary; - - // Write out the files that participated in this journal, so that - // they can be checked for changes on reading. - - if (sources.empty()) { - write_number<unsigned short>(out, 0); - } else { - write_number<unsigned short>(out, sources.size()); - foreach (const path& path, sources) { - write_string(out, path.string()); - struct stat info; - stat(path.string().c_str(), &info); - write_number(out, std::time_t(info.st_mtime)); - } - - // Write out the price database that relates to this data file, so - // that if it ever changes the cache can be invalidated. - if (price_db) { - write_bool(out, true); - write_string(out, price_db->string()); - } else { - write_bool(out, false); - } - } - - // Write out the basket accounts - - if (basket) { - write_bool(out, true); - write_long(out, basket->ident); - } else { - write_bool(out, false); - } - - // Write out the entries and xacts - - std::size_t this_entry_count = 0; - std::size_t this_xact_count = 0; - - foreach (entry_t * entry, entries) { - write_entry(out, entry); - - this_entry_count++; - this_xact_count += entry->xacts.size(); - } - - foreach (auto_entry_t * entry, auto_entries) { - write_auto_entry(out, entry); - - this_entry_count++; - this_xact_count += entry->xacts.size(); - } - - foreach (period_entry_t * entry, period_entries) { - write_period_entry(out, entry); - - this_entry_count++; - this_xact_count += entry->xacts.size(); - } - - return std::pair<std::size_t, std::size_t>(this_entry_count, - this_xact_count); -} - -std::size_t read_session(std::istream& in, - const path& file, - session_t& session) -{ - using namespace binary; - - // Read all of the data in at once, so that we're just dealing with - // a big data buffer. - - std::size_t data_size = read_number<std::size_t>(in); - - scoped_array<char> data_pool(new char[data_size]); - - in.read(data_pool, data_size); - - const char * data = data_pool.get(); - - // Read in the accounts - - accounts.resize(read_number<std::size_t>(data)); - account_ident = 0; - - if (session.master) - checked_delete(session.master); - session.master = read_account(data); - - // Allocate the memory needed for the entries, xacts and bigints in one - // large block, which is then chopped up and custom constructed as - // necessary. - - entry_count = read_number<std::size_t>(data); - auto_entry_count = read_number<std::size_t>(data); - period_entry_count = read_number<std::size_t>(data); - xact_count = read_number<std::size_t>(data); - bigints_count = read_number<std::size_t>(data); - -#define ENTRIES_SIZE (sizeof(entry_t) * entry_count) -#define XACTS_SIZE (sizeof(xact_t) * xact_count) -#define BIGINTS_SIZE (amount_t::sizeof_bigint_t() * bigints_count) - -#define ENTRIES_OFFSET 0 -#define XACTS_OFFSET ENTRIES_SIZE -#define BIGINTS_OFFSET (ENTRIES_SIZE + XACTS_SIZE) - - item_pool.reset(new char[ENTRIES_SIZE + XACTS_SIZE + BIGINTS_SIZE]); - - entry_pool = reinterpret_cast<entry_t *>(item_pool.get() + ENTRIES_OFFSET); - xact_pool = reinterpret_cast<xact_t *>(item_pool.get() + XACTS_OFFSET); - bigints = item_pool.get() + BIGINTS_OFFSET; - bigints_next = bigints; - bigint_ident = 0; - -#if 0 - // Read in the base commodities and the derived commodities - - base_commodity_count = read_number<std::size_t>(data); - base_commodities.resize(base_commodity_count); - - for (std::size_t i = 0; i < base_commodity_count; i++) { - commodity_t::base_t * base = read_commodity_base(data); - session.commodity_pool->commodities.push_back(base); - - std::pair<base_commodities_map::iterator, bool> result = - commodity_base_t::commodities.insert - (base_commodities_pair(commodity->symbol, commodity)); - if (! result.second) { - base_commodities_map::iterator c = - commodity_t::base_t::commodities.find(commodity->symbol); - - // It's possible the user might have used a commodity in a value - // expression passed to an option, we'll just override the flags, but - // keep the commodity pointer intact. - if (c == commodity_t::base_t::commodities.end()) - throw_(cache_error, "Failed to read base commodity from cache: " - << commodity->symbol); - - (*c).second->name = commodity->name; - (*c).second->note = commodity->note; - (*c).second->precision = commodity->precision; - (*c).second->flags = commodity->flags; - - if ((*c).second->smaller) - checked_delete((*c).second->smaller); - (*c).second->smaller = commodity->smaller; - if ((*c).second->larger) - checked_delete((*c).second->larger); - (*c).second->larger = commodity->larger; - - *(base_commodities_next - 1) = (*c).second; - - checked_delete(commodity); - } - } - - commodity_count = read_number<std::size_t>(data); - commodities.resize(commodity_count); - - for (std::size_t i = 0; i < commodity_count; i++) { - commodity_t * commodity; - string mapping_key; - - if (! read_bool(data)) { - commodity = read_commodity(data); - mapping_key = commodity->base->symbol; - } else { - read_string(data, mapping_key); - commodity = read_commodity_annotated(data); - } - - session.commodity_pool->commodities.push_back(commodity); - - if (! result.second) { - commodities_map::iterator c = - commodity_t::commodities.find(mapping_key); - if (c == commodity_t::commodities.end()) - throw_(cache_error, "Failed to read commodity from cache: " - << commodity->symbol()); - - *(commodities_next - 1) = (*c).second; - checked_delete(commodity); - } - } - - for (std::size_t i = 0; i < base_commodity_count; i++) - read_commodity_base_extra(data, i); - - commodity_t::ident_t ident = read_number<commodity_t::ident_t>(data); - if (ident == 0xffffffff || ident == 0) - session.commodity_pool->default_commodity = NULL; - else - session.commodity_pool->default_commodity = commodities[ident - 1]; -#endif - - // Clean up and return the number of entries read - - accounts.clear(); - commodities.clear(); - - VERIFY(session.valid()); - - return count; -} - -void write_session(std::ostream& out, session_t& session) -{ - using namespace binary; - - write_number_nocheck(out, binary_magic_number); - write_number_nocheck(out, format_version); - - // This number gets patched at the end of the function - ostream_pos_type data_val = out.tellp(); - write_number<std::size_t>(out, 0); - - // Write out the accounts - - write_number<std::size_t>(out, count_accounts(session.master)); - write_account(out, session.master); - - // Write out the number of entries, xacts, and amounts - - write_number<std::size_t>(out, entries.size()); - write_number<std::size_t>(out, auto_entries.size()); - write_number<std::size_t>(out, period_entries.size()); - - // These two numbers get patched at the end of the function - ostream_pos_type xacts_val = out.tellp(); - write_number<std::size_t>(out, 0); - ostream_pos_type bigints_val = out.tellp(); - write_number<std::size_t>(out, 0); - - bigint_ident = 0; - -#if 0 - // Write out the commodities - // jww (2008-04-22): This whole section needs to be reworked - - write_number<std::size_t>(out, session.commodity_pool->commodities.size()); - write_number<std::size_t>(out, session.commodity_pool->commodities.size()); - - for (base_commodities_map::value_type pair, commodity_t::base_t::commodities) - write_commodity_base(out, pair.second); - - write_number<commodity_t::ident_t> - (out, commodity_t::commodities.size()); - - for (commodities_map::value_type pair, commodity_t::commodities) { - if (! pair.second->annotated) { - write_bool(out, false); - write_commodity(out, pair.second); - } - } - - for (commodities_map::value_type pair, commodity_t::commodities) { - if (pair.second->annotated) { - write_bool(out, true); - write_string(out, pair.first); // the mapping key - write_commodity_annotated(out, pair.second); - } - } - - // Write out the history and smaller/larger convertible links after - // both the base and the main commodities have been written, since - // the amounts in both will refer to the mains. - - for (base_commodities_map::const_iterator i = - commodity_t::base_t::commodities.begin(); - i != commodity_t::base_t::commodities.end(); - i++) - write_commodity_base_extra(out, (*i).second); - - if (commodity_t::default_commodity) - write_number(out, commodity_t::default_commodity->ident); - else - write_number<commodity_t::ident_t>(out, 0xffffffff); -#endif - - // Back-patch several counts which were not known beforehand - - out.seekp(data_val); - write_number<std::size_t>(out, (static_cast<std::size_t>(out.tellp()) - - static_cast<std::size_t>(data_val) - - sizeof(std::size_t))); - out.seekp(xacts_val); - write_number<std::size_t>(out, xact_count); - out.seekp(bigints_val); - write_number<std::size_t>(out, bigints_count); -} -#endif - -} // namespace ledger |