* Starting work on resource manager.

* Modified rak::accumulate to require accessing ::result instead of
using a reference.


git-svn-id: svn://rakshasa.no/libtorrent/trunk/rtorrent@568 e378c898-3ddf-0310-93e7-cc216c733640

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

rak/functional.h

@@ -51,20 +51,35 @@ struct reference_fix<Type&> {
   typedef Type type;
 };
 
+template <typename Type>
+struct value_t {
+  value_t(Type v) : m_v(v) {}
+
+  Type operator () () const { return m_v; }
+
+  Type m_v;
+};
+
+template <typename Type>
+inline value_t<Type>
+value(Type v) {
+  return value_t<Type>(v);
+}
+
 template <typename Type, typename Ftor>
 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 <typename Arg>
-  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 <typename Type, typename Ftor>
 inline accumulate_t<Type, Ftor>
-accumulate(Type& t, Ftor f) {
+accumulate(Type t, Ftor f) {
   return accumulate_t<Type, Ftor>(t, f);
 }
 
@@ -225,6 +240,10 @@ struct mem_ptr_ref_t : public std::unary_function<Class&, Member&> {
     return c.*m_member;
   }
 
+  const Member& operator () (const Class& c) {
+    return c.*m_member;
+  }
+
   Member Class::*m_member;
 };
 

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 <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RAK_UNORDERED_VECTOR_H
+#define RAK_UNORDERED_VECTOR_H
+
+#include <vector>
+
+namespace rak {
+
+template <typename _Tp>
+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 _Tp>
+typename unordered_vector<_Tp>::iterator
+unordered_vector<_Tp>::insert(iterator position, const value_type& x) {
+  Base::push_back(x);
+
+  return --end();
+}
+
+template <typename _Tp>
+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

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;