aurelia-svn Mailing List for Aurelia (Page 3)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 111
          http://aurelia.svn.sourceforge.net/aurelia/?rev=111&view=rev
Author:   valentindavid
Date:     2010-07-29 22:36:46 +0000 (Thu, 29 Jul 2010)

Log Message:
-----------
2010-07-29  Valentin David  <val...@ii...>

	Use pooled memory allocators.

	* src/terms/shared_object.hh: Use pooled memory allocator.
	Force a pointer to NULL on unlink.

	* src/llstack/frame.hh: Use pooled memory allocator.
	Share frames.

	* src/llstack/queue.hh,
	* src/llstack/node.hh,
	* src/llstack/node.hpp:
	Use pooled memory allocator.

	* src/parser_generator/Makefile.am:
	Fix a build rule to fail on error.

	* src/memory/pool_allocator.hh:
	Fix initialization in case the pool is used in globals'
	initialization.

	* src/threads/specific.hh: New.
	* src/threads/Makefile.am: Update.

	* configure.ac: Put -lpthread to LIBS.
	* aurelia.pc.in: Add LIBS in Libs.

	* src/memory/tests/Makefile.am: Remove useless AM_LDFLAGS.

	* demos/Makefile.am: Remove useless AM_LDFLAGS.
	Disable client-side valgrind use.

	* src/sig/tests/Makefile.am:
	Fix a rule exit.

Modified Paths:
--------------
    trunk/ChangeLog
    trunk/aurelia.pc.in
    trunk/configure.ac
    trunk/demos/Makefile.am
    trunk/src/llstack/frame.hh
    trunk/src/llstack/node.hh
    trunk/src/llstack/node.hpp
    trunk/src/llstack/queue.hh
    trunk/src/memory/pool_allocator.hh
    trunk/src/memory/tests/Makefile.am
    trunk/src/parser_generator/Makefile.am
    trunk/src/sig/tests/Makefile.am
    trunk/src/terms/shared_object.hh
    trunk/src/threads/Makefile.am

Added Paths:
-----------
    trunk/src/threads/specific.hh

Modified: trunk/ChangeLog
===================================================================

--- trunk/ChangeLog	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/ChangeLog	2010-07-29 22:36:46 UTC (rev 111)
@@ -1,5 +1,41 @@
 2010-07-29  Valentin David  <val...@ii...>
 
+	Use pooled memory allocators.
+
+	* src/terms/shared_object.hh: Use pooled memory allocator.
+	Force a pointer to NULL on unlink.
+
+	* src/llstack/frame.hh: Use pooled memory allocator.
+	Share frames.
+
+	* src/llstack/queue.hh,
+	* src/llstack/node.hh,
+	* src/llstack/node.hpp:
+	Use pooled memory allocator.
+
+	* src/parser_generator/Makefile.am:
+	Fix a build rule to fail on error.
+
+	* src/memory/pool_allocator.hh:
+	Fix initialization in case the pool is used in globals'
+	initialization.
+
+	* src/threads/specific.hh: New.
+	* src/threads/Makefile.am: Update.
+
+	* configure.ac: Put -lpthread to LIBS.
+	* aurelia.pc.in: Add LIBS in Libs.
+
+	* src/memory/tests/Makefile.am: Remove useless AM_LDFLAGS.
+
+	* demos/Makefile.am: Remove useless AM_LDFLAGS.
+	Disable client-side valgrind use.
+
+	* src/sig/tests/Makefile.am:
+	Fix a rule exit.
+
+2010-07-29  Valentin David  <val...@ii...>
+
 	* src/strategies/traversals/one.hh:
 	Fix. Was completely wrong.
 

Modified: trunk/aurelia.pc.in
===================================================================
--- trunk/aurelia.pc.in	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/aurelia.pc.in	2010-07-29 22:36:46 UTC (rev 111)
@@ -6,3 +6,4 @@
 Version: 0.1
 Description: Aurelia - Program transformation environment
 Cflags: -I${aureliadir} @EXTRACPPFLAGS@
+Libs: @LIBS@

