Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/range_8hpp_source.html below:

NCBI C++ ToolKit: include/util/range.hpp Source File

<

Signed,

Position>

<

Position>

<

Position>

<

Position>

struct SPositionTraits<float> : SPositionTraitsBySignedness<true, float>

struct SPositionTraits<double> : SPositionTraitsBySignedness<true, double>

struct SPositionTraits<long double>

: SPositionTraitsBySignedness<true, long double>

template<class Position>

typedef Position position_type;

typedef COpenRange<Position> TThisType;

: m_From(GetEmptyFrom()), m_ToOpen(GetEmptyToOpen())

COpenRange(position_type from, position_type toOpen)

: m_From(from), m_ToOpen(toOpen)

position_type GetFrom(void) const

position_type GetToOpen(void) const

position_type GetTo(void) const

return GetToOpen()-1;

bool Empty(void) const

return GetToOpen() <= GetFrom();

bool NotEmpty(void) const

return GetToOpen() > GetFrom();

position_type GetLength(void) const

position_type from = GetFrom(), toOpen = GetToOpen();

if ( toOpen <= from )

position_type len = toOpen - from;

if ( SPositionTraits<position_type>::IsNegative(len) )

len = GetWholeLength();

TThisType& SetFrom(position_type from)

TThisType& SetToOpen(position_type toOpen)

TThisType& SetTo(position_type to)

return SetToOpen(to+1);

TThisType& SetOpen(position_type from, position_type toOpen)

return SetFrom(from).SetToOpen(toOpen);

TThisType& Set(position_type from, position_type to)

return SetFrom(from).SetTo(to);

TThisType& SetLength(position_type length)

_ASSERT(!SPositionTraits<position_type>::IsNegative(length));

position_type from = GetFrom();

position_type toOpen = from + length;

toOpen = GetWholeToOpen();

return SetToOpen(toOpen);

TThisType& SetLengthDown(position_type length)

_ASSERT(length >= 0);

position_type toOpen = GetToOpen();

position_type from = toOpen - length;

from = GetWholeFrom();

return SetFrom(from);

bool operator==(const TThisType& r) const

return GetFrom() == r.GetFrom() && GetToOpen() == r.GetToOpen();

bool operator!=(const TThisType& r) const

return !(*this == r);

bool operator<(const TThisType& r) const

return GetFrom() < r.GetFrom() ||

(GetFrom() == r.GetFrom() && GetToOpen() < r.GetToOpen());

bool operator<=(const TThisType& r) const

return GetFrom() < r.GetFrom() ||

(GetFrom() == r.GetFrom() && GetToOpen() <= r.GetToOpen());

bool operator>(const TThisType& r) const

return GetFrom() > r.GetFrom() ||

(GetFrom() == r.GetFrom() && GetToOpen() > r.GetToOpen());

bool operator>=(const TThisType& r) const

return GetFrom() > r.GetFrom() ||

(GetFrom() == r.GetFrom() && GetToOpen() >= r.GetToOpen());

static position_type GetPositionMin(void)

return numeric_limits<position_type>::min();

static position_type GetPositionMax(void)

return numeric_limits<position_type>::max();

static position_type GetWholeFrom(void)

return GetPositionMin();

static position_type GetWholeToOpen(void)

return GetPositionMax();

static position_type GetWholeTo(void)

return GetWholeToOpen()-1;

static position_type GetWholeLength(void)

return GetPositionMax();

static TThisType GetWhole(void)

return TThisType(GetWholeFrom(), GetWholeToOpen());

bool IsWholeFrom(void) const

return GetFrom() == GetWholeFrom();

bool IsWholeTo(void) const

return GetToOpen() == GetWholeToOpen();

bool IsWhole(void) const

return IsWholeFrom() && IsWholeTo();

static position_type GetEmptyFrom(void)

return GetPositionMax();

static position_type GetEmptyToOpen(void)

return GetPositionMax();

static position_type GetEmptyTo(void)

return GetEmptyToOpen()-1;

static position_type GetEmptyLength(void)

static TThisType GetEmpty(void)

return TThisType(GetEmptyFrom(), GetEmptyToOpen());

TThisType IntersectionWith(const TThisType& r) const

return TThisType(max(GetFrom(), r.GetFrom()),

min(GetToOpen(), r.GetToOpen()));

TThisType& IntersectWith(const TThisType& r)

m_From = max(GetFrom(), r.GetFrom());

m_ToOpen = min(GetToOpen(), r.GetToOpen());

TThisType operator&(const TThisType& r) const

return IntersectionWith(r);

TThisType& operator&=(const TThisType& r)

return IntersectWith(r);

bool IntersectingWith(const TThisType& r) const

return IntersectionWith(r).NotEmpty();

bool AbuttingWith(const TThisType& r) const

if (Empty() || IsWhole() || r.Empty() || r.IsWhole()) {

return GetToOpen() == r.GetFrom() || GetFrom() == r.GetToOpen();

TThisType& CombineWith(const TThisType& r)

m_From = min(m_From, r.GetFrom());

m_ToOpen = max(m_ToOpen, r.GetToOpen());

TThisType CombinationWith(const TThisType& r) const

return TThisType(min(m_From, r.GetFrom()),

max(m_ToOpen, r.GetToOpen()));

TThisType& operator+=(const TThisType& r)

return CombineWith(r);

TThisType operator+(const TThisType& r) const

return CombinationWith(r);

position_type m_From, m_ToOpen;

template<class Position>

class CRange : public COpenRange<Position>

typedef COpenRange<Position> TParent;

typedef typename TParent::position_type position_type;

typedef CRange<Position> TThisType;

CRange(position_type from, position_type to)

: TParent(from, to+1)

CRange(const TParent& range)

TThisType& operator=(const TParent& range)

static_cast<TParent&>(*this) = range;

typedef CRange<TSeqPos> TSeqRange;

typedef CRange<TSignedSeqPos> TSignedSeqRange;

template<class Position>

CNcbiOstream& operator<<(CNcbiOstream& out, const COpenRange<Position>& range)

return out << range.GetFrom() << ".." << range.GetTo();

Include a standard set of the NCBI C++ Toolkit most basic headers.

static bool IsNegative(Position)

static bool IsNegative(Position pos)

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4