/elec/propeller-clock : revision 8

To get this branch, use:

bzr branch
http://bzr.ed.am/elec/propeller-clock

« back to all changes in this revision

Viewing changes to src/utility/iterator_base

Committer: edam
Date: 2011-11-04 15:07:26 UTC
Revision ID: edam@waxworlds.org-20111104150726-0evv5cetrckzg9do

cleaned-up info

files added:
propeller-clock.sch

files removed:
.bzrignore

arduino.mk

pcb.psd

project

project/propeller-clock.pro

project/propeller-clock.sch

src/analogue_clock_mode.cc

src/analogue_clock_mode.h

src/button.cc

src/button.h

src/config.h

src/drawer.cc

src/drawer.h

src/major_mode.h

src/minor_mode.cc

src/minor_mode.h

src/mode_switcher.cc

src/mode_switcher.h

src/propeller-clock.ino

src/test_mode.cc

src/test_mode.h

src/time.cc

src/time.h

src/util

src/util/Bounce.cpp

src/util/Bounce.h

src/util/DS1307.cpp

src/util/DS1307.h

src/utility

src/utility/Jamfile

src/utility/Makefile

src/utility/README.md

src/utility/StandardCplusplus.h

src/utility/algorithm

src/utility/algorithm.cpp

src/utility/associative_base

src/utility/associative_base.cpp

src/utility/basic_definitions

src/utility/bitset

src/utility/bitset.cpp

src/utility/cassert

src/utility/cctype

src/utility/cerrno

src/utility/cfloat

src/utility/char_traits

src/utility/char_traits.cpp

src/utility/climits

src/utility/clocale

src/utility/cmath

src/utility/complex

src/utility/complex.cpp

src/utility/csetjmp

src/utility/csignal

src/utility/cstdarg

src/utility/cstddef

src/utility/cstdio

src/utility/cstdlib

src/utility/cstring

src/utility/ctime

src/utility/cwchar

src/utility/cwctype

src/utility/del_op.cpp

src/utility/del_opnt.cpp

src/utility/del_opv.cpp

src/utility/del_opvnt.cpp

src/utility/deque

src/utility/deque.cpp

src/utility/eh_alloc.cpp

src/utility/eh_globals.cpp

src/utility/exception

src/utility/exception.cpp

src/utility/fstream

src/utility/fstream.cpp

src/utility/func_exception

src/utility/func_exception.cpp

src/utility/functional

src/utility/iomanip

src/utility/iomanip.cpp

src/utility/ios

src/utility/ios.cpp

src/utility/iosfwd

src/utility/iostream

src/utility/iostream.cpp

src/utility/istream

src/utility/istream.cpp

src/utility/istream_helpers

src/utility/iterator

src/utility/iterator.cpp

src/utility/iterator_base

src/utility/limits

src/utility/limits.cpp

src/utility/list

src/utility/list.cpp

src/utility/locale

src/utility/locale.cpp

src/utility/map

src/utility/map.cpp

src/utility/memory

src/utility/new

src/utility/new_handler.cpp

src/utility/new_op.cpp

src/utility/new_opnt.cpp

src/utility/new_opv.cpp

src/utility/new_opvnt.cpp

src/utility/numeric

src/utility/numeric.cpp

src/utility/ostream

src/utility/ostream.cpp

src/utility/ostream_helpers

src/utility/queue

src/utility/queue.cpp

src/utility/serstream

src/utility/set

src/utility/set.cpp

src/utility/sstream

src/utility/sstream.cpp

src/utility/stack

src/utility/stack.cpp

src/utility/stdexcept

src/utility/stdexcept.cpp

src/utility/streambuf

src/utility/streambuf.cpp

src/utility/string

src/utility/string.cpp

src/utility/string_iostream

src/utility/support

src/utility/support.cpp

src/utility/system_configuration.h

src/utility/type_traits

src/utility/typeinfo

src/utility/typeinfo.cpp

src/utility/uartbuf

src/utility/unwind-cxx.h

src/utility/utility.cpp

src/utility/utility.h

src/utility/valarray

src/utility/valarray.cpp

src/utility/vector

src/utility/vector.cpp

test

test/fan-test

test/fan-test/Makefile

test/fan-test/fan-test.ino

test/led-test

test/led-test/Makefile

test/led-test/led-test.ino

test/phantom-button-presses

test/phantom-button-presses/Makefile

test/phantom-button-presses/main.ino

files renamed:
src/Makefile@ => Makefile

notes => Notes

files modified:
electronics-information

Show diffs side-by-side

added added

removed removed

src/utility/iterator_base

This file is part of the uClibc++ Library.

This library 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 2.1 of the License, or (at your option) any later version.

This library 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 library; if not, write to the Free Software

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

#include <basic_definitions>

#ifndef __STD_HEADER_ITERATOR_BASE

#define __STD_HEADER_ITERATOR_BASE 1

