diff --git a/Makefile.am b/Makefile.am index 5d3d5379..2a6c3ef8 100644 --- a/Makefile.am +++ b/Makefile.am @@ -7,5 +7,6 @@ EXTRA_DIST= \ rak/algorithm.h \ rak/error_number.h \ rak/functional.h \ + rak/unordered_vector.h \ scripts/checks.m4 \ scripts/common.m4 diff --git a/rak/functional.h b/rak/functional.h index c70321fc..a0074b05 100644 --- a/rak/functional.h +++ b/rak/functional.h @@ -51,20 +51,35 @@ struct reference_fix { typedef Type type; }; +template +struct value_t { + value_t(Type v) : m_v(v) {} + + Type operator () () const { return m_v; } + + Type m_v; +}; + +template +inline value_t +value(Type v) { + return value_t(v); +} + template struct accumulate_t { - accumulate_t(Type& t, Ftor f) : m_t(t), m_f(f) {} + accumulate_t(Type t, Ftor f) : result(t), m_f(f) {} template - void operator () (Arg& a) { m_t += m_f(a); } + void operator () (const Arg& a) { result += m_f(a); } - Type& m_t; + Type result; Ftor m_f; }; template inline accumulate_t -accumulate(Type& t, Ftor f) { +accumulate(Type t, Ftor f) { return accumulate_t(t, f); } @@ -225,6 +240,10 @@ struct mem_ptr_ref_t : public std::unary_function { return c.*m_member; } + const Member& operator () (const Class& c) { + return c.*m_member; + } + Member Class::*m_member; }; diff --git a/rak/unordered_vector.h b/rak/unordered_vector.h new file mode 100644 index 00000000..b84facc2 --- /dev/null +++ b/rak/unordered_vector.h @@ -0,0 +1,105 @@ +// rak - Rakshasa's toolbox +// Copyright (C) 2005, Jari Sundell +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program 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 General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// In addition, as a special exception, the copyright holders give +// permission to link the code of portions of this program with the +// OpenSSL library under certain conditions as described in each +// individual source file, and distribute linked combinations +// including the two. +// +// You must obey the GNU General Public License in all respects for +// all of the code used other than OpenSSL. If you modify file(s) +// with this exception, you may extend this exception to your version +// of the file(s), but you are not obligated to do so. If you do not +// wish to do so, delete this exception statement from your version. +// If you delete this exception statement from all source files in the +// program, then also delete it here. +// +// Contact: Jari Sundell +// +// Skomakerveien 33 +// 3185 Skoppum, NORWAY + +#ifndef RAK_UNORDERED_VECTOR_H +#define RAK_UNORDERED_VECTOR_H + +#include + +namespace rak { + +template +class unordered_vector : private std::vector<_Tp> { +public: + typedef std::vector<_Tp> Base; + + typedef typename Base::value_type value_type; + typedef typename Base::pointer pointer; + typedef typename Base::const_pointer const_pointer; + typedef typename Base::reference reference; + typedef typename Base::const_reference const_reference; + typedef typename Base::size_type size_type; + typedef typename Base::difference_type difference_type; + typedef typename Base::allocator_type allocator_type; + + typedef typename Base::iterator iterator; + typedef typename Base::reverse_iterator reverse_iterator; + typedef typename Base::const_iterator const_iterator; + typedef typename Base::const_reverse_iterator const_reverse_iterator; + + using Base::clear; + using Base::empty; + using Base::size; + using Base::reserve; + + using Base::front; + using Base::back; + using Base::begin; + using Base::end; + using Base::rbegin; + using Base::rend; + + using Base::push_back; + using Base::pop_back; + + iterator insert(iterator position, const value_type& x); + iterator erase(iterator position); + +private: +}; + +template +typename unordered_vector<_Tp>::iterator +unordered_vector<_Tp>::insert(iterator position, const value_type& x) { + Base::push_back(x); + + return --end(); +} + +template +typename unordered_vector<_Tp>::iterator +unordered_vector<_Tp>::erase(iterator position) { + // We don't need to check if position == end - 1 since we then copy + // to the position we pop later. + *position = Base::back(); + Base::pop_back(); + + return position; +} + +} + +#endif diff --git a/src/display/manager.cc b/src/display/manager.cc index c1602380..81e4c078 100644 --- a/src/display/manager.cc +++ b/src/display/manager.cc @@ -64,11 +64,12 @@ Manager::find(Window* w) { void Manager::adjust_layout() { - int countDynamic = 0; - int staticHeight = 0; - - std::for_each(begin(), end(), rak::if_then(std::mem_fun(&Window::is_active), rak::accumulate(staticHeight, std::mem_fun(&Window::get_min_height)))); - std::for_each(begin(), end(), rak::if_then(std::mem_fun(&Window::is_active), rak::accumulate(countDynamic, std::mem_fun(&Window::is_dynamic)))); + int staticHeight = std::for_each(begin(), end(), + rak::if_then(std::mem_fun(&Window::is_active), + rak::accumulate(0, std::mem_fun(&Window::get_min_height)))).m_then.result; + int countDynamic = std::for_each(begin(), end(), + rak::if_then(std::mem_fun(&Window::is_active), + rak::accumulate(0, std::mem_fun(&Window::is_dynamic)))).m_then.result; int dynamic = std::max(0, Canvas::get_screen_height() - staticHeight); int height = 0, h;