/elec/propeller-clock : revision 54

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/set

Committer: edam
Date: 2012-02-23 20:18:22 UTC
Revision ID: edam@waxworlds.org-20120223201822-dno5n4fwvd35izq9

changed 12-tick to a double tick, added CLOCK_SHIFT to align face and fixed hour-hand

files removed:
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/test_mode.cc

src/test_mode.h

src/time.cc

src/time.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

files modified:
arduino.mk

src/propeller-clock.ino

Show diffs side-by-side

added added

removed removed

src/utility/set

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<memory>

#include<utility.h>

#include<iterator>

#include <deque>

#include<functional>

#include <associative_base>

#ifndef __STD_HEADER_SET

#define __STD_HEADER_SET

#pragma GCC visibility push(default)

namespace std{

template<class Key, class Compare = less<Key>, class Allocator = allocator<Key> > class set;

template<class Key, class Compare = less<Key>, class Allocator = allocator<Key> > class multiset;

/* This is the implementation for the set container. As noted above, it deviates

* from ISO spec by deriving from a base class in order to reduce code redundancy.

* More code could be reduced by convirting to virtual functions (thus allowing

* much of the erase and insert code to be duplicated), but that would deviate from

* the specifications too much to be worth the risk.

//Implementation of set

template<class Key, class Compare, class Allocator> class _UCXXEXPORT set

: public __single_associative<Key, Key, Compare, Allocator>

{

//Default value of allocator does not meet C++ standard specs, but it works for this library

//Deal with it

public:

typedef __single_associative<Key, Key, Compare, Allocator> base;

typedef typename base::key_type key_type;

typedef typename base::value_type value_type;

typedef typename base::key_compare key_compare;

typedef typename base::allocator_type allocator_type;

typedef typename base::reference reference;

typedef typename base::const_reference const_reference;

typedef typename base::iterator iterator;

typedef typename base::const_iterator const_iterator;

typedef typename base::size_type size_type;

typedef typename base::difference_type difference_type;

typedef typename base::pointer pointer;

typedef typename base::const_pointer const_pointer;

typedef typename base::reverse_iterator reverse_iterator;

typedef typename base::const_reverse_iterator const_reverse_iterator;

// using base::value_compare;

static const key_type v_t_k(const value_type v){

return v;

}

explicit set(const Compare& comp = Compare(), const Allocator& al = Allocator())

: base(comp, al, v_t_k) { }

template <class InputIterator> set(InputIterator first, InputIterator last,

const Compare& comp = Compare(), const Allocator& al = Allocator())

: base(first, last, comp, al, v_t_k) { }

set(const set<Key, Compare,Allocator>& x) : base(x) { }

~set() { }

using base::operator=;

using base::operator==;

using base::operator!=;

using base::insert;

using base::erase;

using base::begin;

using base::end;

using base::rbegin;

100

using base::rend;

101

102

using base::empty;

103

using base::size;

104

using base::max_size;

105

106

107

using base::find;

108

using base::count;

109

using base::lower_bound;

110

using base::upper_bound;

111

using base::equal_range;

112

113

protected:

114

115

};

116

117

118

//Implementation of multiset

119

120

121

template<class Key, class Compare, class Allocator> class _UCXXEXPORT multiset

122

: public __multi_associative<Key, Key, Compare, Allocator>

123

{

124

//Default value of allocator does not meet C++ standard specs, but it works for this library

125

//Deal with it

126

public:

127

128

typedef __multi_associative<Key, Key, Compare, Allocator> base;

129

typedef typename base::key_type key_type;

130

typedef typename base::value_type value_type;

131

typedef typename base::key_compare key_compare;

132

typedef typename base::allocator_type allocator_type;

133

typedef typename base::reference reference;

134

typedef typename base::const_reference const_reference;

135

typedef typename base::iterator iterator;

136

typedef typename base::const_iterator const_iterator;

137

typedef typename base::size_type size_type;

138

typedef typename base::difference_type difference_type;

139

typedef typename base::pointer pointer;

140

typedef typename base::const_pointer const_pointer;

141

typedef typename base::reverse_iterator reverse_iterator;

142

typedef typename base::const_reverse_iterator const_reverse_iterator;

143

144

static const key_type v_t_k(const value_type v){

145

return v;

146

}

147

148

explicit multiset(const Compare& comp = Compare(), const Allocator& al = Allocator())

149

: base(comp, al, v_t_k) { }

150

151

template <class InputIterator> multiset(InputIterator first, InputIterator last,

152

const Compare& comp = Compare(), const Allocator& al = Allocator())

153

: base(first, last, comp, al, v_t_k) { }

154

155

156

multiset(const multiset<Key, Compare, Allocator>& x) : base(x) { }

157

~multiset() { }

158

159

using base::operator=;

160

using base::operator==;

161

using base::operator!=;

162

163

using base::insert;

164

using base::erase;

165

166

using base::begin;

167

using base::end;

168

using base::rbegin;

169

using base::rend;

170

171

using base::empty;

172

using base::size;

173

using base::max_size;

174

175

using base::find;

176

using base::count;

177

using base::lower_bound;

178

using base::upper_bound;

179

using base::equal_range;

180

181

182

protected:

183

184

};

185

186

187

/* Non-member functions. These are at the end because they are not associated with any

188

particular class. These will be implemented as I figure out exactly what all of

189

them are supposed to do, and I have time.

190

191

192

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<

193

(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)

194

{

195

typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();

196

typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();

197

typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();

198

typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();

199

200

while(first1 != last1 && first2 != last2){

201

if( *first1 < *first2 ){

202

return true;

203

}

204

if( *first2 < *first1 ){

205

return false;

206

}

207

++first1;

208

++first2;

209

}

210

return first1==last1 && first2 != last2;

211

}

212

213

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>

214

(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)

215

{

216

typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();

217

typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();

218

typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();

219

typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();

220

221

while(first1 != last1 && first2 != last2){

222

if( *first1 > *first2 ){

223

return true;

224

}

225

if( *first2 > *first1 ){

226

return false;

227

}

228

++first1;

229

++first2;

230

}

231

return first1!=last1 && first2 == last2;

232

}

233

234

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>=

235

(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)

236

{

237

typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();

238

typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();

239

typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();

240

typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();

241

242

while(first1 != last1 && first2 != last2){

243

if( *first1 > *first2 ){

244

return true;

245

}

246

if( *first2 > *first1 ){

247

return false;

248

}

249

++first1;

250

++first2;

251

}

252

return first1!=last1;

253

}

254

255

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<=

256

(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)

257

{

258

typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();

259

typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();

260

typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();

261

typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();

262

263

while(first1 != last1 && first2 != last2){

264

if( *first1 < *first2 ){

265

return true;

266

}

267

if( *first2 < *first1 ){

268

return false;

269

}

270

++first1;

271

++first2;

272

}

273

return first2!=last2;

274

}

275

template <class Key, class Compare, class Allocator> _UCXXEXPORT void swap

276

(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y)

277

{

278

x.swap(y);

279

}

280

281

282

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator==

283

(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)

284

{

285

if(x.data == y.data){

286

return true;

287

}

288

return false;

289

}

290

291

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<

292

(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)

293

{

294

typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();

295

typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();

296

typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();

297

typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();

298

299

while(first1 != last1 && first2 != last2){

300

if( *first1 < *first2 ){

301

return true;

302

}

303

if( *first2 < *first1 ){

304

return false;

305

}

306

++first1;

307

++first2;

308

}

309

return first1==last1 && first2 != last2;

310

}

311

312

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator!=

313

(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)

314

{

315

typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();

316

typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();

317

typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();

318

typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();

319

320

while(first1 != last1 && first2 != last2){

321

if( *first1 != *first2 ){

322

return true;

323

}

324

++first1;

325

++first2;

326

}

327

return first1!=last1 || first2 != last2;

328

}

329

330

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>

331

(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)

332

{

333

typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();

334

typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();

335

typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();

336

typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();

337

338

while(first1 != last1 && first2 != last2){

339

if( *first1 > *first2 ){

340

return true;

341

}

342

if( *first2 > *first1 ){

343

return false;

344

}

345

++first1;

346

++first2;

347

}

348

return first1!=last1 && first2 == last2;

349

}

350

351

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>=

352

(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)

353

{

354

typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();

355

typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();

356

typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();

357

typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();

358

359

while(first1 != last1 && first2 != last2){

360

if( *first1 > *first2 ){

361

return true;

362

}

363

if( *first2 > *first1 ){

364

return false;

365

}

366

++first1;

367

++first2;

368

}

369

return first1!=last1;

370

}

371

372

template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<=

373

(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)

374

{

375

typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();

376

typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();

377

typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();

378

typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();

379

380

while(first1 != last1 && first2 != last2){

381

if( *first1 < *first2 ){

382

return true;

383

}

384

if( *first2 < *first1 ){

385

return false;

386

}

387

++first1;

388

++first2;

389

}

390

return first2!=last2;

391

}

392

393

template <class Key, class Compare, class Allocator> _UCXXEXPORT void swap

394

(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y)

395

{

396

x.swap(y);

397

}

398

399

400

401

}

402

403

#pragma GCC visibility pop

404

405

#endif

406

407

Older »