Modified: trunk/configure.ac
===================================================================
--- trunk/configure.ac	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/configure.ac	2010-07-29 22:36:46 UTC (rev 111)
@@ -115,15 +115,13 @@
 
 AM_CONDITIONAL([BOOTSTRAP], [ test x"$BOOTSTRAP" = xtrue ])
 
-oldLIBS="$LIBS"
 AC_CHECK_HEADERS([pthread.h], [dnl
-  AC_CHECK_LIB([pthread], [pthread_create], [dnl
+  AC_SEARCH_LIBS([pthread_create], [pthread], [dnl
     true
   ], [dnl
     AC_MSG_ERROR([Found pthread.h, but not -lpthread.])
   ])
 ])
-LIBS="$oldLIBS"
 
 AC_CHECK_HEADERS([valgrind/valgrind.h])
 

Modified: trunk/demos/Makefile.am
===================================================================
--- trunk/demos/Makefile.am	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/demos/Makefile.am	2010-07-29 22:36:46 UTC (rev 111)
@@ -17,7 +17,7 @@
 
 AM_CPPFLAGS=$(EXTRACPPFLAGS) -I$(top_srcdir)/src \
 	-I$(top_builddir)/src \
-	-DNDEBUG -DSRCDIR="\"$(srcdir)\""
+	-DSRCDIR="\"$(srcdir)\"" -DNVALGRIND
 
 check_PROGRAMS=					\
 	01-terms				\
@@ -56,10 +56,5 @@
 
 if HAVE_VALGRIND
 TESTS=$(check_PROGRAMS)
-TESTS_ENVIRONMENT=ulimit -s 8192; $(VALGRIND) --leak-check=full --error-exitcode=1 >/dev/null --
+TESTS_ENVIRONMENT=ulimit -s 8192; $(VALGRIND) --leak-check=full --show-reachable=yes --error-exitcode=1 >/dev/null --
 endif
-
-if HAVE_PTHREAD_H
-03_threads_LDFLAGS=-lpthread
-04_pools_LDFLAGS=-lpthread
-endif

Modified: trunk/src/llstack/frame.hh
===================================================================
--- trunk/src/llstack/frame.hh	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/llstack/frame.hh	2010-07-29 22:36:46 UTC (rev 111)
@@ -32,9 +32,19 @@
 
 template <typename T>
 struct real_frame_helper: public real_frame {
+  void* operator new(size_t t) {
+    assert(t == sizeof(T));
+    return ChunkAlloc<T>::alloc();
+  }
+
+  void operator delete(void *p) {
+    ChunkAlloc<T>::del((T*) p);
+  }
+
   virtual real_frame* clone() const {
     return new T(*static_cast<const T*>(this));
   }
+
   virtual bool operator==(const real_frame& other) const {
     const T* rother = dynamic_cast<const T*>(&other);
     if (rother == NULL)
@@ -57,7 +67,7 @@
 
 struct frame {
 private:
-  real_frame* rf;
+  std::shared_ptr<real_frame> rf;
   unsigned _hash;
 
 public:
@@ -66,15 +76,10 @@
   }
 
   frame(const real_frame& rf): rf(rf.clone()), _hash(rf.hash()) {}
-  frame(const frame& other): rf(other.rf->clone()), _hash(other._hash) {}
+  frame(const frame& other): rf(other.rf), _hash(other._hash) {}
   frame(frame&& other): rf(other.rf), _hash(other._hash) {
-    other.rf = NULL;
   }
 
-  ~frame() {
-    delete rf;
-  }
-
   frame& operator=(const frame& other) {
     return *this = std::move(other);
   }
@@ -102,13 +107,15 @@
   }
 
   bool operator==(const frame& other) const {
+    if (&*rf == &*other.rf)
+      return true;
     return *rf == *(other.rf);
   }
 
   struct BadFrame {};
   template <typename T>
   const T& as() const {
-    const T* ret = dynamic_cast<const T*>(rf);
+    const T* ret = dynamic_cast<const T*>(&*rf);
     if (ret != NULL)
       return *ret;
     throw BadFrame();

Modified: trunk/src/llstack/node.hh
===================================================================
--- trunk/src/llstack/node.hh	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/llstack/node.hh	2010-07-29 22:36:46 UTC (rev 111)
@@ -25,6 +25,7 @@
 # include <forward_list>
 # include "../terms/shared_object.hh"
 # include "../streams/buf_stream.hh"
+# include "../memory/pool_allocator.hh"
 # include "label.hh"
 # include "frame.hh"
 # ifndef NDEBUG
@@ -57,8 +58,9 @@
 
 struct node_core {
 public:
-  typedef std::unordered_set<node> node_set_t;
-  typedef std::map<stream, std::forward_list<frame> > p_t;
+  typedef std::forward_list<frame, pool_allocator<frame> > frame_list_t;
+  typedef std::unordered_set<node, std::hash<node>, std::equal_to<node>, pool_allocator<node> > node_set_t;
+  typedef std::map<stream, frame_list_t, std::less<stream>, pool_allocator<std::pair<stream, frame_list_t> > > p_t;
 private:
   label L;
   frame f;
@@ -200,8 +202,8 @@
     }
   }
 
-  void mark(std::unordered_set<node>& marks) const {
-    std::pair<std::unordered_set<node>::iterator, bool> j =
+  void mark(std::unordered_set<node, std::hash<node>, std::equal_to<node>, pool_allocator<node> >& marks) const {
+    std::pair<std::unordered_set<node, std::hash<node>, std::equal_to<node>, pool_allocator<node> >::iterator, bool> j =
       marks.insert(*this);
     if (j.second) {
       for (node_core::node_set_t::const_iterator i =
@@ -248,8 +250,8 @@
   }
 # endif
 
-  static void clear(std::unordered_set<node> marks
-		    = std::unordered_set<node>()) {
+  static void clear(std::unordered_set<node, std::hash<node>, std::equal_to<node>, pool_allocator<node> > marks
+		    = std::unordered_set<node, std::hash<node>, std::equal_to<node>, pool_allocator<node> >()) {
     super::o_map_it i = super::objects().begin();
     while (i != super::objects().end()) {
       if (marks.find(node(const_cast<super::RealObject*>(&*i)))

Modified: trunk/src/llstack/node.hpp
===================================================================
--- trunk/src/llstack/node.hpp	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/llstack/node.hpp	2010-07-29 22:36:46 UTC (rev 111)
@@ -52,7 +52,7 @@
     for (node_core::p_t::iterator k =
 	   ret.P().begin();
 	 k != ret.P().end(); ++k) {
-      for (std::forward_list<frame>::iterator l = (*k).second.begin();
+      for (node_core::frame_list_t::iterator l = (*k).second.begin();
 	   l != (*k).second.end(); ++l) {
 	R.add(ret.get_label(), *l, u, (*k).first);
       }

Modified: trunk/src/llstack/queue.hh
===================================================================
--- trunk/src/llstack/queue.hh	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/llstack/queue.hh	2010-07-29 22:36:46 UTC (rev 111)
@@ -20,6 +20,7 @@
 # include "node.hh"
 # include "label.hh"
 # include "frame.hh"
+# include "../memory/pool_allocator.hh"
 # include <unordered_map>
 
 namespace aurelia {
@@ -69,8 +70,8 @@
     }
   };
 
-  typedef std::unordered_set<frame, frame::hash_op, frame::eq> frame_set_t;
-  typedef std::unordered_map<ln, frame_set_t, hash, eq> set_t;
+  typedef std::unordered_set<frame, frame::hash_op, frame::eq, pool_allocator<frame> > frame_set_t;
+  typedef std::unordered_map<ln, frame_set_t, hash, eq, pool_allocator<std::pair<ln, frame_set_t> > > set_t;
   set_t done;
   set_t pending;
 };
@@ -90,7 +91,7 @@
 
 struct R_t {
   struct Eof {};
-  typedef std::map<stream, Rj_t> map_t;
+  typedef std::map<stream, Rj_t, std::less<stream>, pool_allocator<std::pair<stream, Rj_t> > > map_t;
   map_t m;
 
   descriptor pop() {
@@ -118,7 +119,7 @@
   }
 
   void collect_nodes() const {
-    std::unordered_set<node> marks;
+    std::unordered_set<node, std::hash<node>, std::equal_to<node>, pool_allocator<node> > marks;
     for (map_t::const_iterator i = m.begin();
 	 i != m.end(); ++i) {
       for (Rj_t::set_t::const_iterator j = (*i).second.pending.begin();

Modified: trunk/src/memory/pool_allocator.hh
===================================================================
--- trunk/src/memory/pool_allocator.hh	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/memory/pool_allocator.hh	2010-07-29 22:36:46 UTC (rev 111)
@@ -22,8 +22,11 @@
 
 #ifdef HAVE_PTHREAD_H
 # include <pthread.h>
+# include "../threads/specific.hh"
 #endif
 
+# include "../threads/lock.hh"
+
 #ifdef HAVE_VALGRIND_VALGRIND_H
 # include <valgrind/valgrind.h>
 # include <valgrind/memcheck.h>
@@ -41,88 +44,36 @@
 #include <forward_list>
 #include <cassert>
 
+#include <iostream>
+
 namespace aurelia {
 
-  template <typename For, typename ThreadSafe>
-  struct FreePointer {
-  private:
-    static void* p;
-  public:
-    enum { key_init = true };
-
-    static void* free() {
-      return p;
-    }
-
-    static void set_free(void* other) {
-      p=other;
-    }
-  };
-
-#if defined(HAVE_PTHREAD_H)
-  template <typename For>
-  struct FreePointer<For, std::true_type> {
-  private:
-    static pthread_key_t key;
-
-  public:
-    static bool key_init;
-
-    static bool init_key() {
-      pthread_key_create(&key, NULL);
-      return true;
-    }
-
-    static void* free() {
-      return pthread_getspecific(key);
-    }
-
-    static void set_free(void* p) {
-      pthread_setspecific(key, p);
-    }
-  };
-#endif
-
-  template <typename For, typename ThreadSafe>
-  void* FreePointer<For, ThreadSafe>::p;
-
-#if defined(HAVE_PTHREAD_H)
-  template <typename For>
-  pthread_key_t FreePointer<For, std::true_type>::key;
-  template <typename For>
-  bool FreePointer<For, std::true_type>::key_init =
-    FreePointer<For, std::true_type>::init_key();
-#endif
-
   template <int SIZE>
   struct BlockList {
   private:
     std::forward_list<void*> blocks;
-    int used;
+#ifdef HAVE_PTHREAD_H
+    Lock _lock;
+#else
+    NoLock _lock;
+#endif
   public:
-    BlockList(): used(0) {}
+    BlockList() {}
 
     void* new_block() {
       void *p = malloc(SIZE);
       if (p == NULL)
 	throw std::bad_alloc();
+      _lock.lock();
       blocks.push_front(p);
+      _lock.unlock();
       return p;
     }
 
-    void operator++() {
-      used++;
-    }
-
-    void operator--() {
-      used--;
-    }
-
     ~BlockList() {
-      if (used == 0)
-	for (std::forward_list<void*>::iterator i = blocks.begin();
-	     i != blocks.end(); ++i)
-	  free(*i);
+      for (std::forward_list<void*>::iterator i = blocks.begin();
+	   i != blocks.end(); ++i)
+	free(*i);
     }
   };
 
@@ -146,25 +97,33 @@
       Block *next;
     };
 
-    static BlockList<sizeof(Block)*POOL_SIZE> blocks;
-
-    static Block* free() {
-      return (Block*)FreePointer<ChunkAlloc, ThreadSafe>::free();
+#if defined(HAVE_PTHREAD_H)
+    static Block*& free() {
+      static ThreadSpecific<Block*> _free = NULL;
+      return *_free;
     }
 
-    static void set_free(Block* p) {
-      FreePointer<ChunkAlloc, ThreadSafe>::set_free((void*)p);
+    static BlockList<sizeof(Block)*POOL_SIZE>& blocks() {
+      static ThreadSpecific<BlockList<sizeof(Block)*POOL_SIZE>, std::true_type> _blocks;
+      return *_blocks;
     }
+#else
+    static Block*& free() {
+      static Block* _free = NULL;
+      return *free;
+    }
 
-    static bool init() {
-      return (FreePointer<ChunkAlloc, ThreadSafe>::key_init);
+    static BlockList<sizeof(Block)*POOL_SIZE>& blocks() {
+      static BlockList<sizeof(Block)*POOL_SIZE> _blocks;
+      return _blocks;
     }
+#endif
 
     static Block* ensure_blocks() {
       Block* f = free();
-      if ((f == NULL) && init()) {
-	f = (Block*)blocks.new_block();
-	set_free(f);
+      if (f == NULL) {
+	f = (Block*)blocks().new_block();
+	free() = f;
 	for (int i = 0; i < (POOL_SIZE - 1); ++i) {
 	  f[i].next = f + i + 1;
 	}
@@ -179,9 +138,8 @@
       Block* n = ensure_blocks();
       VALGRIND_MEMPOOL_ALLOC(mempool(), n, sizeof(Block));
       VALGRIND_MAKE_MEM_DEFINED(&(n->next), sizeof(Block*));
-      set_free(n->next);
+      free() = n->next;
       VALGRIND_MAKE_MEM_UNDEFINED(&(n->next), sizeof(Block*));
-      ++blocks;
       return (void*)&(n->obj);
     }
 
@@ -194,18 +152,11 @@
       Block *n = (Block*)(((char*)p) - offset());
       n->next = free();
       VALGRIND_MEMPOOL_FREE(mempool(), n);
-      set_free(n);
-      --blocks;
+      free() = n;
     }
   };
 
-
   template <typename T,
-	    typename ThreadSafe,
-	    int POOL_SIZE>
-  BlockList<sizeof(typename ChunkAlloc<T, ThreadSafe, POOL_SIZE>::Block)*POOL_SIZE> ChunkAlloc<T, ThreadSafe, POOL_SIZE>::blocks;
-
-  template <typename T,
 	    typename ThreadSafe = std::true_type,
 	    int POOL_SIZE = 4096,
 	    typename RealAlloc = ChunkAlloc<T, ThreadSafe, POOL_SIZE> >

Modified: trunk/src/memory/tests/Makefile.am
===================================================================
--- trunk/src/memory/tests/Makefile.am	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/memory/tests/Makefile.am	2010-07-29 22:36:46 UTC (rev 111)
@@ -31,9 +31,5 @@
 TESTS=$(check_PROGRAMS)
 
 if HAVE_VALGRIND
-TESTS_ENVIRONMENT=ulimit -s 8192; $(VALGRIND) --leak-check=full --error-exitcode=1 >/dev/null --
+TESTS_ENVIRONMENT=ulimit -s 8192; $(VALGRIND) --leak-check=full --show-reachable=yes --error-exitcode=1 >/dev/null --
 endif
-
-if HAVE_PTHREAD_H
-AM_LDFLAGS=-lpthread
-endif

Modified: trunk/src/parser_generator/Makefile.am
===================================================================
--- trunk/src/parser_generator/Makefile.am	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/parser_generator/Makefile.am	2010-07-29 22:36:46 UTC (rev 111)
@@ -55,6 +55,11 @@
 	  mv -f syntax.hh.tmp syntax.hh; \
 	else \
 	  rm -f syntax.hh.tmp; \
+	  exit 1; \
 	fi
 
 SUBDIRS=tests
+
+if HAVE_PTHREAD_H
+AM_LDFLAGS=-lpthread
+endif

Modified: trunk/src/sig/tests/Makefile.am
===================================================================
--- trunk/src/sig/tests/Makefile.am	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/sig/tests/Makefile.am	2010-07-29 22:36:46 UTC (rev 111)
@@ -35,6 +35,7 @@
 	  mv -f stratego.hh.tmp stratego.hh; \
 	else \
 	  rm -f stratego.hh.tmp; \
+	  exit 1; \
 	fi
 
 TESTS=test

Modified: trunk/src/terms/shared_object.hh
===================================================================
--- trunk/src/terms/shared_object.hh	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/terms/shared_object.hh	2010-07-29 22:36:46 UTC (rev 111)
@@ -22,6 +22,7 @@
  */
 
 # include "../threads/lock.hh"
+# include "../memory/pool_allocator.hh"
 # include <unordered_set>
 
 namespace aurelia {
@@ -98,6 +99,7 @@
       return ;
     }
     o->ref_lock.unlock();
+    o = NULL;
   }
 
 public:
@@ -141,7 +143,7 @@
   };
 
 protected:
-  typedef std::unordered_set<RealObject, ROhash, ROeq> o_map;
+  typedef std::unordered_set<RealObject, ROhash, ROeq, pool_allocator<RealObject> > o_map;
   typedef typename o_map::iterator o_map_it;
 
   static Lock& map_lock() {

Modified: trunk/src/threads/Makefile.am
===================================================================
--- trunk/src/threads/Makefile.am	2010-07-29 22:20:23 UTC (rev 110)
+++ trunk/src/threads/Makefile.am	2010-07-29 22:36:46 UTC (rev 111)
@@ -18,4 +18,5 @@
 threadsdir=$(aureliadir)/threads
 threads_HEADERS=				\
 	lock.hh					\
-	thread.hh
+	thread.hh				\
+	specific.hh

Added: trunk/src/threads/specific.hh
===================================================================
--- trunk/src/threads/specific.hh	                        (rev 0)
+++ trunk/src/threads/specific.hh	2010-07-29 22:36:46 UTC (rev 111)
@@ -0,0 +1,102 @@
+// This file is a part of Aurelia.
+// Copyright (C) 2010  Valentin David
+// Copyright (C) 2010  University of Bergen
+//
+// 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 3 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, see <http://www.gnu.org/licenses/>.
+#ifndef __SPECIFIC_HH
+# define __SPECIFIC_HH
+
+# include <forward_list>
+# include "lock.hh"
+
+namespace aurelia {
+
+  template <typename T, typename AtLast>
+  struct Destructor {
+    void add(void *) const {
+    }
+    static void d(void *p) {
+      delete (T*)p;
+    }
+  };
+
+  template <typename T>
+  struct Destructor<T, std::true_type> {
+  private:
+    Lock lock;
+    std::forward_list<T*> todestroy;
+
+  public:
+    void add(void *p) {
+      lock.lock();
+      todestroy.push_front((T*)p);
+      lock.unlock();
+    }
+    ~Destructor() {
+      for (typename std::forward_list<T*>::iterator i = todestroy.begin();
+	   i != todestroy.end(); ++i)
+	delete *i;
+    }
+    static void d(void *) {
+    }
+  };
+
+  template <typename T, typename DestroyAtLast = std::false_type>
+  struct ThreadSpecific {
+  private:
+    T value;
+    pthread_key_t key;
+    Destructor<T, DestroyAtLast> dest;
+
+    T& get() const {
+      void *p = pthread_getspecific(key);
+      if (p == NULL) {
+	p = new T(value);
+	pthread_setspecific(key, p);
+	(const_cast<Destructor<T, DestroyAtLast>*>(&dest))->add(p);
+      }
+      return *(T*)p;
+    }
+
+    static void destructor(void *p) {
+      Destructor<T, DestroyAtLast>::d(p);
+    }
+
+  public:
+    ThreadSpecific(): value() {
+      pthread_key_create(&key, destructor);
+    }
+
+    ThreadSpecific(const T& value): value(value) {
+      pthread_key_create(&key, destructor);
+    }
+
+    ~ThreadSpecific() {
+      void *last_bit = pthread_getspecific(key);
+      pthread_key_delete(key);
+      destructor(last_bit);
+    }
+
+    T& operator*() {
+      return get();
+    }
+
+    const T& operator*() const {
+      return get();
+    }
+  };
+
+}
+
+#endif


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2010	Jan	Feb	Mar	Apr	May	Jun (8)	Jul (30)	Aug (5)	Sep (6)	Oct (13)	Nov (2)	Dec (5)
2011	Jan (5)	Feb	Mar	Apr	May (3)	Jun	Jul	Aug	Sep	Oct	Nov	Dec
2012	Jan	Feb	Mar	Apr	May	Jun	Jul (2)	Aug	Sep	Oct	Nov	Dec
2014	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec (2)
2015	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec (2)
2016	Jan	Feb	Mar	Apr (2)	May	Jun	Jul (1)	Aug	Sep	Oct (1)	Nov (1)	Dec

aurelia-svn Mailing List for Aurelia (Page 3)

aurelia-svn — Commit messages in Aurelia