--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/dom/RangeBoundaryPoint.h	Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef RangeBoundaryPoint_h
+#define RangeBoundaryPoint_h
+
+#include "Node.h"
+#include "Position.h"
+
+namespace WebCore {
+
+class RangeBoundaryPoint {
+public:
+    explicit RangeBoundaryPoint(PassRefPtr<Node> container);
+
+    const Position toPosition() const;
+
+    Node* container() const;
+    int offset() const;
+    Node* childBefore() const;
+
+    void clear();
+
+    void set(PassRefPtr<Node> container, int offset, Node* childBefore);
+    void setOffset(int offset);
+
+    void setToBeforeChild(Node*);
+    void setToStartOfNode(PassRefPtr<Node>);
+    void setToEndOfNode(PassRefPtr<Node>);
+
+    void childBeforeWillBeRemoved();
+    void invalidateOffset() const;
+    void ensureOffsetIsValid() const;
+
+private:
+    static const int invalidOffset = -1;
+    
+    RefPtr<Node> m_containerNode;
+    mutable int m_offsetInContainer;
+    Node* m_childBeforeBoundary;
+};
+
+inline RangeBoundaryPoint::RangeBoundaryPoint(PassRefPtr<Node> container)
+    : m_containerNode(container)
+    , m_offsetInContainer(0)
+    , m_childBeforeBoundary(0)
+{
+    ASSERT(m_containerNode);
+}
+
+inline Node* RangeBoundaryPoint::container() const
+{
+    return m_containerNode.get();
+}
+
+inline Node* RangeBoundaryPoint::childBefore() const
+{
+    return m_childBeforeBoundary;
+}
+
+inline void RangeBoundaryPoint::ensureOffsetIsValid() const
+{
+    if (m_offsetInContainer >= 0)
+        return;
+
+    ASSERT(m_childBeforeBoundary);
+    m_offsetInContainer = m_childBeforeBoundary->nodeIndex() + 1;
+}
+
+inline const Position RangeBoundaryPoint::toPosition() const
+{
+    ensureOffsetIsValid();
+    return Position(m_containerNode.get(), m_offsetInContainer);
+}
+
+inline int RangeBoundaryPoint::offset() const
+{
+    ensureOffsetIsValid();
+    return m_offsetInContainer;
+}
+
+inline void RangeBoundaryPoint::clear()
+{
+    m_containerNode.clear();
+    m_offsetInContainer = 0;
+    m_childBeforeBoundary = 0;
+}
+
+inline void RangeBoundaryPoint::set(PassRefPtr<Node> container, int offset, Node* childBefore)
+{
+    ASSERT(container);
+    ASSERT(offset >= 0);
+    ASSERT(childBefore == (offset ? container->childNode(offset - 1) : 0));
+    m_containerNode = container;
+    m_offsetInContainer = offset;
+    m_childBeforeBoundary = childBefore;
+}
+
+inline void RangeBoundaryPoint::setOffset(int offset)
+{
+    ASSERT(m_containerNode);
+    ASSERT(m_containerNode->offsetInCharacters());
+    ASSERT(m_offsetInContainer >= 0);
+    ASSERT(!m_childBeforeBoundary);
+    m_offsetInContainer = offset;
+}
+
+inline void RangeBoundaryPoint::setToBeforeChild(Node* child)
+{
+    ASSERT(child);
+    ASSERT(child->parentNode());
+    m_childBeforeBoundary = child->previousSibling();
+    m_containerNode = child->parentNode();
+    m_offsetInContainer = m_childBeforeBoundary ? invalidOffset : 0;
+}
+
+inline void RangeBoundaryPoint::setToStartOfNode(PassRefPtr<Node> container)
+{
+    ASSERT(container);
+    m_containerNode = container;
+    m_offsetInContainer = 0;
+    m_childBeforeBoundary = 0;
+}
+
+inline void RangeBoundaryPoint::setToEndOfNode(PassRefPtr<Node> container)
+{
+    ASSERT(container);
+    m_containerNode = container;
+    if (m_containerNode->offsetInCharacters()) {
+        m_offsetInContainer = m_containerNode->maxCharacterOffset();
+        m_childBeforeBoundary = 0;
+    } else {
+        m_childBeforeBoundary = m_containerNode->lastChild();
+        m_offsetInContainer = m_childBeforeBoundary ? invalidOffset : 0;
+    }
+}
+
+inline void RangeBoundaryPoint::childBeforeWillBeRemoved()
+{
+    ASSERT(m_offsetInContainer);
+    m_childBeforeBoundary = m_childBeforeBoundary->previousSibling();
+    if (!m_childBeforeBoundary)
+        m_offsetInContainer = 0;
+    else if (m_offsetInContainer > 0)
+        --m_offsetInContainer;
+}
+
+inline void RangeBoundaryPoint::invalidateOffset() const
+{
+    m_offsetInContainer = invalidOffset;
+}
+
+inline bool operator==(const RangeBoundaryPoint& a, const RangeBoundaryPoint& b)
+{
+    if (a.container() != b.container())
+        return false;
+    if (a.childBefore() || b.childBefore()) {
+        if (a.childBefore() != b.childBefore())
+            return false;
+    } else {
+        if (a.offset() != b.offset())
+            return false;
+    }
+    return true;
+}
+
+}
+
+#endif