FF4 - Renamed directory to 'objects'

- Better name for new object directory.

src/objects/.gitignore

@@ -0,0 +1 @@
+1.8

src/objects/Context.cpp

@@ -0,0 +1,151 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include <pwd.h>
+#include "Context.h"
+#include "text.h"
+#include "util.h"
+#include "task.h"
+#include "../auto.h"
+
+////////////////////////////////////////////////////////////////////////////////
+Context::Context ()
+{
+  // Set up randomness.
+#ifdef HAVE_SRANDOM
+  srandom (time (NULL));
+#else
+  srand (time (NULL));
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Context::Context (const Context& other)
+{
+  throw std::string ("unimplemented Context::Context");
+  config   = other.config;
+  filter   = other.filter;
+  keymap   = other.keymap;
+  sequence = other.sequence;
+  task     = other.task;
+  tdb      = other.tdb;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Context& Context::operator= (const Context& other)
+{
+  throw std::string ("unimplemented Context::operator=");
+  if (this != &other)
+  {
+    config   = other.config;
+    filter   = other.filter;
+    keymap   = other.keymap;
+    sequence = other.sequence;
+    task     = other.task;
+    tdb      = other.tdb;
+  }
+
+  return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Context::~Context ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Context::initialize (int argc, char** argv)
+{
+  // Load the configuration file from the home directory.  If the file cannot
+  // be found, offer to create a sample one.
+  loadCorrectConfigFile (argc, argv);
+
+  // When redirecting output to a file, do not use color, curses.
+  if (!isatty (fileno (stdout)))
+  {
+    config.set ("curses", "off");
+
+    if (! config.get (std::string ("_forcecolor"), false))
+      config.set ("color",  "off");
+  }
+
+  // TODO Handle "--version, -v" right here.
+
+  // init TDB.
+  std::string location = config.get ("data.location");
+  std::vector <std::string> all;
+  split (all, location, ',');
+  foreach (path, all)
+    tdb.location (expandPath (*path));
+
+  // Allow user override of file locking.  Solaris/NFS machines may want this.
+  tdb.lock (config.get ("locking", true));
+
+  // TODO Load pending.data.
+  // TODO Load completed.data.
+  // TODO Load deleted.data.
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int Context::run ()
+{
+  // TODO Dispatch to command handlers.
+  // TODO Auto shadow update.
+  // TODO Auto gc.
+  // TODO tdb.load (Filter);
+
+  throw std::string ("unimplemented Context::run");
+  return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Context::loadCorrectConfigFile (int argc, char** argv)
+{
+  for (int i = 1; i < argc; ++i)
+  {
+    if (! strncmp (argv[i], "rc:", 3))
+    {
+      if (! access (&(argv[i][3]), F_OK))
+      {
+        std::string file = &(argv[i][3]);
+        config.load (file);
+        return;
+      }
+      else
+        throw std::string ("Could not read configuration file '") + &(argv[i][3]) + "'";
+    }
+  }
+
+  struct passwd* pw = getpwuid (getuid ());
+  if (!pw)
+    throw std::string ("Could not read home directory from passwd file.");
+
+  std::string file = pw->pw_dir;
+  config.createDefault (file);
+}
+
+////////////////////////////////////////////////////////////////////////////////

src/objects/Context.h

@@ -0,0 +1,64 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+#ifndef INCLUDED_CONTEXT
+#define INCLUDED_CONTEXT
+
+#include "Filter.h"
+#include "Keymap.h"
+#include "Config.h"
+#include "Sequence.h"
+#include "T.h"
+#include "TDB.h"
+
+
+class Context
+{
+public:
+  Context ();                          // Default constructor
+  Context (const Context&);            // Copy constructor
+  Context& operator= (const Context&); // Assignment operator
+  ~Context ();                         // Destructor
+
+  void initialize (int, char**);
+  int run ();
+
+private:
+  void loadCorrectConfigFile (int, char**);
+
+public:
+  Config   config;
+  Filter   filter;
+  Keymap   keymap;
+  Sequence sequence;
+  T        task;
+  TDB      tdb;
+
+private:
+};
+
+#endif
+////////////////////////////////////////////////////////////////////////////////

src/objects/Filter.cpp

@@ -0,0 +1,78 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Filter.h"
+
+////////////////////////////////////////////////////////////////////////////////
+Filter::Filter ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Filter::Filter (const Filter& other)
+{
+  throw std::string ("unimplemented Filter::Filter");
+  mAtts = other.mAtts;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Filter& Filter::operator= (const Filter& other)
+{
+  throw std::string ("unimplemented Filter::operator=");
+  if (this != &other)
+  {
+    mAtts = other.mAtts;
+  }
+
+  return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Filter::~Filter ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Filter::add (Att& att)
+{
+  mAtts.push_back (att);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool Filter::pass (Record& record)
+{
+  throw std::string ("unimplemented Filter::pass");
+/*
+  foreach (att, mAtts)
+    if (! att->match (record))
+      return false;
+*/
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////

src/objects/Filter.h

@@ -0,0 +1,50 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+#ifndef INCLUDED_FILTER
+#define INCLUDED_FILTER
+
+#include <vector>
+#include "Att.h"
+#include "Record.h"
+
+class Filter
+{
+public:
+  Filter ();                         // Default constructor
+  Filter (const Filter&);            // Copy constructor
+  Filter& operator= (const Filter&); // Assignment operator
+  ~Filter ();                        // Destructor
+
+  void add (Att&);
+  bool pass (Record&);
+
+private:
+  std::vector <Att> mAtts;
+};
+
+#endif
+////////////////////////////////////////////////////////////////////////////////

src/objects/Keymap.cpp

@@ -0,0 +1,66 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include <string>
+#include "Keymap.h"
+
+////////////////////////////////////////////////////////////////////////////////
+Keymap::Keymap ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Keymap::Keymap (const Keymap& other)
+{
+  throw std::string ("unimplemented Keymap::Keymap");
+//  mOne = other.mOne;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Keymap& Keymap::operator= (const Keymap& other)
+{
+  throw std::string ("unimplemented Keymap::operator=");
+  if (this != &other)
+  {
+//    mOne = other.mOne;
+  }
+
+  return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Keymap::~Keymap ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Keymap::load (const std::string& file)
+{
+  throw std::string ("unimplemented Keymap::load");
+}
+
+////////////////////////////////////////////////////////////////////////////////

src/objects/Keymap.h

@@ -0,0 +1,51 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+#ifndef INCLUDED_KEYMAP
+#define INCLUDED_KEYMAP
+
+#include <string>
+
+class Keymap
+{
+public:
+  Keymap ();                         // Default constructor
+  Keymap (const Keymap&);            // Copy constructor
+  Keymap& operator= (const Keymap&); // Assignment operator
+  ~Keymap ();                        // Destructor
+
+  void load (const std::string&);    // Load the map file
+/*
+  real ();                           // Convert soft to real
+  soft ();                           // Convert real to soft
+*/
+
+private:
+  // TODO Structure for mapping strings to keys.
+};
+
+#endif
+////////////////////////////////////////////////////////////////////////////////

src/objects/Sequence.cpp

@@ -0,0 +1,64 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include <string>
+#include "Sequence.h"
+
+////////////////////////////////////////////////////////////////////////////////
+Sequence::Sequence ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Sequence::Sequence (const Sequence& other)
+{
+  throw std::string ("unimplemented Sequence::Sequence");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Sequence& Sequence::operator= (const Sequence& other)
+{
+  throw std::string ("unimplemented Sequence::operator=");
+  if (this != &other)
+  {
+  }
+
+  return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Sequence::~Sequence ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Sequence::parse (const std::string& input)
+{
+  throw std::string ("unimplemented Sequence::parse");
+}
+
+////////////////////////////////////////////////////////////////////////////////

src/objects/Sequence.h

@@ -0,0 +1,45 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+#ifndef INCLUDED_SEQUENCE
+#define INCLUDED_SEQUENCE
+
+#include <vector>
+#include <string>
+
+class Sequence : public std::vector <int>
+{
+public:
+  Sequence ();                           // Default constructor
+  Sequence (const Sequence&);            // Copy constructor
+  Sequence& operator= (const Sequence&); // Assignment operator
+  ~Sequence ();                          // Destructor
+
+  void parse (const std::string&);
+};
+
+#endif
+////////////////////////////////////////////////////////////////////////////////

src/objects/T.cpp

@@ -0,0 +1,74 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include <string>
+#include "T.h"
+
+////////////////////////////////////////////////////////////////////////////////
+T::T ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+T::T (const std::string& input)
+{
+  throw std::string ("unimplemented T::T");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+T& T::operator= (const T& other)
+{
+  throw std::string ("unimplemented T::operator=");
+  if (this != &other)
+  {
+//    mOne = other.mOne;
+  }
+
+  return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+T::~T ()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// [name:value, name:"value",name:[name:value,name:value]]
+std::string T::composeF4 ()
+{
+  throw std::string ("unimplemented T::composeF4");
+  return "";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+std::string T::composeCSV ()
+{
+  throw std::string ("unimplemented T::composeCSV");
+  return "";
+}
+
+////////////////////////////////////////////////////////////////////////////////

src/objects/T.h

@@ -0,0 +1,48 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+#ifndef INCLUDED_T
+#define INCLUDED_T
+
+#include <string>
+#include "Record.h"
+
+class T : public Record
+{
+public:
+  T ();                    // Default constructor
+  T (const std::string&);  // Parse
+  T& operator= (const T&); // Assignment operator
+  ~T ();                   // Destructor
+
+  std::string composeF4 ();
+  std::string composeCSV ();
+
+private:
+};
+
+#endif
+////////////////////////////////////////////////////////////////////////////////

src/objects/TDB.cpp

@@ -0,0 +1,232 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include <string>
+#include <sys/file.h>
+#include "text.h"
+#include "util.h"
+#include "TDB.h"
+#include "task.h"
+
+////////////////////////////////////////////////////////////////////////////////
+//  The ctor/dtor do nothing.
+//  The lock/unlock methods hold the file open.
+//  There should be only one commit.
+//
+//  +- TDB::TDB
+//  |
+//  |  +- TDB::lock
+//  |  |    open
+//  |  |    [lock]
+//  |  |
+//  |  |  +- TDB::load (Filter)
+//  |  |  |    read all
+//  |  |  |    apply filter
+//  |  |  |    return subset
+//  |  |  |
+//  |  |  +- TDB::add (T)
+//  |  |  |
+//  |  |  +- TDB::update (T, T')
+//  |  |  |
+//  |  |  +- TDB::commit
+//  |  |      write all
+//  |  |
+//  |  +- TDB::unlock
+//  |       [unlock]
+//  |       close
+//  |
+//  +- TDB::~TDB
+//       [TDB::unlock]
+//
+TDB::TDB ()
+: mLock (true)
+, mAllOpenAndLocked (false)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+TDB::TDB (const TDB& other)
+{
+  throw std::string ("unimplemented TDB::TDB");
+  mLocations        = other.mLocations;
+  mLock             = other.mLock;
+  mAllOpenAndLocked = false;  // Deliberately so.
+
+  // Set all to NULL.
+  foreach (location, mLocations)
+    mLocations[location->first] = NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+TDB& TDB::operator= (const TDB& other)
+{
+  throw std::string ("unimplemented TDB::operator=");
+  if (this != &other)
+  {
+    mLocations        = other.mLocations;
+    mLock             = other.mLock;
+    mAllOpenAndLocked = false;  // Deliberately so.
+
+    // Set all to NULL.
+    foreach (location, mLocations)
+      mLocations[location->first] = NULL;
+  }
+
+  return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+TDB::~TDB ()
+{
+  if (mAllOpenAndLocked)
+    unlock ();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TDB::location (const std::string& path)
+{
+  if (access (expandPath (path).c_str (), F_OK))
+    throw std::string ("Data location '") +
+          path +
+          "' does not exist, or is not readable and writable.";
+
+  mLocations[path] = NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TDB::lock (bool lockFile /* = true */)
+{
+  mLock = lockFile;
+
+  foreach (location, mLocations)
+    mLocations[location->first] = openAndLock (location->first);
+
+  mAllOpenAndLocked = true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TDB::unlock ()
+{
+  foreach (location, mLocations)
+  {
+    if (mLocations[location->first] != NULL)
+    {
+      fclose (mLocations[location->first]);
+      mLocations[location->first] = NULL;
+    }
+  }
+
+  mAllOpenAndLocked = false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TODO Returns number of filtered tasks.
+int TDB::load (std::vector <T>& tasks, Filter& filter)
+{
+  throw std::string ("unimplemented TDB::load");
+
+  // TODO Read each row.
+  // TODO Let T::parse disassemble it.
+  // TODO If task passes filter, add to tasks.
+  return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TODO Write to transaction log.
+void TDB::add (T& after)
+{
+  throw std::string ("unimplemented TDB::add");
+
+  // TODO Seek to end of pending.
+  // TODO write after.composeFF4 ().
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TODO Write to transaction log.
+void TDB::update (T& before, T& after)
+{
+  throw std::string ("unimplemented TDB::update");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TODO writes all, including comments
+int TDB::commit ()
+{
+  throw std::string ("unimplemented TDB::commit");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TODO -> FF4
+void TDB::upgrade ()
+{
+  throw std::string ("unimplemented TDB::upgrade");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TDB::getPendingFiles (std::vector <std::string> files)
+{
+  files.clear ();
+
+  foreach (location, mLocations)
+    files.push_back (location->first + "/pending.data");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TDB::getCompletedFiles (std::vector <std::string> files)
+{
+  files.clear ();
+
+  foreach (location, mLocations)
+    files.push_back (location->first + "/completed.data");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+FILE* TDB::openAndLock (const std::string& file)
+{
+  // Check for access.
+  if (access (file.c_str (), F_OK | R_OK | W_OK))
+    throw std::string ("Task does not have the correct permissions for '") +
+          file + "'.";
+
+  // Open the file.
+  FILE* in = fopen (file.c_str (), "rw");
+  if (!in)
+    throw std::string ("Could not open '") + file + "'.";
+
+  // Lock if desired.  Try three times before failing.
+  int retry = 0;
+  if (mLock)
+    while (flock (fileno (in), LOCK_EX) && ++retry <= 3)
+      delay (0.1);
+
+  if (!in)
+    throw std::string ("Could not lock '") + file + "'.";
+
+  return in;
+}
+
+////////////////////////////////////////////////////////////////////////////////

src/objects/TDB.h

@@ -0,0 +1,69 @@
+////////////////////////////////////////////////////////////////////////////////
+// task - a command line task list manager.
+//
+// Copyright 2006 - 2009, Paul Beckingham.
+// All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the
+//
+//     Free Software Foundation, Inc.,
+//     51 Franklin Street, Fifth Floor,
+//     Boston, MA
+//     02110-1301
+//     USA
+//
+////////////////////////////////////////////////////////////////////////////////
+#ifndef INCLUDED_TDB
+#define INCLUDED_TDB
+
+#include <map>
+#include <vector>
+#include <string>
+#include "Filter.h"
+#include "T.h"
+
+class TDB
+{
+public:
+  TDB ();                      // Default constructor
+  TDB (const TDB&);            // Copy constructor
+  TDB& operator= (const TDB&); // Assignment operator
+  ~TDB ();                     // Destructor
+
+  void  location (const std::string&);
+
+  void  lock (bool lockFile = true);
+  void  unlock ();
+
+  int   load (std::vector <T>&, Filter&);
+  void  add (T&);
+  void  update (T&, T&);
+  int   commit ();
+  void  upgrade ();
+
+private:
+  void  getPendingFiles (std::vector <std::string>);
+  void  getCompletedFiles (std::vector <std::string>);
+  FILE* openAndLock (const std::string&);
+
+private:
+  std::map <std::string, FILE*> mLocations;
+  bool mLock;
+  bool mAllOpenAndLocked;
+
+  // TODO Need cache of raw file contents.
+};
+
+#endif
+////////////////////////////////////////////////////////////////////////////////

src/objects/main.cpp

@@ -0,0 +1,30 @@
+////////////////////////////////////////////////////////////////////////////////
+#include <iostream>
+#include <string>
+#include "Context.h"
+
+int main (int argc, char** argv)
+{
+  try
+  {
+    Context c;
+    c.initialize (argc, argv);
+    c.run ();
+
+    return 0;
+  }
+
+  catch (std::string e)
+  {
+    std::cerr << e << std::endl;
+  }
+
+  catch (...)
+  {
+    std::cerr << "task internal error." << std::endl;
+  }
+
+  return -1;
+}
+
+////////////////////////////////////////////////////////////////////////////////