amount.h

Go to the documentation of this file.

/*
 * Copyright (c) 2003-2023, 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.
 */
 
#pragma once
 
#include "utils.h"
#include "times.h"
#include "flags.h"
 
namespace ledger {
 
class commodity_t;
struct annotation_t;
struct keep_details_t;
 
DECLARE_EXCEPTION(amount_error, std::runtime_error);
 
enum parse_flags_enum_t {
  PARSE_DEFAULT    = 0x00,
  PARSE_PARTIAL    = 0x01,
  PARSE_SINGLE     = 0x02,
  PARSE_NO_MIGRATE = 0x04,
  PARSE_NO_REDUCE  = 0x08,
  PARSE_NO_ASSIGN  = 0x10,
  PARSE_NO_ANNOT   = 0x20,
  PARSE_OP_CONTEXT = 0x40,
  PARSE_SOFT_FAIL  = 0x80
};
 
typedef flags::basic_t<parse_flags_enum_t, uint_least8_t> parse_flags_t;
 
class amount_t
  : public ordered_field_operators<amount_t,
           ordered_field_operators<amount_t, double,
           ordered_field_operators<amount_t, unsigned long,
           ordered_field_operators<amount_t, long> > > >
{
public:
  static void initialize();
  static void shutdown();
 
  static bool is_initialized;
 
  typedef uint_least16_t precision_t;
 
  static const std::size_t extend_by_digits = 6U;
 
  static bool stream_fullstrings;
 
protected:
  void _copy(const amount_t& amt);
  void _dup();
  void _clear();
  void _release();
 
  struct bigint_t;
 
  bigint_t *    quantity;
  commodity_t * commodity_;
 
public:
  amount_t() : quantity(NULL), commodity_(NULL) {
    TRACE_CTOR(amount_t, "");
  }
 
  amount_t(const double val);
 
  amount_t(const unsigned long val);
 
  amount_t(const long val);
 
  explicit amount_t(const string& val) : quantity(NULL) {
    parse(val);
    TRACE_CTOR(amount_t, "const string&");
  }
  explicit amount_t(const char * val) : quantity(NULL) {
    assert(val);
    parse(val);
    TRACE_CTOR(amount_t, "const char *");
  }
 
  static amount_t exact(const string& value);
 
  ~amount_t() {
    TRACE_DTOR(amount_t);
    if (quantity)
      _release();
  }
 
  amount_t(const amount_t& amt) : quantity(NULL) {
    if (amt.quantity)
      _copy(amt);
    else
      commodity_ = NULL;
    TRACE_CTOR(amount_t, "copy");
  }
  amount_t(const amount_t& amt, const annotation_t& details) : quantity(NULL) {
    assert(amt.quantity);
    _copy(amt);
    annotate(details);
    TRACE_CTOR(amount_t, "const amount_t&, const annotation_t&");
  }
  amount_t& operator=(const amount_t& amt);
 
  amount_t& operator=(const double val) {
    return *this = amount_t(val);
  }
  amount_t& operator=(const unsigned long val) {
    return *this = amount_t(val);
  }
  amount_t& operator=(const long val) {
    return *this = amount_t(val);
  }
 
  /* Assign a string to an amount.  This causes the contents of the
     string to be parsed, look for a commoditized or uncommoditized
     amount specifier. */
  amount_t& operator=(const string& str) {
    return *this = amount_t(str);
  }
  amount_t& operator=(const char * str) {
    assert(str);
    return *this = amount_t(str);
  }
 
  int compare(const amount_t& amt) const;
 
  bool operator==(const amount_t& amt) const;
 
  template <typename T>
  bool operator==(const T& val) const {
    return compare(val) == 0;
  }
  template <typename T>
  bool operator<(const T& amt) const {
    return compare(amt) < 0;
  }
  template <typename T>
  bool operator>(const T& amt) const {
    return compare(amt) > 0;
  }
 
 
  amount_t& operator+=(const amount_t& amt);
  amount_t& operator-=(const amount_t& amt);
  amount_t& operator*=(const amount_t& amt) {
    return multiply(amt);
  }
  amount_t& multiply(const amount_t& amt, bool ignore_commodity = false);
 
  amount_t& operator/=(const amount_t& amt);
 
  precision_t precision() const;
  bool        keep_precision() const;
  void        set_keep_precision(const bool keep = true) const;
  precision_t display_precision() const;
 
  amount_t negated() const {
    amount_t temp(*this);
    temp.in_place_negate();
    return temp;
  }
  void in_place_negate();
 
  amount_t operator-() const {
    return negated();
  }
 
  amount_t abs() const {
    if (sign() < 0)
      return negated();
    return *this;
  }
 
  amount_t inverted() const {
    amount_t temp(*this);
    temp.in_place_invert();
    return temp;
  }
  void in_place_invert();
 
  amount_t rounded() const {
    amount_t temp(*this);
    temp.in_place_round();
    return temp;
  }
  void in_place_round();
 
  amount_t roundto(int places) const {
    amount_t temp(*this);
    temp.in_place_roundto(places);
    return temp;
  }
  void in_place_roundto(int places);
 
  amount_t truncated() const {
    amount_t temp(*this);
    temp.in_place_truncate();
    return temp;
  }
  void in_place_truncate();
 
  amount_t floored() const {
    amount_t temp(*this);
    temp.in_place_floor();
    return temp;
  }
  void in_place_floor();
 
  amount_t ceilinged() const {
    amount_t temp(*this);
    temp.in_place_ceiling();
    return temp;
  }
  void in_place_ceiling();
 
  amount_t unrounded() const {
    amount_t temp(*this);
    temp.in_place_unround();
    return temp;
  }
  void in_place_unround();
 
  amount_t reduced() const {
    amount_t temp(*this);
    temp.in_place_reduce();
    return temp;
  }
  void in_place_reduce();
 
  amount_t unreduced() const {
    amount_t temp(*this);
    temp.in_place_unreduce();
    return temp;
  }
  void in_place_unreduce();
 
  optional<amount_t>
  value(const datetime_t& moment        = datetime_t(),
        const commodity_t * in_terms_of = NULL) const;
 
  optional<amount_t> price() const;
 
 
  int sign() const;
 
  operator bool() const {
    return is_nonzero();
  }
  bool is_nonzero() const {
    return ! is_zero();
  }
 
  bool is_zero() const;
  bool is_realzero() const {
    return sign() == 0;
  }
 
  bool is_null() const {
    if (! quantity) {
      assert(! commodity_);
      return true;
    }
    return false;
  }
 
 
  double to_double() const;
  long   to_long() const;
  bool   fits_in_long() const;
 
  operator string() const {
    return to_string();
  }
  string to_string() const;
  string to_fullstring() const;
  string quantity_string() const;
 
 
  commodity_t * commodity_ptr() const;
  commodity_t& commodity() const {
    return *commodity_ptr();
  }
 
  bool has_commodity() const;
  void set_commodity(commodity_t& comm) {
    if (! quantity)
      *this = 0L;
    commodity_ = &comm;
  }
  amount_t with_commodity(const commodity_t& comm) const {
    if (commodity_ == &comm) {
      return *this;
    } else {
      amount_t tmp(*this);
      tmp.set_commodity(const_cast<commodity_t&>(comm));
      return tmp;
    }
  }
  void clear_commodity() {
    commodity_ = NULL;
  }
 
  amount_t number() const {
    if (! has_commodity())
      return *this;
 
    amount_t temp(*this);
    temp.clear_commodity();
    return temp;
  }
 
 
  void          annotate(const annotation_t& details);
  bool          has_annotation() const;
 
  annotation_t& annotation();
  const annotation_t& annotation() const {
    return const_cast<amount_t&>(*this).annotation();
  }
 
  amount_t strip_annotations(const keep_details_t& what_to_keep) const;
 
 
  bool parse(std::istream& in,
             const parse_flags_t& flags = PARSE_DEFAULT);
  bool parse(const string& str,
             const parse_flags_t& flags = PARSE_DEFAULT) {
    std::istringstream stream(str);
    bool result = parse(stream, flags);
    return result;
  }
 
  static void parse_conversion(const string& larger_str,
                               const string& smaller_str);
 
 
#define AMOUNT_PRINT_NO_FLAGS                 0x00
#define AMOUNT_PRINT_RIGHT_JUSTIFY            0x01
#define AMOUNT_PRINT_COLORIZE                 0x02
#define AMOUNT_PRINT_NO_COMPUTED_ANNOTATIONS  0x04
#define AMOUNT_PRINT_ELIDE_COMMODITY_QUOTES   0x08
 
  void print(std::ostream&       out,
             const uint_least8_t flags = AMOUNT_PRINT_NO_FLAGS) const;
 
 
  void dump(std::ostream& out) const {
    out << "AMOUNT(";
    print(out);
    out << ")";
  }
 
  bool valid() const;
 
};
 
inline amount_t amount_t::exact(const string& value) {
  amount_t temp;
  temp.parse(value, PARSE_NO_MIGRATE);
  return temp;
}
 
inline string amount_t::to_string() const {
  std::ostringstream bufstream;
  print(bufstream);
  return bufstream.str();
}
 
inline string amount_t::to_fullstring() const {
  std::ostringstream bufstream;
  unrounded().print(bufstream);
  return bufstream.str();
}
 
inline string amount_t::quantity_string() const {
  std::ostringstream bufstream;
  number().print(bufstream);
  return bufstream.str();
}
 
inline std::ostream& operator<<(std::ostream& out, const amount_t& amt) {
  if (amount_t::stream_fullstrings)
    amt.unrounded().print(out);
  else
    amt.print(out);
  return out;
}
inline std::istream& operator>>(std::istream& in, amount_t& amt) {
  amt.parse(in);
  return in;
}
 
void put_amount(property_tree::ptree& pt, const amount_t& amt,
                bool commodity_details = false);
 
} // namespace ledger