/elec/propeller-clock : revision 50

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

Committer: Dan
Date: 2012-02-17 01:24:40 UTC
Revision ID: dan@waxworlds.org-20120217012440-y0kwpr4l2i3y1zuw

updated arduino.mk

files added:
src/util/Bounce.cpp

src/util/Bounce.h

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

project/propeller-clock.sch

src/propeller-clock.ino

test/phantom-button-presses/main.ino

Show diffs side-by-side

added added

removed removed

src/utility/functional

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

#ifndef __STD_HEADER_FUNCTIONAL

#define __STD_HEADER_FUNCTIONAL 1

#include <basic_definitions>

#pragma GCC visibility push(default)

namespace std{

template <class Arg, class Result> struct unary_function;

template <class Arg1, class Arg2, class Result> struct binary_function;

template <class T> struct plus;

template <class T> struct minus;

template <class T> struct multiplies;

template <class T> struct divides;

template <class T> struct modulus;

template <class T> struct negate;

template <class T> struct equal_to;

template <class T> struct not_equal_to;

template <class T> struct greater;

template <class T> struct less;

template <class T> struct greater_equal;

template <class T> struct less_equal;

template <class T> struct logical_and;

template <class T> struct logical_or;

template <class T> struct logical_not;

template <class Predicate> struct unary_negate;

template <class Predicate> unary_negate<Predicate> not1(const Predicate&);

template <class Predicate> struct binary_negate;

template <class Predicate> binary_negate<Predicate> not2(const Predicate&);

template <class Operation> class binder1st;

template <class Operation, class T> binder1st<Operation> bind1st(const Operation&, const T&);

template <class Operation> class binder2nd;

template <class Operation, class T> binder2nd<Operation> bind2nd(const Operation&, const T&);

template <class Arg, class Result> class pointer_to_unary_function;

template <class Arg, class Result> pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg));

template <class Arg1, class Arg2, class Result> class pointer_to_binary_function;

template <class Arg1, class Arg2, class Result>

pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*)(Arg1,Arg2));

template<class S, class T> class mem_fun_t;

template<class S, class T, class A> class mem_fun1_t;

template<class S, class T> class const_mem_fun_t;

template<class S, class T, class A> class const_mem_fun1_t;

template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)());

template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));

template<class S, class T> class mem_fun_ref_t;

template<class S, class T, class A> class mem_fun1_ref_t;

template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());

template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun1_ref(S (T::*f)(A));

//Implementation

template <class Arg, class Result> struct _UCXXEXPORT unary_function{

typedef Arg argument_type;

typedef Result result_type;

};

template <class Arg1, class Arg2, class Result> struct _UCXXEXPORT binary_function{

typedef Arg1 first_argument_type;

typedef Arg2 second_argument_type;

typedef Result result_type;

};

template <class T> struct _UCXXEXPORT plus : binary_function<T,T,T>{

T operator()(const T& x, const T& y) const{

return x + y;

}

};

template <class T> struct _UCXXEXPORT minus : binary_function<T,T,T>{

T operator()(const T& x, const T& y) const{

return x - y;

100

}

101

};

102

103

template <class T> struct _UCXXEXPORT multiplies : binary_function<T,T,T>{

104

T operator()(const T& x, const T& y) const{

105

return x * y;

106

}

107

};

108

109

template <class T> struct _UCXXEXPORT divides : binary_function<T,T,T>{

110

T operator()(const T& x, const T& y) const{

111

return x / y;

112

}

113

};

114

115

template <class T> struct _UCXXEXPORT modulus : binary_function<T,T,T>{

116

T operator()(const T& x, const T& y) const{

117

return x % y;

118

}

119

};

120

121

template <class T> struct _UCXXEXPORT negate : unary_function<T,T>{

122

T operator()(const T& x) const{

123

return -x;

124

}

125

};

126

127

template <class T> struct _UCXXEXPORT equal_to : binary_function<T,T,bool>{

128

bool operator()(const T& x, const T& y) const{

129

return (x == y);

130

}

131

};

132

133

template <class T> struct _UCXXEXPORT not_equal_to : binary_function<T,T,bool>{

134

bool operator()(const T& x, const T& y) const{

135

return (x != y);

136

}

137

};

138

139

template <class T> struct _UCXXEXPORT greater : binary_function<T,T,bool>{

140

bool operator()(const T& x, const T& y) const{

141

return (x > y);

142

}

143

};

144

145

template <class T> struct _UCXXEXPORT less : binary_function<T,T,bool>{

146

bool operator()(const T& x, const T& y) const{

147

return (x < y);

148

}

149

};

150

151

template <class T> struct _UCXXEXPORT greater_equal : binary_function<T,T,bool>{

152

bool operator()(const T& x, const T& y) const{

153

return (x >= y);

154

}

155

};

156

157