#pragma GCC visibility push(default)

namespace std{

template<class Iterator> struct iterator_traits;

template<class T> struct iterator_traits<T*>;

template<class Category, class T, class Distance = ptrdiff_t, class Pointer = T*, class Reference = T&> struct iterator;

struct _UCXXEXPORT input_iterator_tag {};

struct _UCXXEXPORT output_iterator_tag {};

struct _UCXXEXPORT forward_iterator_tag: public input_iterator_tag {};

struct _UCXXEXPORT bidirectional_iterator_tag: public forward_iterator_tag {};

struct _UCXXEXPORT random_access_iterator_tag: public bidirectional_iterator_tag {};

template <class InputIterator, class Distance> _UCXXEXPORT void advance(InputIterator& i, Distance n){

while(n > 0){

--n;

++i;

}

template <class InputIterator> _UCXXEXPORT typename iterator_traits<InputIterator>::difference_type

distance(InputIterator first, InputIterator last)

{

typename iterator_traits<InputIterator>::difference_type d = 0;

while(first++ !=last){

d++;

}

return d;

}

// subclause _lib.predef.iterators_, predefined iterators:

template <class Iterator> class reverse_iterator;

template <class Iterator> bool operator==(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

template <class Iterator> bool operator<(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

template <class Iterator> bool operator!=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

template <class Iterator> bool operator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

template <class Iterator> bool operator>=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

template <class Iterator> bool operator<=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

template <class Iterator> typename reverse_iterator<Iterator>::difference_type

operator-( const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

template <class Iterator> reverse_iterator<Iterator>

operator+( typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& x);

template <class Container> class back_insert_iterator;

template <class Container> back_insert_iterator<Container> back_inserter(Container& x);

template <class Container> class front_insert_iterator;

template <class Container> front_insert_iterator<Container> front_inserter(Container& x);

template <class Container> class insert_iterator;

template <class Container, class Iterator>

insert_iterator<Container> inserter(Container& x, Iterator i);

//Actual Template definitions

template<class Iterator> struct _UCXXEXPORT iterator_traits {

typedef typename Iterator::difference_type difference_type;

typedef typename Iterator::value_type value_type;

typedef typename Iterator::pointer pointer;

typedef typename Iterator::reference reference;

typedef typename Iterator::iterator_category iterator_category;

};

//Pointer specialization - required by standard

template<class T> struct _UCXXEXPORT iterator_traits<T*> {

typedef ptrdiff_t difference_type;

typedef T value_type;

typedef T* pointer;

typedef T& reference;

typedef random_access_iterator_tag iterator_category;

};

//Specialization recomended by standard

/* template<class T> struct _UCXXEXPORT iterator_traits<T __far*> {

typedef long difference_type;

typedef T value_type;

typedef T __far* pointer;

100

typedef T __far& reference;

101

typedef random_access_iterator_tag iterator_category;

102

};*/

103

104

/* template <class BidirectionalIterator> _UCXXEXPORT void

105

reverse(BidirectionalIterator first, BidirectionalIterator last)

106

{

107

typename iterator_traits<BidirectionalIterator>::difference_type n = distance(first, last);

108

--n;

109

while(n > 0){

110

typename iterator_traits<BidirectionalIterator>::value_type tmp = *first;

111

*first++ = * --last;

112

*last = tmp;

113

n -= 2;

114

}

115

};*/

116

117

118

template <class Category, class T, class Distance, class Pointer, class Reference>

119

struct _UCXXEXPORT iterator

120

{

121

typedef T value_type;

122

typedef Distance difference_type;

123

typedef Pointer pointer;

124

typedef Reference reference;

125

typedef Category iterator_category;

126

};

127

128

129

template <class Iterator> class _UCXXEXPORT reverse_iterator

130

: public iterator<typename iterator_traits<Iterator>::iterator_category,

131

typename iterator_traits<Iterator>::value_type, typename iterator_traits<Iterator>::difference_type,

132

typename iterator_traits<Iterator>::pointer, typename iterator_traits<Iterator>::reference>

133

{

134

protected:

135

Iterator current;

136

friend bool operator== <Iterator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

137

friend bool operator< <Iterator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);

138

139

public:

140

typedef Iterator iterator_type;

141

142

reverse_iterator() : current(){};

143

explicit reverse_iterator(Iterator x) : current(x) { }

144

template<class U> reverse_iterator(const reverse_iterator<U> &x) : current(x.base()){}

145

146

Iterator base() const { return current; } // explicit

147

148

typename iterator_traits<Iterator>::reference operator*() const { Iterator tmp = current; return *--tmp; }

149

typename iterator_traits<Iterator>::pointer operator->() const { return &(operator*()); }

150

typename iterator_traits<Iterator>::reference operator[](typename iterator_traits<Iterator>::difference_type n) const{

151

return current[-n-1];

152

}

153

154

reverse_iterator& operator++(){ --current; return *this; }

155

reverse_iterator operator++(int) {reverse_iterator tmp = *this; --current; return tmp; }

156

reverse_iterator& operator--() { ++ current; return *this; }

157

reverse_iterator operator--(int) {reverse_iterator tmp = *this; ++current; return tmp; }

158

159

reverse_iterator operator+ (typename iterator_traits<Iterator>::difference_type n) const{

160

reverse_iterator retval( *this );

161

retval+=n;

162

return retval;

163

}

164

reverse_iterator& operator+=(typename iterator_traits<Iterator>::difference_type n){

165

current -= n;

166

return *this;

167

}

168

reverse_iterator operator- (typename iterator_traits<Iterator>::difference_type n) const{

169

reverse_iterator retval( *this );

170

retval-=n;

171

return retval;

172

}

173

reverse_iterator& operator-=(typename iterator_traits<Iterator>::difference_type n){

174

current += n;

175

return *this;

176

}

177

};

178

179

180

template <class Iterator> _UCXXEXPORT bool

181

operator==(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)

182

{

183

return x.base() == y.base();

184

}

185

template <class Iterator> _UCXXEXPORT bool

186

operator<(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)

187

{

188

return x.base() < y.base();

189

}

190

template <class Iterator> _UCXXEXPORT bool

191

operator!=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)

192

{

193

return x.base() != y.base();

194

}

195

template <class Iterator> _UCXXEXPORT bool

196

operator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)

197

{

198

return x.base() > y.base();

199

}

200

template <class Iterator> _UCXXEXPORT bool

201

operator>=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)

202

{

203

return x.base() >= y.base();

204

}

205

template <class Iterator> _UCXXEXPORT bool

206

operator<=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)

