328 lines
8.7 KiB
C++
328 lines
8.7 KiB
C++
/**
|
|
* @file commodity.h
|
|
* @author John Wiegley
|
|
* @date Wed Apr 18 22:05:53 2007
|
|
*
|
|
* @brief Types for handling commodities.
|
|
*
|
|
* This file contains one of the most basic types in Ledger:
|
|
* commodity_t, and its derived cousin, annotated_commodity_t.
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2003-2007, 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.
|
|
*/
|
|
|
|
#ifndef _COMMODITY_H
|
|
#define _COMMODITY_H
|
|
|
|
namespace ledger {
|
|
|
|
#define COMMODITY_STYLE_DEFAULTS 0x0000
|
|
#define COMMODITY_STYLE_SUFFIXED 0x0001
|
|
#define COMMODITY_STYLE_SEPARATED 0x0002
|
|
#define COMMODITY_STYLE_EUROPEAN 0x0004
|
|
#define COMMODITY_STYLE_THOUSANDS 0x0008
|
|
#define COMMODITY_STYLE_NOMARKET 0x0010
|
|
#define COMMODITY_STYLE_BUILTIN 0x0020
|
|
|
|
typedef std::map<const moment_t, amount_t> history_map;
|
|
typedef std::pair<const moment_t, amount_t> history_pair;
|
|
|
|
class commodity_base_t;
|
|
|
|
typedef std::map<const string, commodity_base_t *> base_commodities_map;
|
|
typedef std::pair<const string, commodity_base_t *> base_commodities_pair;
|
|
|
|
class commodity_base_t
|
|
{
|
|
public:
|
|
friend class commodity_t;
|
|
friend class annotated_commodity_t;
|
|
|
|
typedef unsigned long ident_t;
|
|
|
|
ident_t ident;
|
|
string name;
|
|
string note;
|
|
unsigned char precision;
|
|
unsigned char flags;
|
|
amount_t * smaller;
|
|
amount_t * larger;
|
|
|
|
commodity_base_t()
|
|
: precision(0), flags(COMMODITY_STYLE_DEFAULTS),
|
|
smaller(NULL), larger(NULL), history(NULL) {
|
|
TRACE_CTOR(commodity_base_t, "");
|
|
}
|
|
|
|
commodity_base_t(const commodity_base_t&) {
|
|
TRACE_CTOR(commodity_base_t, "copy");
|
|
assert(0);
|
|
}
|
|
|
|
commodity_base_t(const string& _symbol,
|
|
unsigned int _precision = 0,
|
|
unsigned int _flags = COMMODITY_STYLE_DEFAULTS)
|
|
: precision(_precision), flags(_flags),
|
|
smaller(NULL), larger(NULL), symbol(_symbol), history(NULL) {
|
|
TRACE_CTOR(commodity_base_t, "const string&, unsigned int, unsigned int");
|
|
}
|
|
|
|
~commodity_base_t() {
|
|
TRACE_DTOR(commodity_base_t);
|
|
if (history) checked_delete(history);
|
|
if (smaller) checked_delete(smaller);
|
|
if (larger) checked_delete(larger);
|
|
}
|
|
|
|
static base_commodities_map commodities;
|
|
static commodity_base_t * create(const string& symbol);
|
|
|
|
string symbol;
|
|
|
|
struct history_t {
|
|
history_map prices;
|
|
ptime last_lookup;
|
|
history_t() : last_lookup() {}
|
|
};
|
|
history_t * history;
|
|
|
|
void add_price(const moment_t& date, const amount_t& price);
|
|
bool remove_price(const moment_t& date);
|
|
amount_t value(const moment_t& moment = now);
|
|
|
|
class updater_t {
|
|
public:
|
|
virtual ~updater_t() {}
|
|
virtual void operator()(commodity_base_t& commodity,
|
|
const moment_t& moment,
|
|
const moment_t& date,
|
|
const moment_t& last,
|
|
amount_t& price) = 0;
|
|
};
|
|
friend class updater_t;
|
|
|
|
static updater_t * updater;
|
|
};
|
|
|
|
typedef std::map<const string, commodity_t *> commodities_map;
|
|
typedef std::pair<const string, commodity_t *> commodities_pair;
|
|
|
|
typedef std::vector<commodity_t *> commodities_array;
|
|
|
|
class commodity_t
|
|
{
|
|
friend class annotated_commodity_t;
|
|
|
|
public:
|
|
// This map remembers all commodities that have been defined.
|
|
|
|
static commodities_map commodities;
|
|
static commodities_array * commodities_by_ident;
|
|
static bool commodities_sorted;
|
|
static commodity_t * null_commodity;
|
|
static commodity_t * default_commodity;
|
|
|
|
static commodity_t * create(const string& symbol);
|
|
static commodity_t * find(const string& name);
|
|
static commodity_t * find_or_create(const string& symbol);
|
|
|
|
static bool needs_quotes(const string& symbol);
|
|
|
|
static void make_alias(const string& symbol,
|
|
commodity_t * commodity);
|
|
|
|
// These are specific to each commodity reference
|
|
|
|
typedef unsigned long ident_t;
|
|
|
|
ident_t ident;
|
|
commodity_base_t * base;
|
|
string qualified_symbol;
|
|
bool annotated;
|
|
|
|
public:
|
|
explicit commodity_t() : base(NULL), annotated(false) {
|
|
TRACE_CTOR(commodity_t, "");
|
|
}
|
|
commodity_t(const commodity_t& o)
|
|
: ident(o.ident), base(o.base),
|
|
qualified_symbol(o.qualified_symbol), annotated(o.annotated) {
|
|
TRACE_CTOR(commodity_t, "copy");
|
|
}
|
|
virtual ~commodity_t() {
|
|
TRACE_DTOR(commodity_t);
|
|
}
|
|
|
|
operator bool() const {
|
|
return this != null_commodity;
|
|
}
|
|
virtual bool operator==(const commodity_t& comm) const {
|
|
if (comm.annotated)
|
|
return comm == *this;
|
|
return base == comm.base;
|
|
}
|
|
|
|
string base_symbol() const {
|
|
return base->symbol;
|
|
}
|
|
string symbol() const {
|
|
return qualified_symbol;
|
|
}
|
|
|
|
void write(std::ostream& out) const {
|
|
out << symbol();
|
|
}
|
|
|
|
string name() const {
|
|
return base->name;
|
|
}
|
|
void set_name(const string& arg) {
|
|
base->name = arg;
|
|
}
|
|
|
|
string note() const {
|
|
return base->note;
|
|
}
|
|
void set_note(const string& arg) {
|
|
base->note = arg;
|
|
}
|
|
|
|
unsigned char precision() const {
|
|
return base->precision;
|
|
}
|
|
void set_precision(unsigned char arg) {
|
|
base->precision = arg;
|
|
}
|
|
|
|
unsigned char flags() const {
|
|
return base->flags;
|
|
}
|
|
void set_flags(unsigned char arg) {
|
|
base->flags = arg;
|
|
}
|
|
void add_flags(unsigned char arg) {
|
|
base->flags |= arg;
|
|
}
|
|
void drop_flags(unsigned char arg) {
|
|
base->flags &= ~arg;
|
|
}
|
|
|
|
amount_t * smaller() const {
|
|
return base->smaller;
|
|
}
|
|
void set_smaller(const amount_t& arg) {
|
|
if (base->smaller)
|
|
checked_delete(base->smaller);
|
|
base->smaller = new amount_t(arg);
|
|
}
|
|
|
|
amount_t * larger() const {
|
|
return base->larger;
|
|
}
|
|
void set_larger(const amount_t& arg) {
|
|
if (base->larger)
|
|
checked_delete(base->larger);
|
|
base->larger = new amount_t(arg);
|
|
}
|
|
|
|
commodity_base_t::history_t * history() const {
|
|
return base->history;
|
|
}
|
|
|
|
void add_price(const moment_t& date, const amount_t& price) {
|
|
return base->add_price(date, price);
|
|
}
|
|
bool remove_price(const moment_t& date) {
|
|
return base->remove_price(date);
|
|
}
|
|
amount_t value(const moment_t& moment = now) const {
|
|
return base->value(moment);
|
|
}
|
|
|
|
bool valid() const;
|
|
};
|
|
|
|
class annotated_commodity_t : public commodity_t
|
|
{
|
|
public:
|
|
const commodity_t * ptr;
|
|
|
|
optional<amount_t> price;
|
|
optional<moment_t> date;
|
|
optional<string> tag;
|
|
|
|
explicit annotated_commodity_t() {
|
|
TRACE_CTOR(annotated_commodity_t, "");
|
|
annotated = true;
|
|
}
|
|
virtual ~annotated_commodity_t() {
|
|
TRACE_DTOR(annotated_commodity_t);
|
|
}
|
|
|
|
virtual bool operator==(const commodity_t& comm) const;
|
|
|
|
void write_annotations(std::ostream& out) const {
|
|
annotated_commodity_t::write_annotations(out, price, date, tag);
|
|
}
|
|
|
|
static void write_annotations(std::ostream& out,
|
|
const optional<amount_t>& price,
|
|
const optional<moment_t>& date,
|
|
const optional<string>& tag);
|
|
|
|
private:
|
|
static commodity_t * create(const commodity_t& comm,
|
|
const optional<amount_t>& price,
|
|
const optional<moment_t>& date,
|
|
const optional<string>& tag,
|
|
const string& mapping_key);
|
|
|
|
static commodity_t * find_or_create(const commodity_t& comm,
|
|
const optional<amount_t>& price,
|
|
const optional<moment_t>& date,
|
|
const optional<string>& tag);
|
|
|
|
friend class amount_t;
|
|
};
|
|
|
|
inline std::ostream& operator<<(std::ostream& out, const commodity_t& comm) {
|
|
out << comm.symbol();
|
|
return out;
|
|
}
|
|
|
|
struct compare_amount_commodities {
|
|
bool operator()(const amount_t * left, const amount_t * right) const;
|
|
};
|
|
|
|
} // namespace ledger
|
|
|
|
#endif // _COMMODITY_H
|