template <class T> struct _UCXXEXPORT less_equal : binary_function<T,T,bool>{

158

bool operator()(const T& x, const T& y) const{

159

return (x <= y);

160

}

161

};

162

163

template <class T> struct _UCXXEXPORT logical_and : binary_function<T,T,bool> {

164

bool operator()(const T& x, const T& y) const{

165

return (x && y);

166

}

167

};

168

169

template <class T> struct _UCXXEXPORT logical_or : binary_function<T,T,bool> {

170

bool operator()(const T& x, const T& y) const{

171

return (x || y);

172

}

173

};

174

175

template <class T> struct _UCXXEXPORT logical_not : unary_function<T,bool> {

176

bool operator()(const T& x) const{

177

return !x;

178

}

179

};

180

181

template <class Predicate> class _UCXXEXPORT unary_negate

182

: public unary_function<typename Predicate::argument_type,bool>

183

{

184

public:

185

explicit unary_negate(const Predicate& pred) : p(pred) { }

186

bool operator()(const typename Predicate::argument_type& x) const{

187

return !p(x);

188

}

189

private:

190

Predicate p;

191

};

192

193

194

template <class Predicate> _UCXXEXPORT unary_negate<Predicate> not1(const Predicate& pred){

195

return unary_negate<Predicate>(pred);

196

}

197

198

199

template <class Predicate> class _UCXXEXPORT binary_negate : public

200

binary_function<typename Predicate::first_argument_type,

201

typename Predicate::second_argument_type, bool>

202

{

203

public:

204

explicit binary_negate(const Predicate& pred) : p(pred) { }

205

bool operator()(const typename Predicate::first_argument_type& x,

206

const typename Predicate::second_argument_type& y) const

207

{

208

return !p(x, y);

209

}

210

private:

211

Predicate p;

212

};

213

214

215

template <class Predicate> _UCXXEXPORT binary_negate<Predicate> not2(const Predicate& pred){

216

return binary_negate<Predicate>(pred);

217

}

218

219

220

template <class Operation> class _UCXXEXPORT binder1st

221

: public unary_function<typename Operation::second_argument_type,

222

typename Operation::result_type>

223

{

224

protected:

225

Operation op;

226

typename Operation::first_argument_type value;

227

public:

228

binder1st(const Operation& x, const typename Operation::first_argument_type& y) : op(x), value(y){ }

229

typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const{

230

return op(value,x);

231

}

232

};

233

234

235

template <class Operation, class T> _UCXXEXPORT binder1st<Operation> bind1st(const Operation& op, const T& x){

236

return binder1st<Operation>(op, typename Operation::first_argument_type(x));

237

}

238

239

240

template <class Operation> class _UCXXEXPORT binder2nd

241

: public unary_function<typename Operation::first_argument_type,

242

typename Operation::result_type>

243

{

244

protected:

245

Operation op;

246

typename Operation::second_argument_type value;

247

public:

248

binder2nd(const Operation& x, const typename Operation::second_argument_type& y) : op(x), value(y) { }

249

typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const{

250

return op(x,value);

251

}

252

};

253

254

255

template <class Operation, class T> _UCXXEXPORT

256

binder2nd<Operation> bind2nd(const Operation& op, const T& x)

257

{

258

return binder2nd<Operation>(op, typename Operation::second_argument_type(x));

259

}

260

261

262

template <class Arg, class Result> class _UCXXEXPORT

263

pointer_to_unary_function : public unary_function<Arg, Result>

264

{

265

protected:

266

Result (*func)(Arg);

267

public:

268

explicit pointer_to_unary_function(Result (*f)(Arg)) : func(f) { }

269

Result operator()(Arg x) const{

270

return func(x);

271

}

272

};

273

274

275

template <class Arg, class Result> _UCXXEXPORT pointer_to_unary_function<Arg, Result> ptr_fun(Result (*f)(Arg)){

276

return pointer_to_unary_function<Arg, Result>(f);

277

}

278

279

280

template <class Arg1, class Arg2, class Result> class _UCXXEXPORT

281

pointer_to_binary_function : public binary_function<Arg1,Arg2,Result>

282

{

283

protected:

284

Result (*func)(Arg1, Arg2);

285

public:

286

explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)) : func(f) { }

287

Result operator()(Arg1 x, Arg2 y) const{

288

return func(x, y);

289

}

290

};

291

292

template <class Arg1, class Arg2, class Result> _UCXXEXPORT

293

pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1, Arg2))

294

{

295

return pointer_to_binary_function<Arg1,Arg2,Result>(f);

296

}

297

298

299

template <class S, class T> class _UCXXEXPORT mem_fun_t

300

: public unary_function<T*, S>

301

{

302

public:

303

explicit mem_fun_t(S (T::*p)()) : m(p) { }

304

S operator()(T* p) const { return (p->*m)(); }

305

private:

306

S (T::*m)();

307

};

