diff --git a/examples/trie.cc b/examples/trie.cc
index 1b9fb5a..fb10fc4 100644
--- a/examples/trie.cc
+++ b/examples/trie.cc
@@ -25,8 +25,19 @@
 #include "../utils/random-policy.h"
 #include "../utils/fifo-policy.h"
 #include <boost/intrusive/parent_from_member.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/inherit.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/mpl/inherit_linearly.hpp>
+#include <boost/mpl/range_c.hpp>
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/vector_c.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/sequence_tag.hpp>
 
 using namespace ns3;
+namespace mpl = boost::mpl;
 
 NS_LOG_COMPONENT_DEFINE ("Trie");
 
@@ -47,33 +58,189 @@
   return os;
 }
 
-template<class Policy1, class Policy2>
-struct multi_policy_hook
+template <class T>
+struct wrap
 {
-  Policy1 hook1_;
-  Policy2 hook2_;
+  T value_;
 };
 
-template<class Base, class Container1, class Container2>
+template< class Vector >
+struct multi_type_container
+  : public mpl::inherit_linearly< Vector, mpl::inherit<wrap<mpl::_2>, mpl::_1 >
+  >::type
+{
+  template<int N>
+  struct index
+  {
+    typedef typename mpl::at_c<Vector, N>::type type;
+  };
+  
+  template<class T>
+  T &
+  get ()
+  {
+    return static_cast< wrap<T> &> (*this).value_;
+  }
+
+  template<class T>
+  const T &
+  get () const
+  {
+    return static_cast< const wrap<T> &> (*this).value_;
+  }
+  
+  template<int N>
+  typename mpl::at_c<Vector, N>::type &
+  get ()
+  {
+    typedef typename mpl::at_c<Vector, N>::type T;
+    return static_cast< wrap<T> &> (*this).value_;
+  }
+
+  template<int N>
+  const typename mpl::at_c<Vector, N>::type &
+  get () const
+  {
+    typedef typename mpl::at_c<Vector, N>::type T;
+    return static_cast< const wrap<T> &> (*this).value_;
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+
+template< class Base, class Value >
+struct policy_wrap
+{
+  typedef Value value_type;
+  
+  policy_wrap (Base &base)
+  : value_ (base)
+  { }
+
+  Value value_;
+};
+
+template< class Base, class Super/*empy_wrap/previous level*/, class Value/*policy_wrap< element in vector >*/ >
+struct inherit_with_base : Super, Value
+{
+  inherit_with_base (Base &base)
+  : Super (base), Value (base)
+  { }
+
+  void
+  update (typename Base::iterator item)
+  {
+    Value::value_.update (item);
+    Super::update (item);
+  }
+
+  bool
+  insert (typename Base::iterator item)
+  {
+    // BOOST_MPL_ASSERT ((boost::is_same<Item,typename Base::iterator>));
+    bool ok = Value::value_.insert (item);
+    if (!ok)
+      return false;
+
+    ok = Super::insert (item);
+    if (!ok)
+      {
+        Value::value_.erase (item);
+        return false;
+      }
+    return true;
+  }
+
+  void
+  lookup (typename Base::iterator item)
+  {
+    Value::value_.lookup (item);
+    Super::lookup (item);
+  }
+
+  void
+  erase (typename Base::iterator item)
+  {
+    Value::value_.erase (item);
+    Super::erase (item);
+  }  
+};
+
+template< class Base >
+struct empty_policy_wrap
+{
+  empty_policy_wrap (Base &base) { }
+
+  void update (typename Base::iterator item) {}
+  bool insert (typename Base::iterator item) { return true; }
+  void lookup (typename Base::iterator item) {}
+  void erase (typename Base::iterator item) {}
+};
+
+template< class Base, class Vector >
 struct multi_policy_container
+  : public mpl::fold< Vector,
+                      empty_policy_wrap<Base>,
+                      inherit_with_base<Base,
+                                        mpl::_1/*empty/previous*/,
+                                        policy_wrap<Base, mpl::_2>/*element in vector*/>
+                      >::type
 {
-  typedef Container1 nth_container1;
-  typedef Container2 nth_container2;
-    
+  typedef typename mpl::fold< Vector,
+                              empty_policy_wrap<Base>,
+                              inherit_with_base<Base,
+                                                mpl::_1/*empty/previous*/,
+                                                policy_wrap<Base, mpl::_2>/*element in vector*/>
+                              >::type super;
+  
   multi_policy_container (Base &base)
-    : container1_ (base)
-    , container2_ (base)
+  : super (base)
+  { }
+
+  template<int N>
+  struct index
   {
-  }
+    typedef typename mpl::at_c<Vector, N>::type type;
+  };
   
-  nth_container1 container1_;
-  nth_container2 container2_;
+  template<class T>
+  T &
+  get ()
+  {
+    return static_cast< policy_wrap<Base, T> &> (*this).value_;
+  }
+
+  template<class T>
+  const T &
+  get () const
+  {
+    return static_cast< const policy_wrap<Base, T> &> (*this).value_;
+  }
+
+  template<int N>
+  typename mpl::at_c<Vector, N>::type &
+  get ()
+  {
+    typedef typename mpl::at_c<Vector, N>::type T;
+    return static_cast< policy_wrap<Base, T> &> (*this).value_;
+  }
+
+  template<int N>
+  const typename mpl::at_c<Vector, N>::type &
+  get () const
+  {
+    typedef typename mpl::at_c<Vector, N>::type T;
+    return static_cast< const policy_wrap<Base, T> &> (*this).value_;
+  }
 };
 
-template<class BaseHook, class ValueType, class HookType>
-struct Functor1
+
+template<class BaseHook, class ValueType, int N>
+struct FunctorHook
 {
-  typedef HookType hook_type;
+  typedef typename BaseHook::template index<N>::type hook_type;
   typedef hook_type*            hook_ptr;
   typedef const hook_type*      const_hook_ptr;
   
@@ -83,100 +250,67 @@
   
   //Required static functions
   static hook_ptr to_hook_ptr (value_type &value)
-  {  return &value.policy_hook_.hook1_; }
+  {  return &value.policy_hook_.template get<N> (); }
   
   static const_hook_ptr to_hook_ptr(const value_type &value)
-  {  return &value.policy_hook_.hook1_; }
+  {  return &value.policy_hook_.template get<N> (); }
   
   static pointer to_value_ptr(hook_ptr n)
   {
-    return bi::get_parent_from_member<value_type>
-      (bi::get_parent_from_member<BaseHook >
-       (n, &BaseHook::hook1_)
-       , &value_type::policy_hook_
-       );
+    return
+      bi::get_parent_from_member<value_type>
+      (static_cast<BaseHook*> (bi::get_parent_from_member< wrap<hook_type> >(n, &wrap<hook_type>::value_)),
+       &value_type::policy_hook_);
   }
   static const_pointer to_value_ptr(const_hook_ptr n)
   {
-    return bi::get_parent_from_member<value_type>
-      (bi::get_parent_from_member<BaseHook>
-       (n, &BaseHook::hook1_)
-       , &value_type::policy_hook_
-       );
+    return
+      bi::get_parent_from_member<value_type>
+      (static_cast<const BaseHook*> (bi::get_parent_from_member< wrap<hook_type> >(n, &wrap<hook_type>::value_)),
+       &value_type::policy_hook_);
   }
 };
 
-template<class BaseHook, class ValueType, class HookType>
-struct Functor2
-{
-  typedef HookType hook_type;
-  typedef hook_type*            hook_ptr;
-  typedef const hook_type*      const_hook_ptr;
-  
-  typedef ValueType             value_type;
-  typedef value_type*           pointer;
-  typedef const value_type*     const_pointer;
-  
-  //Required static functions
-  static hook_ptr to_hook_ptr (value_type &value)
-  {  return &value.policy_hook_.hook2_; }
-  
-  static const_hook_ptr to_hook_ptr(const value_type &value)
-  {  return &value.policy_hook_.hook2_; }
-  
-  static pointer to_value_ptr(hook_ptr n)
-  {
-    return bi::get_parent_from_member<value_type>
-      (bi::get_parent_from_member<BaseHook >
-       (n, &BaseHook::hook2_)
-       , &value_type::policy_hook_
-       );
-  }
-  static const_pointer to_value_ptr(const_hook_ptr n)
-  {
-    return bi::get_parent_from_member<value_type>
-      (bi::get_parent_from_member<BaseHook>
-       (n, &BaseHook::hook2_)
-       , &value_type::policy_hook_
-       );
-  }
-};
-
-
+template<typename Policies> // e.g., mpl::vector1< lru_policy_traits >
 struct multi_policy_traits
 {
-  typedef multi_policy_hook< lru_policy_traits::policy_hook_type
-                             ,
-                             random_policy_traits::policy_hook_type
-                             > policy_hook_type;
+  typedef Policies policy_traits;
 
+  struct getHook
+  {
+    template<class Item>
+    struct apply
+    {
+      typedef typename Item::policy_hook_type type;
+    };
+  };
+    
+  typedef multi_type_container< typename mpl::transform1<policy_traits, getHook>::type > policy_hook_type;
+  typedef mpl::range_c<int, 0, mpl::size<policy_traits>::type::value> policies_range;
+  
   template<class Container>
   struct container_hook
   {
-    struct type
-    {
-      typedef bi::function_hook< Functor1 <policy_hook_type,
-                                           Container,
-                                           typename lru_policy_traits::policy_hook_type> > hook1;
-
-      struct hook2
-      {
-        typedef bi::function_hook< Functor2 <policy_hook_type,
-                                             Container,
-                                             typename random_policy_traits::policy_hook_type> > hook_type;
-        
-        static uint32_t& get_order (typename Container::iterator item)
-        {
-          return item->policy_hook_.hook2_.randomOrder;
-        }
-        
-        static const uint32_t& get_order (typename Container::const_iterator item)
-        {
-          return item->policy_hook_.hook2_.randomOrder;
-        }
-      };
-      
-    };
+    typedef void type;
+    // struct getFunctionHook
+    // {
+    //   template<class Number>
+    //   struct apply
+    //   {
+    //     // typedef void type;
+    //     typedef bi::function_hook< FunctorHook <policy_hook_type,
+    //                                             Container,
+    //                                             Number::value> > type;
+    //   };
+    // };
+    
+    // struct type
+    // {
+    //   typedef
+    //   typename mpl::transform1<policies_range,
+    //                            getFunctionHook,
+    //                            mpl::back_inserter< mpl::vector0<> > >::type hooks;
+    // };
   };
 
   template<class Base,
@@ -184,12 +318,45 @@
            class Hook>
   struct policy 
   {
-    typedef multi_policy_container <
-      Base, 
-      typename lru_policy_traits::policy< Base, Container, typename Hook::hook1 >::type
-      ,
-      typename random_policy_traits::policy< Base, Container, typename Hook::hook2 >::type
-      > policy_container;
+    // 1 hooks
+    // 2 actual policies
+
+    // struct getPolicy
+    // {
+    //   template<class Item>
+    //   struct apply
+    //   {
+    //     typedef typename Item::template policy<Base,
+    //                                            Container,
+    //                                            typename mpl::at_c<typename Hook::hooks,0>::type >::type type;
+    //   };
+    // };
+    
+    // typedef typename mpl::transform1<policy_traits, getPolicy>::type policies;
+
+    struct getPolicy
+    {
+      template<class Number>
+      struct apply
+      {
+        typedef
+        typename mpl::at_c<policy_traits, Number::value>::type::
+        template policy<Base,
+                        Container,
+                        bi::function_hook< FunctorHook <policy_hook_type,
+                                                        Container,
+                                                        Number::value> > >::type
+        type;
+      };
+    };
+    
+    typedef
+    typename mpl::transform1<policies_range,
+                             getPolicy,
+                             mpl::back_inserter< mpl::vector0<> > >::type policies;
+                             
+    
+    typedef multi_policy_container< Base, policies > policy_container;
     
     class type : public policy_container
     {
@@ -204,82 +371,64 @@
       inline void
       update (typename parent_trie::iterator item)
       {
-        this->container1_.update (item);
-        this->container2_.update (item);
+        policy_container::update (item);
       }
   
       inline bool
       insert (typename parent_trie::iterator item)
       {
-        bool ok;
-        ok = this->container1_.insert (item);
-        if (!ok)
-          {
-            // nothing to undo. just return false
-            return false;
-          }
-        
-        ok = this->container2_.insert (item);
-        if (!ok)
-          {
-            // undo and return false
-            this->container1_.erase (item);
-            return false;
-          }
-        return true;
+        return policy_container::insert (item);
       }
   
       inline void
       lookup (typename parent_trie::iterator item)
       {
-        this->container1_.lookup (item);
-        this->container2_.lookup (item);
+        policy_container::lookup (item);
       }
   
       inline void
       erase (typename parent_trie::iterator item)
       {
-        this->container1_.erase (item);
-        this->container2_.erase (item);
-      }
-
-      inline typename policy_container::nth_container1 &
-      get1 ()
-      {
-        return this->container1_;
-      }
-
-      inline typename policy_container::nth_container2 &
-      get2 ()
-      {
-        return this->container2_;
+        policy_container::erase (item);
       }
     };
   };
 };
 
+
 int
 main (int argc, char *argv[])
 {
   CommandLine args;
   args.Parse (argc, argv);
+
+  // typedef multi_policy_traits<lru_policy_traits> traits;
+  // // traits::policy<traits::hook>
+  // traits::policy<Bla1,Bla2, traits::container_hook<Bla2>::type> x;
   
   typedef trie_with_policy<
     ns3::CcnxNameComponents,
     smart_pointer_payload_traits<Integer>,
-    multi_policy_traits > trie;
+    multi_policy_traits<
+      mpl::vector2<lru_policy_traits,fifo_policy_traits>
+      // mpl::vector1<lru_policy_traits>
+      > > trie;
+  //   // multi_policy_traits<lru_policy_traits, random_policy_traits> > trie;
   
   trie x;
-  x.getPolicy ().get1 ().set_max_size (10);
-  x.getPolicy ().get2 ().set_max_size (3);
+  x.getPolicy ().get<0> ().set_max_size (3);
+  x.getPolicy ().get<1> ().set_max_size (100);
+  // // x.getPolicy ().get<1> ().set_max_size (3);
+  // // // x.getPolicy ().get1 ().set_max_size (10);
+  // // // x.getPolicy ().get2 ().set_max_size (3);
   
-  // x.getTrie ().PrintStat (std::cout);
+  // // // x.getTrie ().PrintStat (std::cout);
   
   ns3::CcnxNameComponents n1,n2,n3,n4;
-  // n1("a")("b")("c");
-  // n2("a")("b")("d");
-  // n3("a")("b")("f");
-  // n4("a")("b");
+  // // // n1("a")("b")("c");
+  // // // n2("a")("b")("d");
+  // // // n3("a")("b")("f");
+  // // // n4("a")("b");
 
   n1("a");
   n2("b");
@@ -288,10 +437,10 @@
 
   x.insert (n1, ns3::Create<Integer> (1));
   x.insert (n2, ns3::Create<Integer> (2));
-  x.longest_prefix_match (n1);
+  // // // x.longest_prefix_match (n1);
   x.insert (n3, ns3::Create<Integer> (3));
   x.insert (n4, ns3::Create<Integer> (4));
-  // x.insert (n4, ns3::Create<Integer> (4));
+  x.insert (n4, ns3::Create<Integer> (4));
 
   std::cout << "digraph trie {\n";
   std::cout << x.getTrie ();
diff --git a/utils/fifo-policy.h b/utils/fifo-policy.h
index afb0919..e8139ae 100644
--- a/utils/fifo-policy.h
+++ b/utils/fifo-policy.h
@@ -23,7 +23,7 @@
 
 struct fifo_policy_traits
 {
-  typedef bi::list_member_hook<> policy_hook_type;
+  struct policy_hook_type : public bi::list_member_hook<> {};
 
   template<class Container>
   struct container_hook
@@ -96,6 +96,9 @@
       }
 
     private:
+      type () : base_(*((Base*)0)) { };
+
+    private:
       Base &base_;
       size_t max_size_;
     };
diff --git a/utils/lru-policy.h b/utils/lru-policy.h
index 14e49f7..cd091ce 100644
--- a/utils/lru-policy.h
+++ b/utils/lru-policy.h
@@ -23,12 +23,11 @@
 
 struct lru_policy_traits
 {
-  typedef bi::list_member_hook<> policy_hook_type;
+  struct policy_hook_type : public bi::list_member_hook<> {};
 
   template<class Container>
   struct container_hook
   {
-    // could be class/struct implementation
     typedef bi::member_hook< Container,
                              policy_hook_type,
                              &Container::policy_hook_ > type;
@@ -102,6 +101,9 @@
       }
 
     private:
+      type () : base_(*((Base*)0)) { };
+
+    private:
       Base &base_;
       size_t max_size_;
     };
diff --git a/utils/random-policy.h b/utils/random-policy.h
index 28a9800..ebf0a59 100644
--- a/utils/random-policy.h
+++ b/utils/random-policy.h
@@ -30,22 +30,9 @@
   template<class Container>
   struct container_hook
   {
-    struct type
-    {
-      typedef bi::member_hook< Container,
-                               policy_hook_type,
-                               &Container::policy_hook_ > hook_type;
-
-      static uint32_t& get_order (typename Container::iterator item)
-      {
-        return item->policy_hook_.randomOrder;
-      }
-      
-      static const uint32_t& get_order (typename Container::const_iterator item)
-      {
-        return item->policy_hook_.randomOrder;
-      }
-    };
+    typedef bi::member_hook< Container,
+                             policy_hook_type,
+                             &Container::policy_hook_ > type;
   };
 
   template<class Base,
@@ -53,18 +40,30 @@
            class Hook>
   struct policy 
   {
+    static uint32_t& get_order (typename Container::iterator item)
+    {
+      return static_cast<typename policy_container::value_traits::hook_type*>
+        (policy_container::value_traits::to_node_ptr(*item))->randomOrder;
+    }
+      
+    static const uint32_t& get_order (typename Container::const_iterator item)
+    {
+      return static_cast<const typename policy_container::value_traits::hook_type*>
+        (policy_container::value_traits::to_node_ptr(*item))->randomOrder;
+    }
+    
     template<class Key>
     struct MemberHookLess
     {
       bool operator () (const Key &a, const Key &b) const
       {
-        return Hook::get_order (&a) < Hook::get_order (&b);
+        return get_order (&a) < get_order (&b);
       }
     };
 
     typedef bi::set< Container,
                      bi::compare< MemberHookLess< Container > >,
-                     typename Hook::hook_type > policy_container;
+                     Hook > policy_container;
     
     // could be just typedef
     class type : public policy_container
@@ -88,7 +87,7 @@
       inline bool
       insert (typename parent_trie::iterator item)
       {
-        Hook::get_order (item) = u_rand.GetValue ();
+        get_order (item) = u_rand.GetValue ();
 
         if (policy_container::size () >= max_size_)
           {
@@ -134,6 +133,9 @@
       }
 
     private:
+      type () : base_(*((Base*)0)) { };
+      
+    private:
       Base &base_;
       ns3::UniformVariable u_rand;
       size_t max_size_;