207

{

208

return x.base() <= y.base();

209

}

210

template <class Iterator> _UCXXEXPORT typename reverse_iterator<Iterator>::difference_type

211

operator-( const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)

212

{

213

return y.base() - x.base();

214

}

215

template <class Iterator> _UCXXEXPORT reverse_iterator<Iterator>

216

operator+(typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& x)

217

{

218

return reverse_iterator<Iterator> (x.base() - n);

219

}

220

221

template <class Container> class _UCXXEXPORT back_insert_iterator :

222

public iterator<output_iterator_tag,void,void,void,void>

223

{

224

protected:

225

Container& container;

226

public:

227

typedef Container container_type;

228

explicit back_insert_iterator(Container& x):container(x) {};

229

back_insert_iterator<Container>& operator=(const typename Container::value_type& value){

230

container.push_back(value);

231

return *this;

232

}

233

back_insert_iterator<Container>& operator*(){

234

return *this;

235

}

236

back_insert_iterator<Container>& operator++(){

237

return *this;

238

}

239

back_insert_iterator<Container> operator++(int){

240

return *this;

241

}

242

};

243

244

template <class Container> _UCXXEXPORT back_insert_iterator<Container>

245

back_inserter(Container& x)

246

{

247

return back_insert_iterator<Container>(x);

248

}

249

250

template <class Container> class _UCXXEXPORT front_insert_iterator

251

: public iterator<output_iterator_tag,void,void,void,void>

252

{

253

protected:

254

Container& container;

255

public:

256

typedef Container container_type;

257

explicit front_insert_iterator(Container& x): container(x) {}

258

front_insert_iterator<Container>& operator=(const typename Container::value_type& value){

259

container.push_front(value);

260

return *this;

261

}

262

263

front_insert_iterator<Container>& operator*() { return *this; }

264

front_insert_iterator<Container>& operator++() { return *this; }

265

front_insert_iterator<Container> operator++(int) { return *this; }

266

};

267

268

template <class Container> _UCXXEXPORT front_insert_iterator<Container>

269

front_inserter(Container& x)

270

{

271

return front_insert_iterator<Container>(x);

272

}

273

274

template <class Container> class _UCXXEXPORT insert_iterator

275

: public iterator<output_iterator_tag,void,void,void,void>

276

{

277

protected:

278

Container& container;

279

typename Container::iterator iter;

280

public:

281

typedef Container container_type;

282

insert_iterator(Container& x, typename Container::iterator i) : container(x), iter(i) {}

283

insert_iterator<Container>& operator=(const typename Container::value_type& value){

284

iter = container.insert(iter, value);

285

++iter;

286

return *this;

287

}

288

insert_iterator<Container>& operator*() { return *this; }

289

insert_iterator<Container>& operator++() { return *this; }

290

insert_iterator<Container> operator++(int) { return *this; }

291

};

292

293

template <class Container, class Iterator> _UCXXEXPORT insert_iterator<Container>

294

inserter(Container& x, Iterator i)

295

{

296

return insert_iterator<Container>(x,typename Container::iterator(i));

297

}

298

299

}

300

301

#pragma GCC visibility pop

302

303

#endif

304

305

Older »