/** \brief swap content of this and other pointers.
  *  \param other element to swap content with.
  */
 void swap(this_type &other)
 {
   pointer tmp=other.release();
   assert( other.get()==NULL );
   other.t_=get();
   t_=tmp;
 }

 void swap(this_type& m)
     {
         WLock();
         m.WLock();
         parent_type::swap(m);
         m.WUnlock();
         WUnlock();
     }

 bool operator<(const this_type& m) const
     {
         bool ret;
         RLock();
         m.RLock();
         ret = parent_type::operator<(m);
         m.RUnlock();
         RUnlock();
         return ret;
     }

      bool operator==( this_type const& other ) const
      {
	if (empty()) 
	  return other.empty();

	return (low_ == other.low_) && (high_ == other.high_);
      }

 tensor( this_type const& expr,
         Geo_t const& geom, Basis_i_t const& fev )
     :
     M_tensor_expr( expr.expression(), geom, fev ),
     M_inv( vf::detail::ExtractGm<Geo_t>::get( geom )->nPoints() )
 {
 }

		bool operator < (const this_type& rhs) const
		{
			value_type lhs_value = value();
			value_type rhs_value = rhs.value();
			if(lhs_value == rhs_value)
				return m_index < rhs.m_index;
			return lhs_value < rhs_value;
		}

 //! @brief Deep comparison
 bool        operator==      (this_type const &rhs) const
 {
     return
         (!*this && !rhs) ||
         (*this && rhs && (
             (this->get() == rhs.get()) ||
             (**this == *rhs) ) );
 }

	BStr::BStr(const this_type & val) :
		m_str(nullptr)
	{
		if (val.m_str) {
			m_str = ::SysAllocStringLen(val.m_str, val.size());
			if (!m_str)
				CheckCom(E_OUTOFMEMORY);
		}
	}

			static void copy(
				this_type const & from,
				this_type & to,
				uint64_t const blockid,
				uint64_t const numblocks
				)
			{
				uint64_t const blocksize = (from.H.size()+numblocks-1) / numblocks;
				uint64_t const idlow = blockid*blocksize;
				uint64_t const idhigh = std::min(idlow+blocksize,from.H.size());
				
				for ( uint64_t i = idlow; i < idhigh; ++i )
					if ( from.H[i].first != base_type::unused() )
						to.insert(from.H[i].first,from.H[i].second);
			}

 static inline comparable_type apply(this_type const& input)
 {
     return comparable_type(input.radius());
 }

 tensor( this_type const& expr,
         Geo_t const& geom, Basis_i_t const& fev )
     :
     M_tensor_expr( expr.expression(), geom, fev )
 {
 }

 friend std::ptrdiff_t operator- (const this_type& i, const this_type& i2)
 { return i2.distance_to(i); }

 friend
 bool operator== ( const this_type& lhs, const this_type& rhs ) {
   return lhs.absolute() == rhs.absolute() ? true : false;
 }

				iterator(this_type * rowner)
				: owner(rowner), v(owner->decode())
				{

				}

 friend difference_type operator- (const this_type& i, const this_type& i2)
 { return i2.distance_to(i); }

 /*!
  * Lexicographically compares the argument string literal to a part of this string
  *
  * \pre <tt>pos <= size()</tt>
  * \param pos Starting position within this string to perform comparison to
  * \param n Length of the substring of this string to perform comparison to
  * \param that Comparand
  * \return Zero if the comparand equals this string, a negative value if this string is less than the comparand,
  *         a positive value if this string is greater than the comparand.
  *
  * \b Throws: An <tt>std::exception</tt>-based exception if \a pos is out of range.
  */
 int compare(size_type pos, size_type n, this_type const& that) const
 {
     return compare(pos, n, that.c_str(), that.size());
 }

 /** \brief comapre pointers.
  *  \param other element to compare with.
  *  \return true if this pointer is less then other, false otherwise.
  */
 bool operator<(const this_type &other) const
 {
   return get()<other.get();
 }

 friend bool operator==(const this_type& l, const this_type& r)
 {
     return l.size() == r.size() &&
            ngx_strncmp(l.data(), r.data(), l.size()) == 0
         ;
 }

	/** @brief this＝右辺値か判定。
	    @param[in] i_right 右辺値。
	 */
	public: bool operator==(this_type const& i_right) const
	{
		return this->get_malloc() == i_right.get_malloc()
			&& this->get_free() == i_right.get_free();
	}

 fixed_size_vector(const this_type& v, allocator* alloc = default_allocator()) :
     begin_(elements_), size_(0), capacity_(count), allocator_(alloc)
 {
     insert(end(), v.begin(), v.end());
 }