Moved around most of the files so that source code is in src/, documentation

is in doc/, etc.

1 files changed, 154 insertions, 0 deletions

diff --git a/src/times.h b/src/times.h
new file mode 100644
index 00000000..306477f5
--- /dev/null
+++ b/src/times.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2003-2008, 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 _TIMES_H
+#define _TIMES_H
+
+namespace ledger {
+
+DECLARE_EXCEPTION(datetime_error, std::runtime_error);
+DECLARE_EXCEPTION(date_error, std::runtime_error);
+
+typedef boost::posix_time::ptime	datetime_t;
+typedef datetime_t::time_duration_type	time_duration_t;
+
+inline bool is_valid(const datetime_t& moment) {
+  return ! moment.is_not_a_date_time();
+}
+
+typedef boost::gregorian::date          date_t;
+typedef boost::gregorian::date_duration date_duration_t;
+
+inline bool is_valid(const date_t& moment) {
+  return ! moment.is_not_a_date();
+}
+
+extern const datetime_t& current_time;
+extern const date_t&     current_date;
+extern int		 current_year;
+extern optional<string>  input_date_format;
+extern string		 output_date_format;
+
+inline datetime_t parse_datetime(const string& str) {
+  return parse_datetime(str.c_str());
+}
+datetime_t parse_datetime(const char * str);
+
+inline date_t parse_date(const string& str) {
+  return parse_date(str.c_str());
+}
+date_t parse_date(const char * str);
+
+inline std::time_t to_time_t(const ptime& t) 
+{ 
+  if( t == posix_time::neg_infin ) 
+    return 0; 
+  else if( t == posix_time::pos_infin ) 
+    return LONG_MAX; 
+  ptime start(date(1970,1,1)); 
+  return (t-start).total_seconds(); 
+}
+
+inline string format_datetime(const datetime_t& when)
+{
+  char buf[256];
+  time_t moment = to_time_t(when);
+  std::strftime(buf, 255, (output_date_format + " %H:%M:%S").c_str(),
+		std::localtime(&moment));
+  return buf;
+}
+
+inline string format_date(const date_t& when,
+			  const optional<string>& format = none)
+{
+  if (format) {
+    char buf[256];
+    std::tm moment = gregorian::to_tm(when);
+    std::strftime(buf, 255, format->c_str(), &moment);
+    return buf;
+  } else {
+    return to_iso_extended_string(when);
+  }
+}
+
+struct interval_t
+{
+  int	 years;
+  int	 months;
+  int	 days;
+  date_t begin;
+  date_t end;
+
+  mutable bool advanced;
+
+  interval_t(int _days = 0, int _months = 0, int _years = 0,
+	     const date_t& _begin = date_t(),
+	     const date_t& _end   = date_t())
+    : years(_years), months(_months), days(_days),
+      begin(_begin), end(_end), advanced(false) {
+    TRACE_CTOR(interval_t, "int, int, int, const date_t&, const date_t&");
+  }
+  interval_t(const interval_t& other)
+    : years(other.years),
+      months(other.months),
+      days(other.days),
+      begin(other.begin),
+      end(other.end),
+      advanced(other.advanced) {
+    TRACE_CTOR(interval_t, "copy");
+  }
+  interval_t(const string& desc)
+    : years(0), months(0), days(0), begin(), end(), advanced(false) {
+    TRACE_CTOR(interval_t, "const string&");
+    std::istringstream stream(desc);
+    parse(stream);
+  }
+
+  ~interval_t() throw() {
+    TRACE_DTOR(interval_t);
+  }
+
+  operator bool() const {
+    return years != 0 || months != 0  || days != 0;
+  }
+
+  void   start(const date_t& moment) {
+    begin = first(moment);
+  }
+  date_t first(const optional<date_t>& moment = none) const;
+  date_t increment(const date_t&) const;
+
+  void   parse(std::istream& in);
+};
+
+} // namespace ledger
+
+#endif // _TIMES_H