308

309

310

template <class S, class T, class A> class _UCXXEXPORT mem_fun1_t

311

: public binary_function<T*, A, S>

312

{

313

public:

314

explicit mem_fun1_t(S (T::*p)(A)) : m(p) { }

315

S operator()(T* p, A x) const { return (p->*m)(x); }

316

private:

317

S (T::*m)(A);

318

};

319

320

321

template <class S, class T> class _UCXXEXPORT const_mem_fun_t

322

: public unary_function<const T*, S>

323

{

324

public:

325

explicit const_mem_fun_t(S (T::*p)() const) : m(p) { }

326

S operator()(const T* p) const { return (p->*m)(); }

327

private:

328

S (T::*m)() const;

329

};

330

331

332

template <class S, class T, class A> class _UCXXEXPORT const_mem_fun1_t

333

: public binary_function<T*, A, S>

334

{

335

public:

336

explicit const_mem_fun1_t(S (T::*p)(A) const) : m(p) { }

337

S operator()(const T* p, A x) const { return (p->*m)(x); }

338

private:

339

S (T::*m)(A) const;

340

};

341

342

343

template<class S, class T> _UCXXEXPORT mem_fun_t<S,T> mem_fun(S (T::*f)()){

344

return mem_fun_t<S, T>(f);

345

}

346

347

template<class S, class T> _UCXXEXPORT const_mem_fun_t<S,T> mem_fun(S (T::*f)() const){

348

return const_mem_fun_t<S, T>(f);

349

}

350

351

template<class S, class T, class A> _UCXXEXPORT mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)){

352

return mem_fun1_t<S, T, A>(f);

353

}

354

355

template<class S, class T, class A> _UCXXEXPORT const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const){

356

return const_mem_fun1_t<S, T, A>(f);

357

}

358

359

template <class S, class T> class _UCXXEXPORT mem_fun_ref_t

360

: public unary_function<T, S>

361

{

362

public:

363

explicit mem_fun_ref_t(S (T::*p)()) : mf(p) { }

364

S operator()(T& p) { return (p.*mf)(); }

365

private:

366

S (T::*mf)();

367

};

368

369

template <class S, class T, class A> class _UCXXEXPORT mem_fun1_ref_t

370

: public binary_function<T, A, S>

371

{

372

public:

373

explicit mem_fun1_ref_t(S (T::*p)(A)) : mf(p) { }

374

S operator()(T& p, A x) { return (p.*mf)(x); }

375

private:

376

S (T::*mf)(A);

377

};

378

379

template<class S, class T> _UCXXEXPORT mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()){

380

return mem_fun_ref_t<S,T>(f);

381

}

382

383

template<class S, class T, class A> _UCXXEXPORT mem_fun1_ref_t<S,T,A> mem_fun1_ref(S (T::*f)(A)){

384

return mem_fun1_ref_t<S,T,A>(f);

385

}

386

387

388

}

389

390

391

//These are SGI extensions which are checked for by some conformance checks. They

392

// are *NOT* part of the C++ standard, however

393

394

template <class Op1, class Op2> class _UCXXEXPORT unary_compose :

395

public std::unary_function<typename Op2::argument_type,

396

typename Op1::result_type>

397

{

398

protected:

399

Op1 mf1;

400

Op2 mf2;

401

public:

402

unary_compose(const Op1& x, const Op2& y) : mf1(x), mf2(y) { }

403

typename Op1::result_type operator()(const typename Op2::argument_type& x) const {

404

return mf1(mf2(x));

405

}

406

};

407

408

template <class Op1, class Op2> _UCXXEXPORT

409

inline unary_compose<Op1, Op2>

410

compose1(const Op1& fn1, const Op2& fn2){

411

return unary_compose<Op1, Op2>(fn1, fn2);

412

}

413

414

template <class Op1, class Op2, class Op3> class _UCXXEXPORT binary_compose :

415

public std::unary_function<typename Op2::argument_type, typename Op1::result_type>

416

{

417

protected:

418

Op1 mf1;

419

Op2 mf2;

420

Op3 mf3;

421

public:

422

binary_compose(const Op1 & x, const Op2 & y, const Op3 & z)

423

: mf1(x), mf2(y), mf3(z){ }

424

typename Op1::result_type operator()(const typename Op2::argument_type & x) const {

425

return mf1(mf2(x), mf3(x));

426

}

427

};

428

429

template <class Op1, class Op2, class Op3> inline _UCXXEXPORT binary_compose<Op1, Op2, Op3>

430

compose2(const Op1 & fn1, const Op2 & fn2, const Op3 & fn3){

431

return binary_compose<Op1, Op2, Op3>(fn1, fn2, fn3);

432

}

433

434

#pragma GCC visibility pop

435

436

#endif

437

438

439

Older »