lib/standard/ropes.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # This file is free software, which comes along with NIT.  This software is
   4 # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
   5 # without  even  the implied warranty of  MERCHANTABILITY or  FITNESS FOR A
   6 # PARTICULAR PURPOSE.  You can modify it if you want,  provided this header
   7 # is kept unaltered, and a notification of the changes is added.
   8 # You  are  allowed  to  redistribute it and sell it, alone or as a part of
   9 # another product.
  10
  11 # Nit implementation of the Ropes (see Ropes : An Alternative to Strings,
  12 # SOFTWARE - PRACTICE AND EXPERIENCE, VOL. 25(12), 1315 - 1330 (DECEMBER 1995)
  13 # Hans. J Boehm, Russ Atkinson and Michael Plass)
  14 #
  15 # A rope is a kind of string but instead of being flat, it relies on a binary tree structure to store data.
  16 module ropes
  17
  18 intrude import string
  19
  20 # Used when searching for a particular node
  21 # Returns the path to the node from the root of the rope
  22 # Also, the node and the offset for seeked position in the rope
  23 private class Path
  24         # Leaf found
  25         var leaf: Leaf
  26         # Offset in leaf
  27         var offset: Int
  28         # Stack of the nodes traversed, and the path used
  29         var stack: List[PathElement]
  30 end
  31
  32 # An element for a Path, has the concat node and whether or not
  33 # left or right child was visited.
  34 private class PathElement
  35         # Visited node
  36         var node: Concat
  37         # Was the left child visited ?
  38         var left = false
  39         # Was the right child visited ?
  40         var right = false
  41 end
  42
  43 # A node for a Rope
  44 private abstract class RopeNode
  45         # Length of the node
  46         var length = 0
  47 end
  48
  49 # Node that represents a concatenation between two nodes (of any RopeNode type)
  50 private class Concat
  51         super RopeNode
  52
  53         # Left child of the node
  54         var _left: nullable RopeNode = null
  55         # Right child of the node
  56         var _right: nullable RopeNode = null
  57
  58         fun left: nullable RopeNode do return _left
  59         fun right: nullable RopeNode do return _right
  60
  61         fun left=(l: RopeNode)
  62         do
  63                 _left = l
  64                 length = l.length
  65                 if _right != null then length += _right.length
  66         end
  67
  68         fun right=(r: RopeNode)
  69         do
  70                 _right = r
  71                 length = r.length
  72                 if _left != null then length += _left.length
  73         end
  74 end
  75
  76 # Leaf of a Rope, contains a FlatString
  77 private class Leaf
  78         super RopeNode
  79
  80         # Encapsulated FlatString in the leaf node
  81         var str: FlatString
  82
  83         init(val: FlatString) do
  84                 self.str = val
  85                 length = str.length
  86         end
  87
  88 end
  89
  90 # Basic structure, binary tree with a root node.
  91 #
  92 # Also shared services by subsequent implementations.
  93 abstract class Rope
  94         super Text
  95
  96         # Root node, entry point of a Rope.
  97         private var root: RopeNode
  98
  99         # Empty Rope
 100         init do from("")
 101
 102         # Creates a new Rope with `s` as root
 103         init from(s: String) do
 104                 if s isa RopeString then root = s.root else root = new Leaf(s.as(FlatString))
 105         end
 106
 107         private init from_root(r: RopeNode)
 108         do
 109                 root = r
 110         end
 111
 112         redef fun length do return root.length
 113
 114         # Path to the Leaf for `position`
 115         private fun node_at(position: Int): Path
 116         do
 117                 assert position >= 0 and position < length
 118                 return get_node_from(root.as(not null), 0, position, new List[PathElement])
 119         end
 120
 121         # Builds the path to Leaf at position `seek_pos`
 122         private fun get_node_from(node: RopeNode, curr_pos: Int, seek_pos: Int, stack: List[PathElement]): Path
 123         do
 124                 assert curr_pos >= 0
 125                 if node isa Leaf then return new Path(node, seek_pos - curr_pos, stack)
 126                 node = node.as(Concat)
 127
 128                 if node.left != null then
 129                         var next_pos = curr_pos + node.left.length
 130                         stack.add(new PathElement(node))
 131                         if next_pos > seek_pos then
 132                                 stack.last.left = true
 133                                 return get_node_from(node.left.as(not null), curr_pos, seek_pos, stack)
 134                         end
 135                         stack.last.right = true
 136                         return get_node_from(node.right.as(not null), next_pos, seek_pos, stack)
 137                 else
 138                         var vis = new PathElement(node)
 139                         vis.right = true
 140                         stack.add(vis)
 141                         return get_node_from(node.right.as(not null), curr_pos, seek_pos, stack)
 142                 end
 143         end
 144
 145 end
 146
 147 # Rope that cannot be modified
 148 class RopeString
 149         super Rope
 150         super String
 151
 152         redef fun to_s do return self
 153
 154         # Inserts a String `str` at position `pos`
 155         fun insert_at(str: String, pos: Int): RopeString
 156         do
 157                 if str.length == 0 then return self
 158                 if self.length == 0 then return new RopeString.from(str)
 159
 160                 assert pos >= 0 and pos <= length
 161
 162                 if pos == length then return append(str).as(RopeString)
 163
 164                 var path = node_at(pos)
 165
 166                 var last_concat = new Concat
 167
 168                 if path.offset == 0 then
 169                         last_concat.right = path.leaf
 170                         if str isa FlatString then last_concat.left = new Leaf(str) else last_concat.left = str.as(RopeString).root
 171                 else if path.offset == path.leaf.length then
 172                         if str isa FlatString then last_concat.right = new Leaf(str) else last_concat.right = str.as(RopeString).root
 173                         last_concat.left = path.leaf
 174                 else
 175                         var s = path.leaf.str
 176                         var l_half = s.substring(0, s.length - path.offset)
 177                         var r_half = s.substring_from(s.length - path.offset)
 178                         var cct = new Concat
 179                         cct.right = new Leaf(r_half)
 180                         last_concat.left = new Leaf(l_half)
 181                         if str isa FlatString then last_concat.right = new Leaf(str) else last_concat.right = str.as(RopeString).root
 182                         cct.left = last_concat
 183                         last_concat = cct
 184                 end
 185
 186                 for i in path.stack.reverse_iterator do
 187                         var nod = new Concat
 188                         if i.left then
 189                                 nod.right = i.node.right.as(not null)
 190                                 nod.left = last_concat
 191                         else
 192                                 nod.left = i.node.left.as(not null)
 193                                 nod.right = last_concat
 194                         end
 195                         last_concat = nod
 196                 end
 197
 198                 return new RopeString.from_root(last_concat)
 199         end
 200
 201         # Adds `s` at the end of self
 202         fun append(s: String): String
 203         do
 204                 if self.is_empty then return s
 205                 return new RopeString.from_root(append_to_path(root,s))
 206         end
 207
 208         # Builds a new path from root to the rightmost node with s appended
 209         private fun append_to_path(node: RopeNode, s: String): RopeNode
 210         do
 211                 var cct = new Concat
 212                 if node isa Leaf then
 213                         cct.left = node
 214                         if s isa FlatString then cct.right = new Leaf(s) else cct.right = s.as(RopeString).root
 215                 else if node isa Concat then
 216                         var right = node.right
 217                         if node.left != null then cct.left = node.left.as(not null)
 218                         if right == null then
 219                                 if s isa FlatString then cct.right = new Leaf(s) else cct.right = s.as(RopeString).root
 220                         else
 221                                 cct.right = append_to_path(right, s)
 222                         end
 223                 end
 224                 return cct
 225         end
 226
 227         # O(log(n))
 228         #
 229         #     var rope = new RopeString.from("abcd")
 230         #     assert rope.substring(1, 2)         ==  "bc"
 231         #     assert rope.substring(-1, 2)         ==  "a"
 232         #     assert rope.substring(1, 0)         ==  ""
 233         #     assert rope.substring(2, 5)         ==  "cd"
 234         #
 235         redef fun substring(pos, len)
 236         do
 237                 if pos < 0 then
 238                         len += pos
 239                         pos = 0
 240                 end
 241
 242                 if pos + len > length then len = length - pos
 243
 244                 if len <= 0 then return new RopeString.from("")
 245
 246                 var path = node_at(pos)
 247
 248                 var lf = path.leaf
 249                 var offset = path.offset
 250
 251                 if path.leaf.str.length - offset > len then lf = new Leaf(lf.str.substring(offset,len)) else lf = new Leaf(lf.str.substring_from(offset))
 252
 253                 var nod: RopeNode = lf
 254
 255                 for i in path.stack.reverse_iterator do
 256                         if i.right then continue
 257                         var tmp = new Concat
 258                         tmp.left = nod
 259                         var r = i.node.right
 260                         if r != null then tmp.right = r
 261                         nod = tmp
 262                 end
 263
 264                 var ret = new RopeString
 265                 ret.root = nod
 266
 267                 path = ret.node_at(len-1)
 268
 269                 offset = path.offset
 270                 nod = new Leaf(path.leaf.str.substring(0, offset+1))
 271
 272                 for i in path.stack.reverse_iterator do
 273                         if i.left then continue
 274                         var tmp = new Concat
 275                         tmp.right = nod
 276                         var l = i.node.left
 277                         if l != null then tmp.left = l
 278                         nod = tmp
 279                 end
 280
 281                 ret.root = nod
 282
 283                 return ret
 284         end
 285 end
 286