346 lines
7.0 KiB
C++
346 lines
7.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 MStrings.h
|
|
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "AlmostEqual.h"
|
|
#include "MFsObjects.h"
|
|
#include "IStrings.h"
|
|
|
|
namespace ColumnMovingAlgebra
|
|
{
|
|
/*
|
|
1.1 Forward Declaration of ~StringUnit~
|
|
|
|
~StringUnit~ represents a moving string unit
|
|
|
|
*/
|
|
class StringUnit;
|
|
|
|
/*
|
|
1.1 Declaration of ~MStrings~
|
|
|
|
~MStrings~ represents a string boolean
|
|
|
|
*/
|
|
typedef MFsObjects<StringUnit> MStrings;
|
|
|
|
/*
|
|
1.2 Declaration of class ~StringUnit~
|
|
|
|
*/
|
|
class StringUnit
|
|
{
|
|
public:
|
|
static const int STRING_SIZE = 49;
|
|
|
|
struct Value {
|
|
char s[STRING_SIZE];
|
|
bool operator < (const Value & b) const;
|
|
};
|
|
typedef IStrings Instants;
|
|
typedef CcString Attr;
|
|
typedef temporalalgebra::RString RAttr;
|
|
typedef temporalalgebra::MString MAttr;
|
|
|
|
/*
|
|
constructors
|
|
|
|
*/
|
|
StringUnit() = default;
|
|
StringUnit(temporalalgebra::MString mstring, int unit);
|
|
StringUnit(Interval interval, std::string str);
|
|
|
|
/*
|
|
~interval~ returns the definition interval of this unit
|
|
|
|
*/
|
|
Interval interval() const;
|
|
/*
|
|
~minimum~ returns the minimum value of the mapping function during the
|
|
definition interval
|
|
|
|
*/
|
|
Value minimum() const;
|
|
/*
|
|
~maximum~ returns the maximum value of the mapping function during the
|
|
definition interval
|
|
|
|
*/
|
|
Value maximum() const;
|
|
/*
|
|
~appendTo~ adds this unit to a moving object in the temporal algebra
|
|
|
|
*/
|
|
void appendTo(temporalalgebra::MString & mstring);
|
|
/*
|
|
~compareValue~ compares this unit
|
|
|
|
*/
|
|
int compareValue(const StringUnit & stringUnit);
|
|
/*
|
|
~atInstant~ returns an intime for ~instant~
|
|
|
|
*/
|
|
temporalalgebra::IString atInstant(Instant instant);
|
|
/*
|
|
~restrictToInterval~ restricts the unit to ~unitInterval~
|
|
|
|
*/
|
|
StringUnit restrictToInterval(Interval unitInterval);
|
|
/*
|
|
~passes~ returns true, iff this this unit has the same value
|
|
|
|
*/
|
|
bool passes(CcString ccString);
|
|
/*
|
|
or iff the value is in the specified range
|
|
|
|
*/
|
|
bool passes(temporalalgebra::RString rString);
|
|
/*
|
|
~at~ adds this unit to ~result~ iff it has the same value as specified
|
|
|
|
*/
|
|
void at(CcString ccString, MStrings & result);
|
|
/*
|
|
of iff its value is in the specified range
|
|
|
|
*/
|
|
void at(temporalalgebra::RString rString, MStrings & result);
|
|
|
|
/*
|
|
~undefinedAttr~ returns an undefined attribute
|
|
|
|
*/
|
|
static CcString undefinedAttr();
|
|
/*
|
|
~compare~
|
|
returns -1 if ~value~ smaller ~attr~,
|
|
returns 0 if ~value~ equal ~attr~,
|
|
returns 1 if ~value~ greater ~attr~
|
|
|
|
*/
|
|
static int compare(Value value, Attr attr);
|
|
/*
|
|
~random~ returns a unit with the specified interval and a random value
|
|
|
|
*/
|
|
static StringUnit random(Interval interval);
|
|
|
|
private:
|
|
/*
|
|
~mInterval~ represents the definition interval of this unit
|
|
|
|
*/
|
|
Interval m_Interval;
|
|
/*
|
|
~mValue~ represents the value of this unit
|
|
|
|
*/
|
|
char m_Value[STRING_SIZE];
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
1.2 Implementation of class ~StringUnit~
|
|
|
|
comparision operator for string values
|
|
|
|
*/
|
|
inline bool StringUnit::Value::operator < (const Value & b) const
|
|
{
|
|
return strcmp(s, b.s) < 0;
|
|
}
|
|
|
|
/*
|
|
constructors
|
|
|
|
*/
|
|
inline StringUnit::StringUnit(temporalalgebra::MString mstring, int unit)
|
|
{
|
|
temporalalgebra::UString u;
|
|
mstring.Get(unit, u);
|
|
m_Interval = u.timeInterval;
|
|
snprintf(m_Value, STRING_SIZE, "%s", u.constValue.GetValue().c_str());
|
|
}
|
|
|
|
inline StringUnit::StringUnit(Interval interval, std::string str) :
|
|
m_Interval(interval)
|
|
{
|
|
snprintf(m_Value, STRING_SIZE, "%s", str.c_str());
|
|
}
|
|
|
|
/*
|
|
~minimum~ returns the minimum value of the mapping function during the
|
|
definition interval
|
|
|
|
*/
|
|
inline StringUnit::Value StringUnit::minimum() const
|
|
{
|
|
Value v;
|
|
strcpy(v.s, m_Value);
|
|
return v;
|
|
}
|
|
|
|
/*
|
|
~maximum~ returns the maximum value of the mapping function during the
|
|
definition interval
|
|
|
|
*/
|
|
inline StringUnit::Value StringUnit::maximum() const
|
|
{
|
|
Value v;
|
|
strcpy(v.s, m_Value);
|
|
return v;
|
|
}
|
|
|
|
/*
|
|
~interval~ returns the definition interval of this unit
|
|
|
|
*/
|
|
inline Interval StringUnit::interval() const
|
|
{
|
|
return m_Interval;
|
|
}
|
|
|
|
/*
|
|
~appendTo~ adds this unit to a moving object in the temporal algebra
|
|
|
|
*/
|
|
inline void StringUnit::appendTo(
|
|
temporalalgebra::MString & mstring)
|
|
{
|
|
mstring.Add(temporalalgebra::UString(m_Interval.convert(),
|
|
CcString(true, std::string(m_Value))));
|
|
}
|
|
|
|
/*
|
|
~compareValue~ compares this unit
|
|
|
|
*/
|
|
inline int StringUnit::compareValue(const StringUnit & stringUnit)
|
|
{
|
|
return strcmp(m_Value, stringUnit.m_Value);
|
|
}
|
|
|
|
/*
|
|
~atInstant~ returns an intime for ~instant~
|
|
|
|
*/
|
|
inline temporalalgebra::IString StringUnit::atInstant(Instant instant)
|
|
{
|
|
return temporalalgebra::IString(instant,
|
|
CcString(true, std::string(m_Value)));
|
|
}
|
|
|
|
/*
|
|
~restrictToInterval~ restricts the unit to ~unitInterval~
|
|
|
|
*/
|
|
inline StringUnit StringUnit::restrictToInterval(Interval unitInterval)
|
|
{
|
|
StringUnit u;
|
|
u.m_Interval = unitInterval;
|
|
strcpy(u.m_Value, m_Value);
|
|
return u;
|
|
}
|
|
|
|
/*
|
|
~passes~ returns true, iff this this unit has the same value
|
|
|
|
*/
|
|
inline bool StringUnit::passes(CcString ccString)
|
|
{
|
|
return strcmp(m_Value, ccString.GetValue().c_str()) == 0;
|
|
}
|
|
|
|
/*
|
|
or iff the value is in the specified range
|
|
|
|
*/
|
|
inline bool StringUnit::passes(temporalalgebra::RString rString)
|
|
{
|
|
return rString.Contains(CcString(true, std::string(m_Value)));
|
|
}
|
|
|
|
/*
|
|
~at~ adds this unit to ~result~ iff it has the same value as specified
|
|
|
|
*/
|
|
inline void StringUnit::at(CcString ccString, MStrings & result)
|
|
{
|
|
if (passes(ccString))
|
|
result.addUnit(*this);
|
|
}
|
|
|
|
/*
|
|
of iff its value is in the specified range
|
|
|
|
*/
|
|
inline void StringUnit::at(temporalalgebra::RString rString,
|
|
MStrings & result)
|
|
{
|
|
if (passes(rString))
|
|
result.addUnit(*this);
|
|
}
|
|
|
|
/*
|
|
~undefinedAttr~ returns an undefined attribute
|
|
|
|
*/
|
|
inline CcString StringUnit::undefinedAttr()
|
|
{
|
|
CcString r(false, std::string());
|
|
r.SetDefined(false);
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
~compare~
|
|
returns -1 if ~value~ smaller ~attr~,
|
|
returns 0 if ~value~ equal ~attr~,
|
|
returns 1 if ~value~ greater ~attr~
|
|
|
|
*/
|
|
inline int StringUnit::compare(Value value, Attr attr)
|
|
{
|
|
const char *b = attr.GetValue().c_str();
|
|
int r = strcmp(value.s, b);;
|
|
return r < 0 ? -1 : (r == 0 ? 0 : 1);
|
|
}
|
|
|
|
/*
|
|
~random~ returns a unit with the specified interval and a random value
|
|
|
|
*/
|
|
inline StringUnit StringUnit::random(Interval interval)
|
|
{
|
|
return StringUnit(interval, std::to_string(rand()));
|
|
}
|
|
}
|