static size_type shrink_buckets
      ( bucket_ptr buckets, size_type old_size
      , allocator_type &alloc, size_type new_size)
   {
      if(old_size <= new_size )
         return old_size;
      size_type received_size;
      if(!alloc.allocation_command
         (boost::interprocess::try_shrink_in_place | boost::interprocess::nothrow_allocation, old_size, new_size, received_size, buckets).first){
         return old_size;
      }

      for( bucket_type *p = ipcdetail::to_raw_pointer(buckets) + received_size
         , *pend = ipcdetail::to_raw_pointer(buckets) + old_size
         ; p != pend
         ; ++p){
         p->~bucket_type();
      }

      bucket_ptr shunk_p = alloc.allocation_command
         (boost::interprocess::shrink_in_place | boost::interprocess::nothrow_allocation, received_size, received_size, received_size, buckets).first;
      BOOST_ASSERT(buckets == shunk_p); (void)shunk_p;

      bucket_ptr buckets_init = buckets + received_size;
      for(size_type i = 0; i < (old_size - received_size); ++i){
         to_raw_pointer(buckets_init++)->~bucket_type();
      }
      return received_size;
   }

 explicit E(int i, int j, const allocator_type& a)
 {
     assert(i == 1);
     assert(j == 2);
     assert(a.id() == 50);
     constructed = true;
 }

 static bucket_ptr create_buckets(allocator_type &alloc, size_type num)
 {
    num = index_type::suggested_upper_bucket_count(num);
    bucket_ptr buckets = alloc.allocate(num);
    bucket_ptr buckets_init = buckets;
    for(size_type i = 0; i < num; ++i){
       new(to_raw_pointer(buckets_init++))bucket_type();
    }
    return buckets;
 }

 static bucket_ptr expand_or_create_buckets
    ( bucket_ptr old_buckets, const size_type old_num
    , allocator_type &alloc,  const size_type new_num)
 {
    size_type received_size = new_num;
    bucket_ptr reuse(old_buckets);
    bucket_ptr ret = alloc.allocation_command
          (boost::interprocess::expand_fwd | boost::interprocess::allocate_new, new_num, received_size, reuse);
    if(ret == old_buckets){
       bucket_ptr buckets_init = old_buckets + old_num;
       for(size_type i = 0; i < (new_num - old_num); ++i){
          ::new(to_raw_pointer(buckets_init++), boost_container_new_t())bucket_type();
       }
    }
    else{
       bucket_ptr buckets_init = ret;
       for(size_type i = 0; i < new_num; ++i){
          ::new(to_raw_pointer(buckets_init++), boost_container_new_t())bucket_type();
       }
    }
    return ret;
 }

   static bucket_ptr expand_or_create_buckets
      ( bucket_ptr old_buckets, const size_type old_num
      , allocator_type &alloc,  const size_type new_num)
   {
      size_type received_size;
      std::pair<bucket_ptr, bool> ret =
         alloc.allocation_command
            (boost::interprocess::expand_fwd | boost::interprocess::allocate_new, new_num, new_num, received_size, old_buckets);
      if(ret.first == old_buckets){
         bucket_ptr buckets_init = old_buckets + old_num;
         for(size_type i = 0; i < (new_num - old_num); ++i){
            new(to_raw_pointer(buckets_init++))bucket_type();
         }
      }
      else{
         bucket_ptr buckets_init = ret.first;
         for(size_type i = 0; i < new_num; ++i){
            new(to_raw_pointer(buckets_init++))bucket_type();
         }
      }

      return ret.first;
   }

 //-------------------------------------------------------------------
 //! Deallocate a bunch of memory.
 //-------------------------------------------------------------------
 static void
 deallocate(const allocator_type &a, T *ptr, 
            size_type const n = size_type())
 {
   return a->deallocate(ptr);
 }

 explicit C(std::allocator_arg_t, const allocator_type& a, int i)
 {
     assert(a.id() == 7);
     assert(i == 8);
     constructed = true;
 }

 static void construct(allocator_type& a, U* p, Args&&... args)
 {a.construct(p, std::forward<Args>(args)...);}

 static void destroy(allocator_type& a, U* p) {a.destroy(p);}

	void push(T &&new_value) {
		auto ptr = allocator.allocate(1);
		::new (ptr) T(std::move(new_value));

		stored_ptr new_data(ptr);

		push(std::move(new_data));
	}

      void
      _M_deallocate_node(_Node_* const __P)
      {
	// Deallocate a node of size sizeof(_Node_)!
        return _M_node_allocator.deallocate(__P, 1*sizeof(_Node_));
      }

		CAlloc_obj()
			:data_{alloc_.allocate(1)},has_not_destroy_{false}{}

 pointer allocate(size_type n){
     return static_cast<pointer>(A_.allocate(n*sizeof(T)));
 }

 void destroy(pointer start, pointer end){
     while (start != end){
         A_.destroy(start++);
     }
 }

 void
 _M_deallocate_node(_Node_* const __P)
 {
     return _M_node_allocator.deallocate(__P, 1);
 }

      _Node_*
      _M_allocate_node()
      {
	// Allocate a new node of size sizeof(_Node_)!
        return (_Node_*) _M_node_allocator.allocate(1*sizeof(_Node_));
      }

	static inline void deallocate(void * p)
		{ allocator.release((data_type *)p); }

 void deallocate(pointer p, size_type n){
     A_.deallocate(p, n*sizeof(T));
 }

 void construct(pointer finish, const_reference &c){
     A_.construct(finish, c);
 }

	static inline void *allocate()
		{ return allocator.acquire(); }