/elec/propeller-clock : revision 88

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

Committer: Tim Marston
Date: 2012-05-18 14:40:04 UTC
Revision ID: tim@ed.am-20120518144004-uuz2zrjmyr78wqd5

updated emacs compile command and readjusted clock shift

files added:
src/TODO

src/common.cc

src/common.h

src/modes

src/modes/digital_clock_mode.cc

src/modes/digital_clock_mode.h

src/modes/info_mode.cc

src/modes/info_mode.h

src/modes/major_mode.cc

src/modes/major_mode.h

src/modes/mode.cc

src/modes/mode.h

src/modes/settings_major_mode.cc

src/modes/settings_major_mode.h

src/modes/switcher_major_mode.cc

src/modes/switcher_major_mode.h

src/nvram.h

src/text.cc

src/text.h

src/text_renderer.cc

src/text_renderer.h

src/util/PString.cpp

src/util/PString.h

test/rtc-test

test/rtc-test/Makefile

test/rtc-test/rtc-ds1307.ino

test/rtc-test/util

test/rtc-test/util/DS1307.cpp

test/rtc-test/util/DS1307.h

files removed:
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/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 renamed:
src/analogue_clock_mode.cc => src/modes/analogue_clock_mode.cc

src/analogue_clock_mode.h => src/modes/analogue_clock_mode.h

src/test_mode.cc => src/modes/test_pattern_mode.cc

src/test_mode.h => src/modes/test_pattern_mode.h

src/propeller-clock.ino => src/propeller-clock.cc

files modified:
.bzrignore

arduino.mk

electronics-information

notes

project/propeller-clock.sch

src/Makefile

src/button.cc

src/button.h

src/config.h

src/time.cc

src/time.h

Show diffs side-by-side

added added

removed removed

src/utility/map

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_MAP

#define __STD_HEADER_MAP

#pragma GCC visibility push(default)

namespace std{

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

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

//Compare the keys of the two items

/* template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT

__base_map<Key, T, Compare, Allocator>::value_compare : public binary_function<

typename map<Key, T, Compare, Allocator>::value_type,

bool>

{

friend class __base_map<Key, T, Compare, Allocator>;

protected:

Compare comp;

value_compare(Compare c) : comp(c) { }

~value_compare() { }

public:

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

return comp(x.first, y.first);

}

};

// value_compare value_comp() const;

/* This is the implementation for the map 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 map

template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT map

: public __single_associative<Key, pair<Key, T>, 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, pair<Key, T>, Compare, Allocator> base;

typedef T mapped_type;

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;

100

101

static const key_type v_t_k(const value_type v){

102

return v.first;

103

}

104

105

// using base::value_compare;

106

107

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

108

: base(comp, al, v_t_k) { }

109

110

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

111

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

112

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

113

114

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

115

~map() { }

116

117

using base::operator=;

118

using base::operator==;

119

using base::operator!=;

120

121

using base::insert;

122

using base::erase;

123

124

using base::begin;

125

using base::end;

126

using base::rbegin;

127

using base::rend;

128

129

using base::empty;

130

using base::size;

131

using base::max_size;

132

133

using base::find;

134

using base::count;

135

using base::lower_bound;

136

using base::upper_bound;

137

using base::equal_range;

138

using base::swap;

139

140

reference operator[](const key_type& k){

141

iterator i = lower_bound(k);

142

if (i == end() || base::c(k, i->first)) {

143

i = insert(make_pair(k, T())).first;

144

}

145

return i->second;

146

}

147

148

protected:

149

using base::backing;

150

};

151

152

153

//Implementation of multimap

154

155

156

template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT multimap

157

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

158

159

{

160

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

161

//Deal with it

162

public:

163

164

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

165

typedef T mapped_type;

166

typedef typename base::key_type key_type;

167

typedef typename base::value_type value_type;

168

typedef typename base::key_compare key_compare;

169

typedef typename base::allocator_type allocator_type;

170

typedef typename base::reference reference;

171

typedef typename base::const_reference const_reference;

172

typedef typename base::iterator iterator;

173

typedef typename base::const_iterator const_iterator;

174

typedef typename base::size_type size_type;

175

typedef typename base::difference_type difference_type;

176

typedef typename base::pointer pointer;

177

typedef typename base::const_pointer const_pointer;

178

typedef typename base::reverse_iterator reverse_iterator;

179

typedef typename base::const_reverse_iterator const_reverse_iterator;

180

181

static const key_type v_t_k(const value_type v){

182

return v.first;

183

}

184

185

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

186

: base(comp, al, v_t_k) { }

187

188

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

189

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

190

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

191

192

193

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

194

~multimap() { }

195

196

using base::operator=;

197

using base::operator==;

198

using base::operator!=;

199

200

using base::insert;

201

using base::erase;

202

203

using base::begin;

204

using base::end;

205

using base::rbegin;

206

using base::rend;

207

208

using base::empty;

209

using base::size;

210

using base::max_size;

211

212

using base::find;

213

using base::count;

214

using base::lower_bound;

215

using base::upper_bound;

216

using base::equal_range;

217

using base::swap;

218

219

protected:

220

221

using base::c;

222

223

};

224

225

226

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

227

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

228

them are supposed to do, and I have time.

229

230

231

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

232

(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);

233

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

234

(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);

235

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

236

(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);

237

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

238

(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);

239

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

240

(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);

241

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

242

(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);

243

244

245

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

246