PointSet( const self_type& P )
     :
     super(),
     M_npoints( P.nPoints() ),
     M_points( P.points() ),
     M_points_face( P.M_points_face )
 {}

    void inherit( self_type & parent ) {
#ifdef DEBUGGING
        assert( parent.size() <= size() );
#endif  // DEBUGGING

        memcpy( m_positions, parent.m_positions, parent.size() * sizeof(position_type) );
    }

    inline void basic_val<T>::copy(self_type const& o)
    {
        if (type() == o.type())
        {
            switch (o.type())
            {
                case type_info::object:
                    o_ = o.o_;
                    break;
                case type_info::array:
                    a_ = o.a_;
                    break;
                case type_info::string:
                    s_ = o.s_;
                    break;
                case type_info::int_:
                    i_ = o.i_;
                    break;
                case type_info::double_:
                    d_ = o.d_;
                    break;
                case type_info::bool_:
                    b_ = o.b_;
                    break;
                default:
                    break;
            }
            return;
        }

        free();

        switch (type_ = o.type())
        {
            case type_info::object:
                new (&o_) object(o.o_);
                break;
            case type_info::array:
                new (&a_) array(o.a_);
                break;
            case type_info::string:
                new (&s_) string(o.s_);
                break;
            case type_info::int_:
                i_ = o.i_;
                break;
            case type_info::double_:
                d_ = o.d_;
                break;
            case type_info::bool_:
                b_ = o.b_;
                break;
            default:
                break;
        }
    }

void
nsTString_CharT::ReplaceSubstring(const self_type& aTarget,
                                  const self_type& aNewValue)
{
  if (!ReplaceSubstring(aTarget, aNewValue, mozilla::fallible)) {
    // Note that this may wildly underestimate the allocation that failed, as
    // we could have been replacing multiple copies of aTarget.
    AllocFailed(mLength + (aNewValue.Length() - aTarget.Length()));
  }
}

int32_t
nsACString::RFind(const self_type& aStr, int32_t aOffset,
                  ComparatorFunc aComparator) const
{
  const char_type* begin;
  const char_type* end;
  uint32_t selflen = BeginReading(&begin, &end);

  const char_type* other;
  uint32_t otherlen = aStr.BeginReading(&other);

  if (selflen < otherlen) {
    return -1;
  }

  if (aOffset < 0 || uint32_t(aOffset) > (selflen - otherlen)) {
    end -= otherlen;
  } else {
    end = begin + aOffset;
  }

  for (const char_type* cur = end; cur >= begin; --cur) {
    if (!aComparator(cur, other, otherlen)) {
      return cur - begin;
    }
  }
  return -1;
}

 self_type cross(self_type const& r) const
 {
     impl_type* pl = (impl_type*)this->data();
     impl_type const* pr = (impl_type const*)r.data();
     impl_type res = pl->cross(*pr);
     return self_type(res(0), res(1), res(2));
 }

void
nsTSubstring_CharT::Assign(const self_type& aStr)
{
  if (!Assign(aStr, fallible_t())) {
    NS_ABORT_OOM(aStr.Length());
  }
}

int32_t
nsACString::Find(const self_type& aStr, uint32_t aOffset,
                 ComparatorFunc c) const
{
  const char_type *begin, *end;
  uint32_t selflen = BeginReading(&begin, &end);

  if (aOffset > selflen)
    return -1;

  const char_type *other;
  uint32_t otherlen = aStr.BeginReading(&other);

  if (otherlen > selflen - aOffset)
    return -1;

  // We want to stop searching otherlen characters before the end of the string
  end -= otherlen;

  for (const char_type *cur = begin + aOffset; cur <= end; ++cur) {
    if (!c(cur, other, otherlen))
      return cur - begin;
  }
  return -1;
}

    void push_back( self_type & other, size_t idx ) {
        size_t e = this->m_positions.size();

        this->resize( e + 1 );

        this->setPositionAt( e, other.getPositionAt( idx ) );
    }

void
nsTSubstring_CharT::Assign(const self_type& aStr)
{
  if (!Assign(aStr, fallible_t())) {
    AllocFailed(aStr.Length());
  }
}

void
nsTString_CharT::ReplaceSubstring( const self_type& aTarget, const self_type& aNewValue )
  {
    if (aTarget.Length() == 0)
      return;

    uint32_t i = 0;
    while (i < mLength)
      {
        int32_t r = FindSubstring(mData + i, mLength - i, aTarget.Data(), aTarget.Length(), false);
        if (r == kNotFound)
          break;

        Replace(i + r, aTarget.Length(), aNewValue);
        i += r + aNewValue.Length();
      }
  }

bool
nsTSubstring_CharT::Assign( const self_type& str, const fallible_t& )
  {
    // |str| could be sharable.  we need to check its flags to know how to
    // deal with it.

    if (&str == this)
      return true;

    if (!str.mLength)
      {
        Truncate();
        mFlags |= str.mFlags & F_VOIDED;
        return true;
      }

    if (str.mFlags & F_SHARED)
      {
        // nice! we can avoid a string copy :-)

        // |str| should be null-terminated
        NS_ASSERTION(str.mFlags & F_TERMINATED, "shared, but not terminated");

        ::ReleaseData(mData, mFlags);

        mData = str.mData;
        mLength = str.mLength;
        SetDataFlags(F_TERMINATED | F_SHARED);

        // get an owning reference to the mData
        nsStringBuffer::FromData(mData)->AddRef();
        return true;
      }
    else if (str.mFlags & F_LITERAL)
      {
        NS_ABORT_IF_FALSE(str.mFlags & F_TERMINATED, "Unterminated literal");

        AssignLiteral(str.mData, str.mLength);
        return true;
      }

    // else, treat this like an ordinary assignment.
    return Assign(str.Data(), str.Length(), fallible_t());
  }

 bool equal(const self_type& rhs) const
 {
     if (valid_)
     {
         if (rhs.valid_)
             return this->base() == rhs.base();
         else
             return false;
     }
     else
         return !rhs.valid_;
 }

PRInt32 
nsACString::RFind(const self_type& aStr, PRInt32 aOffset, ComparatorFunc c) const
{
  const char_type *begin, *end;
  PRUint32 selflen = BeginReading(&begin, &end);

  const char_type *other;
  PRUint32 otherlen = aStr.BeginReading(&other);

  if (selflen < otherlen)
    return -1;

  if (aOffset < 0 || aOffset > (selflen - otherlen))
    end -= otherlen;
  else
    end = begin + aOffset;

  for (const char_type *cur = end; cur >= begin; --cur) {
    if (!c(cur, other, otherlen))
      return cur - begin;
  }
  return -1;
}

 friend inline std::size_t hash_value(self_type const& x) {
   std::size_t h = boost::hash<MatchState>()(x.match);
   boost::hash_combine(h, x.input);
   x.hashCombine(h);
   return h;
 }

 vector_range(self_type const & v, range const & entry_range)
   : base_type(const_cast<handle_type &>(v.handle()),
               entry_range.size(), v.start() + v.stride() * entry_range.start(), v.stride()) {}

 friend inline void print(O& o, derivation_type const& d, self_type const& s) {
   s.print_projection(o, d);
 }

inline actor_ptr fwd_aptr(const self_type& s) {
    return s.unchecked();
}

 bool operator>= (self_type rhs ) const { return internal_id >= rhs.get(); }

 static inline actor_ptr _(const self_type& s) { return s.get(); }