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

Code Cleanup

Browse source 
- Eliminated obsolete Variant code.
This commit is contained in:
Paul Beckingham 2011-08-01 01:26:59 -04:00
parent 76760fe434
commit a7f694386a
6 changed files with 1 additions and 1017 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/CMakeLists.txt
View file

@ -35,7 +35,6 @@ set (task_SRCS A3.cpp A3.h
TransportRSYNC.cpp TransportRSYNC.h
TransportSSH.cpp TransportSSH.h
Uri.cpp Uri.h
Variant.cpp Variant.h
ViewTask.cpp ViewTask.h
ViewText.cpp ViewText.h
helpers.cpp

848
src/Variant.cpp
View file

@ -1,848 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// taskwarrior - a command line task list manager.
//
// Copyright 2006 - 2011, Paul Beckingham, Federico Hernandez.
// 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 <iostream>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <text.h>
#include <i18n.h>
#include <Context.h>
#include <Variant.h>
extern Context context;
////////////////////////////////////////////////////////////////////////////////
Variant::Variant ()
: _type (v_unknown)
, _raw ("")
, _raw_type ("")
, _bool (false)
, _integer (0)
, _double (0.0)
, _string ("")
, _date (0)
, _duration (0)
{
}
////////////////////////////////////////////////////////////////////////////////
Variant::Variant (const Variant& other)
{
_type = other._type;
_raw = other._raw;
_raw_type = other._raw_type;
// Explicitly copy only the relevant type. This saves memory.
switch (_type)
{
case v_boolean: _bool = other._bool; break;
case v_integer: _integer = other._integer; break;
case v_double: _double = other._double; break;
case v_string: _string = other._string; break;
case v_date: _date = other._date; break;
case v_duration: _duration = other._duration; break;
case v_unknown: break;
}
}
////////////////////////////////////////////////////////////////////////////////
Variant::Variant (const bool input)
: _type (v_boolean)
, _raw ("")
, _raw_type ("")
, _bool (input)
, _integer (0)
, _double (0.0)
, _string ("")
, _date (0)
, _duration (0)
{
}
////////////////////////////////////////////////////////////////////////////////
Variant::Variant (const int input)
: _type (v_integer)
, _raw ("")
, _raw_type ("")
, _bool (false)
, _integer (input)
, _double (0.0)
, _string ("")
, _date (0)
, _duration (0)
{
}
////////////////////////////////////////////////////////////////////////////////
Variant::Variant (const double& input)
: _type (v_double)
, _raw ("")
, _raw_type ("")
, _bool (false)
, _integer (0)
, _double (input)
, _string ("")
, _date (0)
, _duration (0)
{
}
////////////////////////////////////////////////////////////////////////////////
Variant::Variant (const std::string& input)
: _type (v_string)
, _raw ("")
, _raw_type ("")
, _bool (false)
, _integer (0)
, _double (0.0)
, _string (input)
, _date (0)
, _duration (0)
{
}
////////////////////////////////////////////////////////////////////////////////
Variant::Variant (const Date& input)
: _type (v_date)
, _raw ("")
, _raw_type ("")
, _bool (false)
, _integer (0)
, _double (0.0)
, _string ("")
, _date (input)
, _duration (0)
{
}
////////////////////////////////////////////////////////////////////////////////
Variant::Variant (const Duration& input)
: _type (v_duration)
, _raw ("")
, _raw_type ("")
, _bool (false)
, _integer (0)
, _double (0.0)
, _string ("")
, _date (0)
, _duration (input)
{
}
////////////////////////////////////////////////////////////////////////////////
// For copying.
Variant& Variant::operator= (const Variant& other)
{
if (this != &other)
{
_type = other._type;
_bool = other._bool;
_integer = other._integer;
_double = other._double;
_string = other._string;
_date = other._date;
_duration = other._duration;
_raw = other._raw;
_raw_type = other._raw_type;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator&& (Variant& other)
{
cast (v_boolean);
other.cast (v_boolean);
return _bool && other._bool;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator|| (Variant& other)
{
cast (v_boolean);
other.cast (v_boolean);
return _bool || other._bool;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator<= (Variant& other)
{
promote (*this, other);
bool result;
switch (_type)
{
case v_boolean:
throw std::string (STRING_VARIANT_REL_BOOL);
break;
case v_integer:
result = _integer <= other._integer;
break;
case v_double:
result = _double <= other._double;
break;
case v_string:
{
int collating = strcmp (_string.c_str (), other._string.c_str ());
result = collating <= 0;
}
break;
case v_date:
result = _date <= other._date;
break;
case v_duration:
result = _duration <= other._duration;
break;
case v_unknown:
throw std::string (STRING_VARIANT_REL_UNKNOWN);
break;
}
return result;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator>= (Variant& other)
{
promote (*this, other);
bool result;
switch (_type)
{
case v_boolean:
throw std::string (STRING_VARIANT_REL_BOOL);
break;
case v_integer:
result = _integer >= other._integer;
break;
case v_double:
result = _double >= other._double;
break;
case v_string:
{
int collating = strcmp (_string.c_str (), other._string.c_str ());
result = collating >= 0;
}
break;
case v_date:
result = _date >= other._date;
break;
case v_duration:
result = _duration >= other._duration;
break;
case v_unknown:
throw std::string (STRING_VARIANT_REL_UNKNOWN);
break;
}
return result;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator== (Variant& other)
{
promote (*this, other);
bool result;
switch (_type)
{
case v_boolean:
result = _bool == other._bool;
break;
case v_integer:
result = _integer == other._integer;
break;
case v_double:
result = _double == other._double;
break;
case v_string:
{
int collating = strcmp (_string.c_str (), other._string.c_str ());
result = collating == 0;
}
break;
case v_date:
result = _date == other._date;
break;
case v_duration:
result = _duration == other._duration;
break;
case v_unknown:
throw std::string (STRING_VARIANT_REL_UNKNOWN);
break;
}
return result;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator!= (Variant& other)
{
promote (*this, other);
bool result;
switch (_type)
{
case v_boolean:
result = _bool != other._bool;
break;
case v_integer:
result = _integer != other._integer;
break;
case v_double:
result = _double != other._double;
break;
case v_string:
{
int collating = strcmp (_string.c_str (), other._string.c_str ());
result = collating != 0;
}
break;
case v_date:
result = _date != other._date;
break;
case v_duration:
result = _duration != other._duration;
break;
case v_unknown:
throw std::string (STRING_VARIANT_REL_UNKNOWN);
break;
}
return result;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator! ()
{
cast (v_boolean);
_bool = ! _bool;
return _bool;
}
////////////////////////////////////////////////////////////////////////////////
Variant& Variant::operator- (Variant& other)
{
promote (*this, other);
switch (_type)
{
case v_boolean:
throw std::string ("Cannot perform subtraction on Boolean types");
break;
case v_integer:
_integer -= other._integer;
break;
case v_double:
_double -= other._double;
break;
case v_string:
throw std::string ("Cannot perform subtraction on string types");
break;
case v_date:
_duration = Duration (_date - other._date);
_type = v_duration;
break;
case v_duration:
_duration = _duration - other._duration;
break;
case v_unknown:
throw std::string ("Cannot perform subtraction on unknown types");
break;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Variant& Variant::operator+ (Variant& other)
{
promote (*this, other);
switch (_type)
{
case v_boolean:
throw std::string ("Cannot perform addition on Boolean types");
break;
case v_integer:
_integer += other._integer;
break;
case v_double:
_double += other._double;
break;
case v_string:
_string += other._string;
break;
case v_date:
// TODO operator+ only works for int
//_date += other._date;
break;
case v_duration:
// TODO operator+ missing
//_duration += other._duration;
break;
case v_unknown:
throw std::string ("Cannot perform addition on unknown types");
break;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Variant& Variant::operator* (Variant& other)
{
promote (*this, other);
switch (_type)
{
case v_boolean:
throw std::string ("Cannot perform multiplication on Boolean types");
break;
case v_integer:
_integer *= other._integer;
break;
case v_double:
_double *= other._double;
break;
case v_string:
throw std::string ("Cannot perform multiplication on string types");
break;
case v_date:
throw std::string ("Cannot perform multiplication on date types");
break;
case v_duration:
throw std::string ("Cannot perform multiplication on duration types");
break;
case v_unknown:
throw std::string ("Cannot perform multiplication on unknown types");
break;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Variant& Variant::operator/ (Variant& other)
{
promote (*this, other);
switch (_type)
{
case v_boolean:
throw std::string ("Cannot perform division on Boolean types");
break;
case v_integer:
_integer /= other._integer;
break;
case v_double:
_double /= other._double;
break;
case v_string:
throw std::string ("Cannot perform division on string types");
break;
case v_date:
throw std::string ("Cannot perform division on date types");
break;
case v_duration:
throw std::string ("Cannot perform division on duration types");
break;
case v_unknown:
throw std::string ("Cannot perform division on unknown types");
break;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator< (Variant& other)
{
promote (*this, other);
bool result;
switch (_type)
{
case v_boolean:
throw std::string (STRING_VARIANT_REL_BOOL);
break;
case v_integer:
result = _integer < other._integer;
break;
case v_double:
result = _double < other._double;
break;
case v_string:
{
int collating = strcmp (_string.c_str (), other._string.c_str ());
result = collating < 0;
}
break;
case v_date:
result = _date < other._date;
break;
case v_duration:
result = _duration < other._duration;
break;
case v_unknown:
throw std::string (STRING_VARIANT_REL_UNKNOWN);
break;
}
return result;
}
////////////////////////////////////////////////////////////////////////////////
bool Variant::operator> (Variant& other)
{
promote (*this, other);
bool result;
switch (_type)
{
case v_boolean:
throw std::string (STRING_VARIANT_REL_BOOL);
break;
case v_integer:
result = _integer > other._integer;
break;
case v_double:
result = _double > other._double;
break;
case v_string:
{
int collating = strcmp (_string.c_str (), other._string.c_str ());
result = collating > 0;
}
break;
case v_date:
result = _date > other._date;
break;
case v_duration:
result = _duration > other._duration;
break;
case v_unknown:
throw std::string (STRING_VARIANT_REL_UNKNOWN);
break;
}
return result;
}
////////////////////////////////////////////////////////////////////////////////
void Variant::input (const std::string& input)
{
if (! compare (input, "true", false) ||
! compare (input, "t", false) ||
! compare (input, "yes", false) ||
! compare (input, "on", false))
{
_type = v_boolean;
_bool = true;
return;
}
if (! compare (input, "false", false) ||
! compare (input, "f", false) ||
! compare (input, "no", false) ||
! compare (input, "off", false))
{
_type = v_boolean;
_bool = false;
return;
}
// Attempt Date (input) parse.
if (Date::valid (input, context.config.get ("dateformat")))
{
_type = v_date;
_date = Date (input);
return;
}
// Attempt Duration (input) parse.
if (Duration::valid (input))
{
_type = v_duration;
_duration = Duration (input);
return;
}
bool numeric = true;
bool period = false;
for (unsigned int i = 0; i < input.length (); ++i)
{
if (input[i] == '.') period = true;
if (!isdigit (input[i]) && input[i] != '.') numeric = false;
}
if (numeric)
{
if (period)
{
_type = v_double;
_double = atof (input.c_str ());
}
else
{
_type = v_integer;
_integer = atoi (input.c_str ());
}
return;
}
_type = v_string;
_string = input;
}
////////////////////////////////////////////////////////////////////////////////
std::string Variant::format ()
{
std::string output;
switch (_type)
{
case v_boolean:
output = _bool ? "true" : "false";
break;
case v_integer:
{
char temp [24];
sprintf (temp, "%d", _integer);
output = temp;
}
break;
case v_double:
{
char temp [24];
sprintf (temp, "%g", _double);
output = temp;
}
break;
case v_string:
output = _string;
break;
case v_date:
output = _date.toString (context.config.get ("dateformat"));
break;
case v_duration:
output = _duration.formatCompact ();
break;
case v_unknown:
default:
throw std::string ("Cannot render an unknown type.");
break;
}
return output;
}
////////////////////////////////////////////////////////////////////////////////
void Variant::cast (const variant_type type)
{
if (_type == v_unknown || type == v_unknown)
throw std::string ("Cannot coerce data either to or from an unknown type");
// Short circuit.
if (_type == type)
return;
// From v_boolean
if (_type == v_boolean && type == v_integer)
_integer = _bool ? 1 : 0;
else if (_type == v_boolean && type == v_double)
_double = _bool ? 1.0 : 0.0;
else if (_type == v_boolean && type == v_string)
_string = _bool ? "true" : "false";
// From v_integer
else if (_type == v_integer && type == v_boolean)
_bool = _integer == 0 ? false : true;
else if (_type == v_integer && type == v_double)
_double = (double)_integer;
else if (_type == v_integer && type == v_string)
{
char temp [24];
sprintf (temp, "%d", _integer);
_string = temp;
}
// From v_double
else if (_type == v_double && type == v_boolean)
_bool = _double == 0.0 ? false : true;
else if (_type == v_double && type == v_integer)
_integer = (int)_double;
else if (_type == v_double && type == v_string)
{
char temp [24];
sprintf (temp, "%g", _double);
_string = temp;
}
// From v_string
else if (_type == v_string && type == v_boolean)
_bool = (_string.length () == 0 ||
_string == "0" ||
_string == "0.0") ? false : true;
else if (_type == v_string && type == v_integer)
_integer = atol (_string.c_str ());
else if (_type == v_string && type == v_double)
_double = atol (_string.c_str ());
// TODO From v_date
// TODO From v_duration
_type = type;
}
////////////////////////////////////////////////////////////////////////////////
void Variant::promote (Variant& lhs, Variant& rhs)
{
// Short circuit.
if (lhs._type == rhs._type)
return;
variant_type newType;
switch (lhs._type | rhs._type)
{
case v_boolean | v_integer: newType = v_integer; break;
case v_boolean | v_double: newType = v_double; break;
case v_boolean | v_string: newType = v_string; break;
case v_boolean | v_date: newType = v_date; break;
case v_boolean | v_duration: newType = v_duration; break;
case v_integer | v_double: newType = v_integer; break;
case v_integer | v_string: newType = v_string; break;
case v_integer | v_date: newType = v_date; break;
case v_integer | v_duration: newType = v_duration; break;
case v_double | v_string: newType = v_string; break;
case v_double | v_date: newType = v_date; break;
case v_double | v_duration: newType = v_duration; break;
case v_string | v_date: newType = v_date; break;
case v_string | v_duration: newType = v_duration; break;
case v_date | v_duration: newType = v_date; break;
}
lhs.cast (newType);
rhs.cast (newType);
}
////////////////////////////////////////////////////////////////////////////////
// Casts to boolean and returns the value. Used to evaluating expression
// results.
bool Variant::boolean ()
{
cast (v_boolean);
return _bool;
}
////////////////////////////////////////////////////////////////////////////////
std::string Variant::dump ()
{
return format () + "/" + _raw + "/" + _raw_type;
}
////////////////////////////////////////////////////////////////////////////////

98
src/Variant.h
View file

@ -1,98 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
// taskwarrior - a command line task list manager.
//
// Copyright 2006 - 2011, Paul Beckingham, Federico Hernandez.
// 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_VARIANT
#define INCLUDED_VARIANT
#define L10N // Localization complete.
#include <string>
#include <time.h>
#include <Date.h>
#include <Duration.h>
class Variant
{
public:
enum variant_type
{
v_unknown = 1,
v_boolean = 2,
v_integer = 4,
v_double = 8,
v_string = 16,
v_date = 32,
v_duration = 64
};
Variant ();
Variant (const Variant&);
Variant (const bool);
Variant (const int);
Variant (const double&);
Variant (const std::string&);
Variant (const Date&);
Variant (const Duration&);
Variant& operator= (const Variant&);
bool operator&& (Variant& other);
bool operator|| (Variant& other);
bool operator<= (Variant& other);
bool operator>= (Variant& other);
bool operator== (Variant& other);
bool operator< (Variant& other);
bool operator> (Variant& other);
bool operator!= (Variant& other);
bool operator! ();
Variant& operator- (Variant& other);
Variant& operator+ (Variant& other);
Variant& operator* (Variant& other);
Variant& operator/ (Variant& other);
void input (const std::string&);
std::string format ();
void cast (const variant_type);
void promote (Variant&, Variant&);
bool boolean ();
std::string dump ();
public:
variant_type _type;
std::string _raw;
std::string _raw_type;
bool _bool;
int _integer;
double _double;
std::string _string;
Date _date;
Duration _duration;
};
#endif
////////////////////////////////////////////////////////////////////////////////

4
src/en-US.h
View file

@ -465,9 +465,5 @@
#define STRING_UTIL_KIBIBYTES "KiB"
#define STRING_UTIL_BYTES "B"
// Variant
#define STRING_VARIANT_REL_BOOL "Cannot perform relational comparison on Boolean types."
#define STRING_VARIANT_REL_UNKNOWN "Cannot perform relational comparison on unknown types."
#endif