File: qaregexprange.cpp

package info (click to toggle)
regexplorer 0.1.3-1
  • links: PTS
  • area: main
  • in suites: potato
  • size: 332 kB
  • ctags: 222
  • sloc: cpp: 1,166; perl: 99; makefile: 45; sh: 32
file content (151 lines) | stat: -rw-r--r-- 2,424 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
// 
// $Id: qaregexprange.cpp,v 1.2 1999/07/19 02:36:55 amos Exp $
//
// Implementation of QaRegExpRange class
//
// Jan Borsodi <amos@ez.no>
// Created on: <15-Jul-1999 13:42:57 amos>
//


#include "qaregexprange.hpp"
#include <qstring.h>

/*!
  \class QaRegExpRange qaregexprange.hpp
  \brief Holds a start and end offset for a given regexp match.

  A simple tool class for keeping a start and end offset and for extracting the correct substring from a given string.
  It also makes sure the start offset is smaller than the end offset, they are swapped if needed.

*/

/*!
  Creates a range with start and end equal to -1
*/

QaRegExpRange::QaRegExpRange()
{
    Start = -1;
    End = -1;
}

/*!
  Creates a range with given start end end offset.
*/

QaRegExpRange::QaRegExpRange( int soffs, int eoffs )
{
    if ( eoffs < soffs )
    {
        Start = eoffs;
        End = soffs;
    }
    else
    {
        Start = soffs;
        End = eoffs;
    }
}

/*!
  Destroys the object
*/

QaRegExpRange::~QaRegExpRange()
{
}

/*!
  \return The start offset.
*/

int QaRegExpRange::start() const
{
    return Start;
}

/*!
  \return The end offset.
*/

int QaRegExpRange::end() const
{
    return End;
}

/*!
  \return The length of the offset, 0 means start and end are equal.
*/

int QaRegExpRange::length() const
{
    return End-Start;
}

/*!
  Sets the start offset, if it is larger than the end offset it used as end
  and the previous end is used as start.
*/

void QaRegExpRange::setStart( int s )
{
    if ( s == Start )
        return;
    if ( s > End )
    {
        Start = End;
        End = s;
    }
    else
        Start = s;
}

/*!
  Sets the end offset, if it is smaller than the start offset it used as start
  and the previous start is used as end.
*/

void QaRegExpRange::setEnd( int e )
{
    if ( e == End )
        return;
    if ( e < Start )
    {
        End = Start;
        Start = e;
    }
    else
        End = e;
}

/*!
  \return The substring of the given string.
*/

QString QaRegExpRange::stringRange( const QString &s ) const
{
    return s.mid( start(), length() );
}

/*!
  Moves both start and end offset by i places.
*/

QaRegExpRange &QaRegExpRange::operator +=( int i )
{
    Start += i;
    End += i;
    return *this;
}

/*!
  Moves both start and end offset by i places.
*/

QaRegExpRange &QaRegExpRange::operator -=( int i )
{
    Start -= i;
    End -= i;
    return *this;
}