summaryrefslogtreecommitdiff
path: root/src/containers/kolabcontainers.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/containers/kolabcontainers.cpp')
-rw-r--r--src/containers/kolabcontainers.cpp767
1 files changed, 767 insertions, 0 deletions
diff --git a/src/containers/kolabcontainers.cpp b/src/containers/kolabcontainers.cpp
new file mode 100644
index 0000000..47c76e3
--- /dev/null
+++ b/src/containers/kolabcontainers.cpp
@@ -0,0 +1,767 @@
+/*
+ * Copyright (C) 2011 Christian Mollekopf <mollekopf@kolabsys.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "kolabcontainers.h"
+#include "incidence_p.h"
+
+namespace Kolab {
+
+struct cDateTime::Private {
+ Private()
+ : year(-1),
+ month(-1),
+ day(-1),
+ hour(-1),
+ minute(-1),
+ second(-1),
+ isUtc(false){}
+
+ int year;
+ int month;
+ int day;
+ int hour;
+ int minute;
+ int second;
+ bool isUtc;
+ std::string timezone;
+};
+
+cDateTime::cDateTime()
+: d(new cDateTime::Private())
+{
+
+}
+
+cDateTime::cDateTime(int year, int month, int day, int hour, int minute, int second, bool isUtc)
+: d(new cDateTime::Private())
+{
+ d->year = year;
+ d->month = month;
+ d->day = day;
+ d->hour = hour;
+ d->minute = minute;
+ d->second = second;
+ d->isUtc = isUtc;
+}
+
+cDateTime::cDateTime(const std::string& timezone, int year, int month, int day, int hour, int minute, int second)
+: d(new cDateTime::Private())
+{
+ d->year = year;
+ d->month = month;
+ d->day = day;
+ d->hour = hour;
+ d->minute = minute;
+ d->second = second;
+ d->timezone = timezone;
+}
+
+cDateTime::cDateTime(int year, int month, int day)
+: d(new cDateTime::Private())
+{
+ d->year = year;
+ d->month = month;
+ d->day = day;
+}
+
+cDateTime::cDateTime(const Kolab::cDateTime &other)
+: d(new cDateTime::Private())
+{
+ *d = *other.d;
+}
+
+cDateTime::~cDateTime()
+{
+
+}
+
+
+void cDateTime::operator=(const Kolab::cDateTime &other)
+{
+ *d = *other.d;
+}
+
+bool cDateTime::operator==(const Kolab::cDateTime &other) const
+{
+ if ( d->year == other.year() &&
+ d->month == other.month() &&
+ d->day == other.day() &&
+ d->hour == other.hour() &&
+ d->minute == other.minute() &&
+ d->second== other.second() &&
+ d->isUtc== other.isUTC() &&
+ d->timezone== other.timezone()) {
+ return true;
+ }
+ return false;
+}
+
+
+
+int cDateTime::year() const
+{
+ return d->year;
+}
+
+int cDateTime::month() const
+{
+ return d->month;
+}
+
+int cDateTime::day() const
+{
+ return d->day;
+}
+
+int cDateTime::hour() const
+{
+ return d->hour;
+}
+
+int cDateTime::minute() const
+{
+ return d->minute;
+}
+
+int cDateTime::second() const
+{
+ return d->second;
+}
+
+bool cDateTime::isDateOnly() const
+{
+ if ((d->hour < 0) && (d->minute < 0) && (d->second < 0)) {
+ return true;
+ }
+ return false;
+}
+
+void cDateTime::setDate(int year, int month, int day)
+{
+ d->year = year;
+ d->month = month;
+ d->day = day;
+}
+void cDateTime::setTime(int hour, int minute, int second)
+{
+ d->hour = hour;
+ d->minute = minute;
+ d->second = second;
+}
+void cDateTime::setTimezone(const std::string &tz)
+{
+ d->timezone = tz;
+}
+void cDateTime::setUTC(bool utc)
+{
+ d->isUtc = utc;
+}
+
+bool cDateTime::isUTC() const
+{
+ return d->isUtc;
+}
+
+std::string cDateTime::timezone() const
+{
+ return d->timezone;
+}
+
+bool cDateTime::isValid() const
+{
+ return (d->year >= 0 && d->month >= 0 && d->day >= 0);
+}
+
+struct RecurrenceRule::Private
+{
+ Private()
+ : freq(FreqNone),
+ weekstart(Monday),
+ count(-1),
+ interval(1){};
+
+ Frequency freq;
+ Weekday weekstart;
+ cDateTime end;
+ int count;
+ int interval;
+ std::vector<int> bysecond;
+ std::vector<int> byminute;
+ std::vector<int> byhour;
+ std::vector<DayPos> byday;
+ std::vector<int> bymonthday;
+ std::vector<int> byyearday;
+ std::vector<int> byweekno;
+ std::vector<int> bymonth;
+};
+
+RecurrenceRule::RecurrenceRule()
+: d(new RecurrenceRule::Private)
+{
+
+}
+
+RecurrenceRule::RecurrenceRule(const Kolab::RecurrenceRule &other)
+: d(new RecurrenceRule::Private)
+{
+ *d = *other.d;
+}
+
+void RecurrenceRule::operator=(const Kolab::RecurrenceRule &other)
+{
+ *d = *other.d;
+}
+
+bool RecurrenceRule::operator==(const Kolab::RecurrenceRule &other) const
+{
+ if ( d->freq == other.frequency() &&
+ d->weekstart == other.weekStart() &&
+ d->end == other.end() &&
+ d->count == other.count() &&
+ d->interval == other.interval() &&
+ d->bysecond == other.bysecond() &&
+ d->byminute == other.byminute() &&
+ d->byhour == other.byhour() &&
+ d->byday == other.byday() &&
+ d->bymonthday == other.bymonthday() &&
+ d->byyearday == other.byyearday() &&
+ d->byweekno == other.byweekno() &&
+ d->bymonth == other.bymonth()) {
+ return true;
+ }
+ return false;
+}
+
+RecurrenceRule::~RecurrenceRule()
+{
+
+}
+
+void RecurrenceRule::setFrequency(RecurrenceRule::Frequency freq)
+{
+ d->freq = freq;
+}
+
+RecurrenceRule::Frequency RecurrenceRule::frequency() const
+{
+ return d->freq;
+}
+
+void RecurrenceRule::setWeekStart(Kolab::Weekday weekstart)
+{
+ d->weekstart = weekstart;
+}
+
+Kolab::Weekday RecurrenceRule::weekStart() const
+{
+ return d->weekstart;
+}
+
+void RecurrenceRule::setEnd(const Kolab::cDateTime &end)
+{
+ d->end = end;
+}
+
+cDateTime RecurrenceRule::end() const
+{
+ return d->end;
+}
+
+void RecurrenceRule::setCount(int count)
+{
+ d->count = count;
+}
+
+int RecurrenceRule::count() const
+{
+ return d->count;
+}
+
+void RecurrenceRule::setInterval(int interval)
+{
+ d->interval = interval;
+}
+
+int RecurrenceRule::interval() const
+{
+ return d->interval;
+}
+
+void RecurrenceRule::setBysecond(const std::vector< int >&by)
+{
+ d->bysecond = by;
+}
+
+
+std::vector< int > RecurrenceRule::bysecond() const
+{
+ return d->bysecond;
+}
+
+void RecurrenceRule::setByminute(const std::vector< int > &by)
+{
+ d->byminute = by;
+}
+
+std::vector< int > RecurrenceRule::byminute() const
+{
+ return d->byminute;
+}
+
+void RecurrenceRule::setByhour(const std::vector< int > &by)
+{
+ d->byhour = by;
+}
+
+std::vector< int > RecurrenceRule::byhour() const
+{
+ return d->byhour;
+}
+
+void RecurrenceRule::setByday(const std::vector< DayPos > &by)
+{
+ d->byday = by;
+}
+
+std::vector< DayPos > RecurrenceRule::byday() const
+{
+ return d->byday;
+}
+
+void RecurrenceRule::setBymonthday(const std::vector< int > &by)
+{
+ d->bymonthday = by;
+}
+
+std::vector< int > RecurrenceRule::bymonthday() const
+{
+ return d->bymonthday;
+}
+
+void RecurrenceRule::setByyearday(const std::vector< int > &by)
+{
+ d->byyearday = by;
+}
+
+std::vector< int > RecurrenceRule::byyearday() const
+{
+ return d->byyearday;
+}
+
+void RecurrenceRule::setByweekno(const std::vector< int > &by)
+{
+ d->byweekno = by;
+}
+
+std::vector< int > RecurrenceRule::byweekno() const
+{
+ return d->byweekno;
+}
+
+void RecurrenceRule::setBymonth(const std::vector< int > &by)
+{
+ d->bymonth = by;
+}
+
+std::vector< int > RecurrenceRule::bymonth() const
+{
+ return d->bymonth;
+}
+
+bool RecurrenceRule::isValid() const
+{
+ if (d->freq == FreqNone) {
+ return false;
+ }
+ return true;
+}
+
+
+
+struct Attendee::Private
+{
+ Private()
+ : partStat(PartNeedsAction),
+ role(Required),
+ rsvp(false),
+ cutype(CutypeIndividual)
+ {};
+
+ ContactReference contact;
+ PartStatus partStat;
+ Role role;
+ bool rsvp;
+ std::vector<ContactReference> delegatedTo;
+ std::vector<ContactReference> delegatedFrom;
+ Cutype cutype;
+};
+
+Attendee::Attendee()
+: d(new Attendee::Private)
+{
+
+}
+
+Attendee::Attendee(const ContactReference& contact)
+: d(new Attendee::Private)
+{
+ d->contact = contact;
+}
+
+Attendee::Attendee(const Kolab::Attendee &other)
+: d(new Attendee::Private)
+{
+ *d = *other.d;
+}
+
+void Attendee::operator=(const Kolab::Attendee &other)
+{
+ *d = *other.d;
+}
+
+Attendee::~Attendee()
+{
+
+}
+
+bool Attendee::operator==(const Kolab::Attendee &other) const
+{
+ if ( d->contact == other.contact() &&
+ d->partStat == other.partStat() &&
+ d->role == other.role() &&
+ d->rsvp == other.rsvp() &&
+ d->delegatedTo == other.delegatedTo() &&
+ d->delegatedFrom == other.delegatedFrom() &&
+ d->cutype == other.cutype()
+ ) {
+ return true;
+ }
+ return false;
+}
+
+bool Attendee::isValid() const
+{
+ return d->contact.isValid();
+};
+
+void Attendee::setContact(const ContactReference &c)
+{
+ d->contact = c;
+}
+
+ContactReference Attendee::contact() const
+{
+ return d->contact;
+}
+
+
+void Attendee::setPartStat(PartStatus partStat)
+{
+ d->partStat = partStat;
+}
+
+PartStatus Attendee::partStat() const
+{
+ return d->partStat;
+}
+
+void Attendee::setRole(Role role)
+{
+ d->role = role;
+}
+
+Role Attendee::role() const
+{
+ return d->role;
+}
+
+void Attendee::setRSVP(bool rsvp)
+{
+ d->rsvp = rsvp;
+}
+
+bool Attendee::rsvp() const
+{
+ return d->rsvp;
+}
+
+void Attendee::setDelegatedTo(const std::vector< ContactReference > &del)
+{
+ d->delegatedTo = del;
+}
+
+std::vector< ContactReference > Attendee::delegatedTo() const
+{
+ return d->delegatedTo;
+}
+
+void Attendee::setDelegatedFrom(const std::vector< ContactReference > &del)
+{
+ d->delegatedFrom = del;
+}
+
+std::vector< ContactReference > Attendee::delegatedFrom() const
+{
+ return d->delegatedFrom;
+}
+
+void Attendee::setCutype(Cutype type)
+{
+ d->cutype = type;
+}
+
+Cutype Attendee::cutype() const
+{
+ return d->cutype;
+}
+
+
+struct Attachment::Private
+{
+ std::string uri;
+ std::string data;
+ std::string mimetype;
+ std::string label;
+};
+
+Attachment::Attachment()
+: d(new Attachment::Private)
+{
+}
+
+Attachment::Attachment(const Kolab::Attachment &other)
+: d(new Attachment::Private)
+{
+ *d = *other.d;
+}
+
+void Attachment::operator=(const Kolab::Attachment &other)
+{
+ *d = *other.d;
+}
+
+Attachment::~Attachment()
+{
+}
+
+bool Attachment::operator==(const Kolab::Attachment &other) const
+{
+ return ( d->uri == other.uri() &&
+ d->data == other.data() &&
+ d->label == other.label() &&
+ d->mimetype == other.mimetype() );
+}
+
+void Attachment::setUri(const std::string &uri, const std::string& mimetype)
+{
+ d->uri = uri;
+ d->mimetype = mimetype;
+}
+
+std::string Attachment::uri() const
+{
+ return d->uri;
+}
+
+std::string Attachment::mimetype() const
+{
+ return d->mimetype;
+}
+
+void Attachment::setLabel(const std::string &label)
+{
+ d->label = label;
+}
+
+std::string Attachment::label() const
+{
+ return d->label;
+}
+
+void Attachment::setData(const std::string &data, const std::string& mimetype)
+{
+ d->data = data;
+ d->mimetype = mimetype;
+}
+
+std::string Attachment::data() const
+{
+ return d->data;
+}
+
+bool Attachment::isValid() const
+{
+ return !d->mimetype.empty(); //TODO use isValid variable
+}
+
+
+
+struct Alarm::Private
+{
+ Private(): relativeTo(Start),
+ numrepeat(0),
+ type(Alarm::InvalidAlarm) {};
+ std::string text;
+ Attachment audioFile;
+ std::string summary;
+ std::vector<ContactReference> attendees;
+ cDateTime start;
+ Duration relativeDuration;
+ Relative relativeTo;
+ Duration duration;
+ int numrepeat;
+ Type type;
+
+};
+
+Alarm::Alarm()
+: d(new Alarm::Private)
+{
+}
+
+Alarm::Alarm(const std::string &text)
+: d(new Alarm::Private)
+{
+ d->text = text;
+ d->type = DisplayAlarm;
+}
+
+
+Alarm::Alarm(const Kolab::Attachment& audio)
+: d(new Alarm::Private)
+{
+ d->audioFile = audio;
+ d->type = AudioAlarm;
+}
+
+Alarm::Alarm(const std::string& summary, const std::string& description, const std::vector<ContactReference> attendees)
+: d(new Alarm::Private)
+{
+ d->summary = summary;
+ d->text = description;
+ d->attendees = attendees;
+ d->type = EMailAlarm;
+
+}
+
+Alarm::Alarm(const Kolab::Alarm &other)
+: d(new Alarm::Private)
+{
+ *d = *other.d;
+}
+
+void Alarm::operator=(const Kolab::Alarm &other)
+{
+ *d = *other.d;
+}
+
+Alarm::~Alarm()
+{
+}
+
+bool Alarm::operator==(const Kolab::Alarm &other) const
+{
+ return ( d->text == other.description() &&
+ d->text == other.description() &&
+ d->audioFile == other.audioFile() &&
+ d->summary == other.summary() &&
+ d->attendees == other.attendees() &&
+ d->start == other.start() &&
+ d->relativeDuration == other.relativeStart() &&
+ d->relativeTo == other.relativeTo() &&
+ d->duration == other.duration() &&
+ d->numrepeat == other.numrepeat() );
+}
+
+std::string Alarm::text() const
+{
+ return d->text;
+}
+
+Attachment Alarm::audioFile() const
+{
+ return d->audioFile;
+}
+
+std::string Alarm::summary() const
+{
+ return d->summary;
+}
+
+std::string Alarm::description() const
+{
+ return d->text;
+}
+
+std::vector<ContactReference> Alarm::attendees() const
+{
+ return d->attendees;
+}
+
+void Alarm::setStart(const Kolab::cDateTime &start)
+{
+ d->start = start;
+}
+
+cDateTime Alarm::start() const
+{
+ return d->start;
+}
+
+void Alarm::setRelativeStart(const Kolab::Duration &duration, Relative relativeTo)
+{
+ d->relativeDuration = duration;
+ d->relativeTo = relativeTo;
+}
+
+Duration Alarm::relativeStart() const
+{
+ return d->relativeDuration;
+}
+
+Relative Alarm::relativeTo() const
+{
+ return d->relativeTo;
+}
+
+void Alarm::setDuration(const Kolab::Duration &duration, int numrepeat)
+{
+ d->numrepeat = numrepeat;
+ d->duration = duration;
+}
+
+Duration Alarm::duration() const
+{
+ return d->duration;
+}
+
+int Alarm::numrepeat() const
+{
+ return d->numrepeat;
+}
+
+Alarm::Type Alarm::type() const
+{
+ return d->type;
+}
+
+
+
+
+
+
+}//Namespace