tddoc.cc

   1 // Copyright (c) 2006 by Mike Sharov <msharov@users.sourceforge.net>
   2 //
   3 // tddoc.cc
   4 //
   5
   6 #include "tddoc.h"
   7 #include <iff.h>
   8 #include <unistd.h>
   9
  10 //----------------------------------------------------------------------
  11
  12 /// Default constructor.
  13 CTodoDocument::CTodoDocument (void)
  14 : CDocument (),
  15   m_Todos (),
  16   m_Deps ()
  17 {
  18     m_Todos.insert (CTodoItem());
  19 }
  20
  21 //--{ Internal data accessors }-----------------------------------------
  22
  23 /// Looks up item \p id in m_Todos, returns NULL if not found.
  24 CTodoDocument::icitem_t CTodoDocument::FindItem (itemid_t id) const
  25 {
  26     icitem_t i = m_Todos.find (id);
  27     return (i == m_Todos.end() ? NULL : i);
  28 }
  29
  30 /// Links \p m to the dependency list for \p id.
  31 void CTodoDocument::ItemDeps (itemid_t id, tddepmap_t& m) const
  32 {
  33     pair<icdep_t, icdep_t> dr = equal_range (m_Deps, CTodoDep(id));
  34     m.link (dr.first, dr.second);
  35 }
  36
  37 /// Returns the next available item id.
  38 inline CTodoDocument::itemid_t CTodoDocument::GetNextItemId (void) const
  39 {
  40     return (m_Todos.back().Id() + 1);
  41 }
  42
  43 //--{ Serialization }---------------------------------------------------
  44
  45 enum {
  46     fmt_TodoList        = IFF_FMT('T','O','D','O'),
  47     fmt_Options         = IFF_FMT('O','P','T','S'),
  48     fmt_Item            = IFF_FMT('T','I','T','M'),
  49     fmt_Dep             = IFF_FMT('T','D','E','P')
  50 };
  51
  52 static const uint32_t c_CurrentVersion  = 1;
  53
  54 //----------------------------------------------------------------------
  55
  56 class CTodoHeader {
  57 public:
  58     inline              CTodoHeader (void)              : m_Version (c_CurrentVersion), m_Flags (0), m_Reserved (0) { }
  59     inline void         read (istream& is)              { is >> m_Version >> m_Flags >> m_Reserved; }
  60     inline void         write (ostream& os) const       { os << m_Version << m_Flags << m_Reserved; }
  61     inline size_t       stream_size (void) const        { return (stream_size_of (m_Version) + stream_size_of (m_Flags) + stream_size_of(m_Reserved)); }
  62 public:
  63     uint32_t            m_Version;      ///< File format's version number.
  64     bitset<32>          m_Flags;        ///< Various flags. None for now.
  65     uint32_t            m_Reserved;     ///< Future functionality.
  66 };
  67
  68 STD_STREAMABLE (CTodoHeader)
  69
  70 /// Reads the object from stream \p is.
  71 void CTodoDocument::read (istream& is)
  72 {
  73     iff::SkipChunk (is, fmt_Options);
  74     iff::ReadVector (is, m_Todos, fmt_Item);
  75     iff::ReadVector (is, m_Deps, fmt_Dep);
  76     VerifyData();
  77 }
  78
  79 /// Writes the object to stream \p os.
  80 void CTodoDocument::write (ostream& os) const
  81 {
  82     iff::WriteChunk (os, CTodoHeader(), fmt_Options);
  83     iff::WriteVector (os, m_Todos, fmt_Item);
  84     iff::WriteVector (os, m_Deps, fmt_Dep);
  85 }
  86
  87 /// Returns the size of the written object.
  88 size_t CTodoDocument::stream_size (void) const
  89 {
  90     return (iff::chunk_size_of (CTodoHeader()) +
  91             iff::vector_size_of (m_Todos) +
  92             iff::vector_size_of (m_Deps));
  93 }
  94
  95 /// Opens \p filename and reads todo entries from it.
  96 void CTodoDocument::Open (const string& filename)
  97 {
  98     CDocument::Open (filename);
  99     if (access (filename, F_OK))        // Check if it's a new document.
 100         return;
 101     if (access (filename, W_OK))        // Check if it is read-only.
 102         SetFlag (f_ReadOnly);
 103     memblock buf;
 104     buf.read_file (filename);
 105     istream is (buf);
 106     iff::ReadFORM (is, *this, fmt_TodoList);
 107     SetFlag (f_Changed, false);
 108     UpdateAllViews();
 109 }
 110
 111 /// Saves the data to the currently open file.
 112 void CTodoDocument::Save (void)
 113 {
 114     if (Flag (f_ReadOnly) && access (Filename(), W_OK)) {
 115         MessageBox ("Can't save: this file is marked as read-only");
 116         return;
 117     }
 118     memblock buf (iff::form_size_of (*this));
 119     ostream os (buf);
 120     iff::WriteFORM (os, *this, fmt_TodoList);
 121     buf.write_file (Filename());
 122     SetFlag (f_Changed, false);
 123     UpdateAllViews();
 124 }
 125
 126 /// Verifies and corrects any defects in the data.
 127 void CTodoDocument::VerifyData (void)
 128 {
 129     foreach (tddepmap_t::iterator, i, m_Deps) {
 130         if (!FindItem (i->m_ItemId) || !FindItem (i->m_DepId)) {
 131             assert (!"Found a dependency pointing to a nonexistent item!");
 132             --(i = m_Deps.erase (i));
 133         }
 134     }
 135 }
 136
 137 /// Returns the true if \p i1 ought to appear before \p i2 in the visible list.
 138 bool CTodoDocument::VisibleOrderLess (const CTodoDep& d1, const CTodoDep& d2) const
 139 {
 140     const icitem_t i1 (FindItem (d1.m_DepId)), i2 (FindItem (d2.m_DepId));
 141     // Sort to put completed items at the end, then sort by priority, and then by creation date.
 142     return (i1->Complete() < i2->Complete() ||
 143             (!i1->Complete() && !i2->Complete() && (i1->Priority() < i2->Priority() ||
 144              (i1->Priority() == i2->Priority() && *i1 < *i2))) ||
 145             (i1->Complete() && i2->Complete() && (i1->Done() > i2->Done() ||
 146              (i1->Done() == i2->Done() && *i1 < *i2))));
 147 }
 148
 149 /// Reorders the items in the list by canonical sort order.
 150 void CTodoDocument::ResortItemDeps (idep_t first, idep_t last) const
 151 {
 152     for (idep_t j, i = first; ++i < last;) {
 153         for (j = i; j-- > first && !VisibleOrderLess (*j, *i););
 154         rotate (++j, i, i + 1);
 155     }
 156 }
 157
 158 //--{ Item progress recursive updating }--------------------------------
 159
 160 /// Creates a new item and returns its id.
 161 CTodoDocument::itemid_t CTodoDocument::CreateItem (void)
 162 {
 163     CTodoItem e (GetNextItemId());
 164     assert (!FindItem (e.Id()));
 165     // To the complete list
 166     m_Todos.insert (e);
 167     SetFlag (f_Changed);
 168     return (e.Id());
 169 }
 170
 171 /// Makes item \p id a dependency of \p parent item.
 172 void CTodoDocument::LinkItem (itemid_t id, itemid_t parent)
 173 {
 174     iitem_t iItem = FindItem (id), iParent = FindItem (parent);
 175     if (!iParent | !iItem)
 176         return;
 177     // m_Deps is sorted by parent, but not by < (because < requires accessing m_Todos)
 178     idep_t ip = upper_bound (m_Deps, CTodoDep (parent));
 179     m_Deps.insert (ip, CTodoDep (parent, id));
 180     // Update the new item's status.
 181     iItem->AddRef();
 182     iParent->SetHasSublist (true);
 183     UpdateCompleteStatus (id);
 184     // Tell the world
 185     SetFlag (f_Changed);
 186     UpdateAllViews();
 187 }
 188
 189 /// Removes one reference the given item.
 190 void CTodoDocument::UnlinkItem (icdep_t id)
 191 {
 192     assert (id >= m_Deps.begin() && id < m_Deps.end() && "UnlinkItem takes an iterator from the vector set by ItemDeps");
 193     iitem_t ii = FindItem (id->m_DepId);        // Cache master list iterator while we still have the item to look for.
 194     // Remove from dependency list.
 195     m_Deps.erase (const_cast<idep_t>(id));
 196     pair<idep_t, idep_t> r = equal_range (m_Deps, CTodoDep(ii->Id()));
 197     if (r.first == r.second)    // Can't be cleanly done in UpdateItemProgress.
 198         FindItem (id->m_ItemId)->SetHasSublist (false);
 199     // Update the item in the master list.
 200     if (!ii->DelRef())  // If no more refs, then delete.
 201         m_Todos.erase (ii);
 202     UpdateItemProgress (r.first, r.second);
 203     // Update visible list.
 204     SetFlag (f_Changed);
 205     UpdateAllViews();
 206 }
 207
 208 /// Updates item \p v in the master list.
 209 void CTodoDocument::UpdateItem (rcitem_t v)
 210 {
 211     iitem_t i = FindItem (v.Id());
 212     assert (i && "Update item must only be called with already existent items. Call AppendItem to create new ones.");
 213     *i = v;
 214     UpdateCompleteStatus (v.Id());
 215     // Tell the world
 216     SetFlag (f_Changed);
 217     UpdateAllViews();
 218 }
 219
 220 /// Updates the progress of the item given by dependency range [first, last)
 221 void CTodoDocument::UpdateItemProgress (idep_t first, idep_t last)
 222 {
 223     const uint32_t nItems = distance (first, last);
 224     if (!nItems)
 225         return;
 226     ResortItemDeps (first, last);
 227     const itemid_t rangeId (first->m_ItemId);
 228     uint32_t progress = 0;
 229     for (; first < last; ++first)
 230         progress += FindItem(first->m_DepId)->Progress();
 231     // +1 treats the parent item as part of the list.
 232     progress = min (progress / (nItems + 1), 100U);
 233     iitem_t ii = FindItem (rangeId);
 234     if (!ii || ii->Progress() == progress)
 235         return;
 236     ii->MarkComplete (progress);
 237     UpdateCompleteStatus (rangeId);     // Recurse to propagate the change up.
 238 }
 239
 240 /// Updates progress values of item dependent on \p dep
 241 void CTodoDocument::UpdateCompleteStatus (itemid_t dep)
 242 {
 243     // Each item has a range of dependencies; ranges are sequential in m_Deps.
 244     idep_t rangeStart = m_Deps.begin(); // The start of the current range.
 245     const idep_t iEnd = m_Deps.end();
 246     bool hasDep = false;                // Does current range have dep?
 247     for (idep_t i = rangeStart; i < iEnd; ++i) {
 248         if (i->m_ItemId != rangeStart->m_ItemId) {
 249             if (hasDep)
 250                 UpdateItemProgress (rangeStart, i);
 251             rangeStart = i;
 252             hasDep = false;
 253         }
 254         hasDep = hasDep || i->m_DepId == dep;
 255     }
 256     if (hasDep)
 257         UpdateItemProgress (rangeStart, iEnd);
 258 }
 259