300 lines
6.0 KiB
C++
300 lines
6.0 KiB
C++
/*
|
|
----
|
|
This file is part of SECONDO.
|
|
|
|
Copyright (C) 2004-2009, University in Hagen, Faculty of Mathematics
|
|
and Computer Science, Database Systems for New Applications.
|
|
|
|
SECONDO 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.
|
|
|
|
SECONDO 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 SECONDO; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
----
|
|
|
|
1 Interval.h
|
|
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "Algebras/Temporal/TemporalAlgebra.h"
|
|
|
|
namespace ColumnMovingAlgebra
|
|
{
|
|
/*
|
|
1.1 Declaration of struct ~Interval~
|
|
|
|
~Interval~ represents a time interval
|
|
|
|
*/
|
|
struct Interval {
|
|
/*
|
|
~s~ and ~e~ represent the left and right boundary of the time interval.
|
|
~lc~ and ~rc~ determine, wether the interval is left closed respectively
|
|
right closed
|
|
|
|
|
|
*/
|
|
int64_t s, e;
|
|
bool lc, rc;
|
|
|
|
/*
|
|
default constructor
|
|
|
|
*/
|
|
Interval() = default;
|
|
/*
|
|
constructor with explicit values
|
|
|
|
*/
|
|
Interval(int64_t s, int64_t e, bool lc, bool rc);
|
|
/*
|
|
constructor for conversion from the time interval class of the Temporal algebra
|
|
|
|
*/
|
|
Interval(temporalalgebra::Interval<Instant> i);
|
|
/*
|
|
~convert~ convertes the time interval to the representation used in the
|
|
Temporal algebra
|
|
|
|
*/
|
|
temporalalgebra::Interval<Instant> convert();
|
|
|
|
/*
|
|
~length~ returns the duration of the time interval
|
|
|
|
*/
|
|
int64_t length();
|
|
/*
|
|
~before~ returns true, iff ~instant~ is before the start of the time interval
|
|
|
|
*/
|
|
bool before(int64_t instant);
|
|
/*
|
|
~after~ returns true, iff ~instant~ is after the end of the time interval
|
|
|
|
*/
|
|
bool after(int64_t instant);
|
|
/*
|
|
~contains~ returns true, iff ~instant~ is in the time interval
|
|
|
|
*/
|
|
bool contains(int64_t instant);
|
|
/*
|
|
~before~ returns true, iff this interval ends before ~b~ starts
|
|
|
|
*/
|
|
bool before(Interval & b);
|
|
/*
|
|
~after~ returns true, iff this interval starts after ~b~ ends
|
|
|
|
*/
|
|
bool after(Interval & b);
|
|
/*
|
|
~intersects~ returns true, iff the intersection of this interval and ~b~
|
|
is not empty
|
|
|
|
*/
|
|
bool intersects(Interval & b);
|
|
/*
|
|
~intersection~ returns the intersection of this interval and ~b~
|
|
|
|
*/
|
|
Interval intersection(Interval & b);
|
|
/*
|
|
~endsFirstComparedTo~ returns true, iff this interval ends before ~b~ ends
|
|
|
|
*/
|
|
bool endsFirstComparedTo(Interval & b);
|
|
/*
|
|
~compare~ defines a ordering relation on time intervals.
|
|
returns -1 if this interval is smaller than b.
|
|
returns 0 if this interval is equal to b.
|
|
returns 1 if this interval is greater than b.
|
|
|
|
*/
|
|
int compare(Interval b);
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
1.1 Implementation of struct ~Interval~
|
|
|
|
constructor with explicit values
|
|
|
|
*/
|
|
inline Interval::Interval(int64_t s, int64_t e, bool lc, bool rc) :
|
|
s(s),
|
|
e(e),
|
|
lc(lc),
|
|
rc(rc)
|
|
{
|
|
}
|
|
/*
|
|
constructor for conversion from the time interval class of the Temporal algebra
|
|
|
|
*/
|
|
inline Interval::Interval(temporalalgebra::Interval<Instant> i) :
|
|
s(i.start.millisecondsToNull()),
|
|
e(i.end.millisecondsToNull()),
|
|
lc(i.lc),
|
|
rc(i.rc)
|
|
{
|
|
}
|
|
|
|
/*
|
|
~convert~ convertes the time interval to the representation used in the
|
|
Temporal algebra
|
|
|
|
*/
|
|
inline temporalalgebra::Interval<Instant> Interval::convert()
|
|
{
|
|
return temporalalgebra::Interval<Instant>(s, e, lc, rc);
|
|
}
|
|
|
|
/*
|
|
~length~ returns the duration of the time interval
|
|
|
|
*/
|
|
inline int64_t ColumnMovingAlgebra::Interval::length()
|
|
{
|
|
return e - s;
|
|
}
|
|
|
|
/*
|
|
~before~ returns true, iff ~instant~ is before the start of the time interval
|
|
|
|
*/
|
|
inline bool Interval::before(int64_t instant)
|
|
{
|
|
return e < instant || (e == instant && !rc);
|
|
}
|
|
|
|
/*
|
|
~after~ returns true, iff ~instant~ is after the end of the time interval
|
|
|
|
*/
|
|
inline bool Interval::after(int64_t instant)
|
|
{
|
|
return s > instant || (s == instant && !lc);
|
|
}
|
|
|
|
/*
|
|
~contains~ returns true, iff ~instant~ is in the time interval
|
|
|
|
*/
|
|
inline bool ColumnMovingAlgebra::Interval::contains(int64_t instant)
|
|
{
|
|
return !before(instant) && !after(instant);
|
|
}
|
|
|
|
/*
|
|
~before~ returns true, iff this interval ends before ~b~ starts
|
|
|
|
*/
|
|
inline bool Interval::before(Interval & b)
|
|
{
|
|
return e < b.s || (e == b.s && (!rc || !b.lc));
|
|
}
|
|
|
|
/*
|
|
~after~ returns true, iff this interval starts after ~b~ ends
|
|
|
|
*/
|
|
inline bool Interval::after(Interval & b)
|
|
{
|
|
return s > b.e || (s == b.e && (!lc || !b.rc));
|
|
}
|
|
|
|
/*
|
|
~intersects~ returns true, iff the intersection of this interval and ~b~
|
|
is not empty
|
|
|
|
*/
|
|
inline bool Interval::intersects(Interval & b)
|
|
{
|
|
return !before(b) && !after(b);
|
|
}
|
|
|
|
/*
|
|
~intersection~ returns the intersection of this interval and ~b~
|
|
|
|
*/
|
|
inline Interval Interval::intersection(Interval & b)
|
|
{
|
|
Interval i;
|
|
|
|
if (s > b.s) {
|
|
i.s = s;
|
|
i.lc = lc;
|
|
}
|
|
else if (s < b.s) {
|
|
i.s = b.s;
|
|
i.lc = b.lc;
|
|
} else {
|
|
i.s = s;
|
|
i.lc = lc && b.lc;
|
|
}
|
|
|
|
if (e < b.e) {
|
|
i.e = e;
|
|
i.rc = rc;
|
|
} else if (e > b.e) {
|
|
i.e = b.e;
|
|
i.rc = b.rc;
|
|
} else {
|
|
i.e = e;
|
|
i.rc = rc && b.rc;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
~endsFirstComparedTo~ returns true, iff this interval ends before ~b~ ends
|
|
|
|
*/
|
|
inline bool Interval::endsFirstComparedTo(Interval & b)
|
|
{
|
|
return e < b.e || (e == b.e && !rc && b.rc);
|
|
}
|
|
|
|
/*
|
|
~compare~ defines a ordering relation on time intervals.
|
|
returns -1 if this interval is smaller than b.
|
|
returns 0 if this interval is equal to b.
|
|
returns 1 if this interval is greater than b.
|
|
|
|
*/
|
|
inline int Interval::compare(Interval b)
|
|
{
|
|
int64_t tDiff;
|
|
|
|
tDiff = s - b.s;
|
|
if (tDiff != 0)
|
|
return tDiff < 0 ? -1 : 1;
|
|
|
|
tDiff = e - b.e;
|
|
if (tDiff != 0)
|
|
return tDiff < 0 ? -1 : 1;
|
|
|
|
if (lc != b.lc)
|
|
return lc ? -1 : 1;
|
|
|
|
if (rc != b.rc)
|
|
return rc ? -1 : 1;
|
|
|
|
return 0;
|
|
}
|
|
}
|