GothenburgBitFactory/taskwarrior
1
0
Fork 0
mirror of https://github.com/GothenburgBitFactory/taskwarrior.git synced 2025-07-07 20:06:36 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

FF4 - Skeleton objects

Browse source 
Created skeleton objects for all new 1.8.0 code.
This commit is contained in:
Paul Beckingham 2009-05-16 15:45:31 -04:00
parent 6bef54cdae
commit 833fac3c13
24 changed files with 1235 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

58
src/rewrite/Att.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "Att.h"
////////////////////////////////////////////////////////////////////////////////
Att::Att ()
{
}
////////////////////////////////////////////////////////////////////////////////
Att::Att (const Att& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
Att& Att::operator= (const Att& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Att::~Att ()
{
}
////////////////////////////////////////////////////////////////////////////////

55
src/rewrite/Att.h Normal file
View file

@ -0,0 +1,55 @@
////////////////////////////////////////////////////////////////////////////////
// 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_ATT
#define INCLUDED_ATT
class Att
{
public:
Att (); // Default constructor
Att (const Att&); // Copy constructor
Att& operator= (const Att&); // Assignment operator
~Att (); // Destructor
/*
Att (name, value)
std::string name ()
std::string value ()
int value_int ()
addMod ()
bool isFilter ()
bool isRequired ()
bool isInternal ()
composeF4 ()
parse (const std::stirng&)
*/
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

80
src/rewrite/Context.cpp Normal file
View file

@ -0,0 +1,80 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "Context.h"
////////////////////////////////////////////////////////////////////////////////
Context::Context ()
{
}
////////////////////////////////////////////////////////////////////////////////
Context::Context (const Context& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
Context& Context::operator= (const Context& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Context::~Context ()
{
}
////////////////////////////////////////////////////////////////////////////////
void Context::initialize ()
{
// TODO Load config
// TODO Load pending.data
// TODO Load completed.data
// TODO Load deleted.data
}
////////////////////////////////////////////////////////////////////////////////
int Context::commandLine (int argc, char** argv)
{
// TODO Support rc: override.
return 0;
}
////////////////////////////////////////////////////////////////////////////////
int Context::run ()
{
return 0;
}
////////////////////////////////////////////////////////////////////////////////

62
src/rewrite/Context.h Normal file
View file

@ -0,0 +1,62 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "TDB.h"
#include "T.h"
class Context
{
public:
Context (); // Default constructor
Context (const Context&); // Copy constructor
Context& operator= (const Context&); // Assignment operator
~Context (); // Destructor
void initialize ();
int commandLine (int, char**);
int run ();
public:
// Config config;
Filter filter;
Keymap keymap;
Sequence sequence;
T task;
TDB tdb;
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

58
src/rewrite/Date.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "Date.h"
////////////////////////////////////////////////////////////////////////////////
Date::Date ()
{
}
////////////////////////////////////////////////////////////////////////////////
Date::Date (const Date& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
Date& Date::operator= (const Date& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Date::~Date ()
{
}
////////////////////////////////////////////////////////////////////////////////

46
src/rewrite/Date.h Normal file
View file

@ -0,0 +1,46 @@
////////////////////////////////////////////////////////////////////////////////
// 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_DATE
#define INCLUDED_DATE
class Date
{
public:
Date (); // Default constructor
Date (const Date&); // Copy constructor
Date& operator= (const Date&); // Assignment operator
~Date (); // Destructor
/*
bool isDate (const std::string&)
*/
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

58
src/rewrite/Duration.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "Duration.h"
////////////////////////////////////////////////////////////////////////////////
Duration::Duration ()
{
}
////////////////////////////////////////////////////////////////////////////////
Duration::Duration (const Duration& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
Duration& Duration::operator= (const Duration& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Duration::~Duration ()
{
}
////////////////////////////////////////////////////////////////////////////////

46
src/rewrite/Duration.h Normal file
View file

@ -0,0 +1,46 @@
////////////////////////////////////////////////////////////////////////////////
// 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_DURATION
#define INCLUDED_DURATION
class Duration
{
public:
Duration (); // Default constructor
Duration (const Duration&); // Copy constructor
Duration& operator= (const Duration&); // Assignment operator
~Duration (); // Destructor
/*
bool isDuration (const std::string&)
*/
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

58
src/rewrite/Filter.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
Filter& Filter::operator= (const Filter& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Filter::~Filter ()
{
}
////////////////////////////////////////////////////////////////////////////////

48
src/rewrite/Filter.h Normal file
View file

@ -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_FILTER
#define INCLUDED_FILTER
class Filter
{
public:
Filter (); // Default constructor
Filter (const Filter&); // Copy constructor
Filter& operator= (const Filter&); // Assignment operator
~Filter (); // Destructor
/*
add (Att&)
bool Filter::pass (T&)
Filter::parse ()
*/
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

58
src/rewrite/Keymap.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "Keymap.h"
////////////////////////////////////////////////////////////////////////////////
Keymap::Keymap ()
{
}
////////////////////////////////////////////////////////////////////////////////
Keymap::Keymap (const Keymap& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
Keymap& Keymap::operator= (const Keymap& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Keymap::~Keymap ()
{
}
////////////////////////////////////////////////////////////////////////////////

42
src/rewrite/Keymap.h Normal file
View file

@ -0,0 +1,42 @@
////////////////////////////////////////////////////////////////////////////////
// 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
class Keymap
{
public:
Keymap (); // Default constructor
Keymap (const Keymap&); // Copy constructor
Keymap& operator= (const Keymap&); // Assignment operator
~Keymap (); // Destructor
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

23
src/rewrite/Makefile Normal file
View file

@ -0,0 +1,23 @@
PROJECT = 1.8
CFLAGS = -I. -I../../library/include -Wall -pedantic -ggdb3 -fno-rtti -fstack-check
LFLAGS =
LIBS =
OBJECTS = main.o Context.o TDB.o T.o Sequence.o Filter.o Att.o Date.o Duration.o Keymap.o
all: $(PROJECT)
install: $(PROJECT)
@echo unimplemented
test: $(PROJECT)
@echo unimplemented
clean:
-rm *.o $(PROJECT)
.cpp.o: $(INCLUDE)
g++ -c $(CFLAGS) $<
$(PROJECT): $(OBJECTS)
g++ $(OBJECTS) $(LFLAGS) $(LIBS) -o $(PROJECT)

58
src/rewrite/Record.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "Record.h"
////////////////////////////////////////////////////////////////////////////////
Record::Record ()
{
}
////////////////////////////////////////////////////////////////////////////////
Record::Record (const Record& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
Record& Record::operator= (const Record& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Record::~Record ()
{
}
////////////////////////////////////////////////////////////////////////////////

42
src/rewrite/Record.h Normal file
View file

@ -0,0 +1,42 @@
////////////////////////////////////////////////////////////////////////////////
// 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_RECORD
#define INCLUDED_RECORD
class Record
{
public:
Record (); // Default constructor
Record (const Record&); // Copy constructor
Record& operator= (const Record&); // Assignment operator
~Record (); // Destructor
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

58
src/rewrite/Sequence.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "Sequence.h"
////////////////////////////////////////////////////////////////////////////////
Sequence::Sequence ()
{
}
////////////////////////////////////////////////////////////////////////////////
Sequence::Sequence (const Sequence& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
Sequence& Sequence::operator= (const Sequence& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Sequence::~Sequence ()
{
}
////////////////////////////////////////////////////////////////////////////////

42
src/rewrite/Sequence.h Normal file
View file

@ -0,0 +1,42 @@
////////////////////////////////////////////////////////////////////////////////
// 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
class Sequence
{
public:
Sequence (); // Default constructor
Sequence (const Sequence&); // Copy constructor
Sequence& operator= (const Sequence&); // Assignment operator
~Sequence (); // Destructor
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

58
src/rewrite/T.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "T.h"
////////////////////////////////////////////////////////////////////////////////
T::T ()
{
}
////////////////////////////////////////////////////////////////////////////////
T::T (const T& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
T& T::operator= (const T& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
T::~T ()
{
}
////////////////////////////////////////////////////////////////////////////////

49
src/rewrite/T.h Normal file
View file

@ -0,0 +1,49 @@
////////////////////////////////////////////////////////////////////////////////
// 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
class T
{
public:
T (); // Default constructor
T (const T&); // Copy constructor
T& operator= (const T&); // Assignment operator
~T (); // Destructor
/*
T (const std::string&);
composeF4
composeCSV
parse
*/
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

58
src/rewrite/TDB.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "TDB.h"
////////////////////////////////////////////////////////////////////////////////
TDB::TDB ()
{
}
////////////////////////////////////////////////////////////////////////////////
TDB::TDB (const TDB& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
TDB& TDB::operator= (const TDB& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
TDB::~TDB ()
{
}
////////////////////////////////////////////////////////////////////////////////

55
src/rewrite/TDB.h Normal file
View file

@ -0,0 +1,55 @@
////////////////////////////////////////////////////////////////////////////////
// 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
class TDB
{
public:
TDB (); // Default constructor
TDB (const TDB&); // Copy constructor
TDB& operator= (const TDB&); // Assignment operator
~TDB (); // Destructor
/*
location (path to task dir)
std::vector <T> load (filter)
caches all raw, including comments
update (T& old, T& new)
commit ()
writes all, including comments
autoupgrade ()
-> FF4
*/
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

58
src/rewrite/X.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////////////////////
// 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 "X.h"
////////////////////////////////////////////////////////////////////////////////
X::X ()
{
}
////////////////////////////////////////////////////////////////////////////////
X::X (const X& other)
{
// mOne = other.mOne;
}
////////////////////////////////////////////////////////////////////////////////
X& X::operator= (const X& other)
{
if (this != &other)
{
// mOne = other.mOne;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
X::~X ()
{
}
////////////////////////////////////////////////////////////////////////////////

42
src/rewrite/X.h Normal file
View file

@ -0,0 +1,42 @@
////////////////////////////////////////////////////////////////////////////////
// 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_X
#define INCLUDED_X
class X
{
public:
X (); // Default constructor
X (const X&); // Copy constructor
X& operator= (const X&); // Assignment operator
~X (); // Destructor
private:
};
#endif
////////////////////////////////////////////////////////////////////////////////

23
src/rewrite/main.cpp Normal file
View file

@ -0,0 +1,23 @@
////////////////////////////////////////////////////////////////////////////////
#include "Context.h"
int main (int argc, char** argv)
{
try
{
Context c;
c.initialize ();
c.commandLine (argc, argv);
c.run ();
return 0;
}
catch (...)
{
}
return -1;
}
////////////////////////////////////////////////////////////////////////////////