412 lines
12 KiB
CoffeeScript
412 lines
12 KiB
CoffeeScript
basic_types_uninitialized = require "./BasicTypes"
|
|
|
|
module.exports = (HB)->
|
|
basic_types = basic_types_uninitialized HB
|
|
types = basic_types.types
|
|
parser = basic_types.parser
|
|
|
|
#
|
|
# @nodoc
|
|
# Manages map like objects. E.g. Json-Type and XML attributes.
|
|
#
|
|
class MapManager extends types.Operation
|
|
|
|
#
|
|
# @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.
|
|
#
|
|
constructor: (uid)->
|
|
@map = {}
|
|
super uid
|
|
|
|
type: "MapManager"
|
|
|
|
applyDelete: ()->
|
|
for name,p of @map
|
|
p.applyDelete()
|
|
super()
|
|
|
|
cleanup: ()->
|
|
super()
|
|
|
|
#
|
|
# @see JsonTypes.val
|
|
#
|
|
val: (name, content)->
|
|
if content?
|
|
if not @map[name]?
|
|
HB.addOperation(new AddName undefined, @, name).execute()
|
|
@map[name].replace content
|
|
@
|
|
else if name?
|
|
obj = @map[name]?.val()
|
|
if obj instanceof types.ImmutableObject
|
|
obj.val()
|
|
else
|
|
obj
|
|
else
|
|
result = {}
|
|
for name,o of @map
|
|
obj = o.val()
|
|
if obj instanceof types.ImmutableObject or obj instanceof MapManager
|
|
obj = obj.val()
|
|
result[name] = obj
|
|
result
|
|
|
|
#
|
|
# @nodoc
|
|
# When a new property in a map manager is created, then the uids of the inserted Operations
|
|
# must be unique (think about concurrent operations). Therefore only an AddName operation is allowed to
|
|
# add a property in a MapManager. If two AddName operations on the same MapManager name happen concurrently
|
|
# only one will AddName operation will be executed.
|
|
#
|
|
class AddName extends types.Operation
|
|
|
|
#
|
|
# @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.
|
|
# @param {Object} map_manager Uid or reference to the MapManager.
|
|
# @param {String} name Name of the property that will be added.
|
|
#
|
|
constructor: (uid, map_manager, @name)->
|
|
@saveOperation 'map_manager', map_manager
|
|
super uid
|
|
|
|
type: "AddName"
|
|
|
|
applyDelete: ()->
|
|
super()
|
|
|
|
cleanup: ()->
|
|
super()
|
|
|
|
#
|
|
# If map_manager doesn't have the property name, then add it.
|
|
# The ReplaceManager that is being written on the property is unique
|
|
# in such a way that if AddName is executed (from another peer) it will
|
|
# always have the same result (ReplaceManager, and its beginning and end are the same)
|
|
#
|
|
execute: ()->
|
|
if not @validateSavedOperations()
|
|
return false
|
|
else
|
|
uid_r = @map_manager.getUid()
|
|
uid_r.op_number = "_#{uid_r.op_number}_RM_#{@name}"
|
|
if not HB.getOperation(uid_r)?
|
|
uid_beg = @map_manager.getUid()
|
|
uid_beg.op_number = "_#{uid_beg.op_number}_RM_#{@name}_beginning"
|
|
uid_end = @map_manager.getUid()
|
|
uid_end.op_number = "_#{uid_end.op_number}_RM_#{@name}_end"
|
|
beg = HB.addOperation(new types.Delimiter uid_beg, undefined, uid_end).execute()
|
|
end = HB.addOperation(new types.Delimiter uid_end, beg, undefined).execute()
|
|
@map_manager.map[@name] = HB.addOperation(new ReplaceManager undefined, uid_r, beg, end)
|
|
@map_manager.map[@name].setParent @map_manager, @name
|
|
(@map_manager.map[@name].add_name_ops ?= []).push @
|
|
@map_manager.map[@name].execute()
|
|
super
|
|
|
|
#
|
|
# Encode this operation in such a way that it can be parsed by remote peers.
|
|
#
|
|
_encode: ()->
|
|
{
|
|
'type' : "AddName"
|
|
'uid' : @getUid()
|
|
'map_manager' : @map_manager.getUid()
|
|
'name' : @name
|
|
}
|
|
|
|
parser['AddName'] = (json)->
|
|
{
|
|
'map_manager' : map_manager
|
|
'uid' : uid
|
|
'name' : name
|
|
} = json
|
|
new AddName uid, map_manager, name
|
|
|
|
#
|
|
# @nodoc
|
|
# Manages a list of Insert-type operations.
|
|
#
|
|
class ListManager extends types.Operation
|
|
|
|
#
|
|
# A ListManager maintains a non-empty list that has a beginning and an end (both Delimiters!)
|
|
# @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.
|
|
# @param {Delimiter} beginning Reference or Object.
|
|
# @param {Delimiter} end Reference or Object.
|
|
constructor: (uid, beginning, end, prev, next, origin)->
|
|
if beginning? and end?
|
|
@saveOperation 'beginning', beginning
|
|
@saveOperation 'end', end
|
|
else
|
|
@beginning = HB.addOperation new types.Delimiter undefined, undefined, undefined
|
|
@end = HB.addOperation new types.Delimiter undefined, @beginning, undefined
|
|
@beginning.next_cl = @end
|
|
@beginning.execute()
|
|
@end.execute()
|
|
super uid, prev, next, origin
|
|
|
|
type: "ListManager"
|
|
|
|
#
|
|
# @private
|
|
# @see Operation.execute
|
|
#
|
|
execute: ()->
|
|
if @validateSavedOperations()
|
|
@beginning.setParent @
|
|
@end.setParent @
|
|
super
|
|
else
|
|
false
|
|
|
|
# Get the element previous to the delemiter at the end
|
|
getLastOperation: ()->
|
|
@end.prev_cl
|
|
|
|
# similar to the above
|
|
getFirstOperation: ()->
|
|
@beginning.next_cl
|
|
|
|
# Transforms the the list to an array
|
|
# Doesn't return left-right delimiter.
|
|
toArray: ()->
|
|
o = @beginning.next_cl
|
|
result = []
|
|
while o isnt @end
|
|
result.push o
|
|
o = o.next_cl
|
|
result
|
|
|
|
#
|
|
# Retrieves the x-th not deleted element.
|
|
#
|
|
getOperationByPosition: (position)->
|
|
o = @beginning.next_cl
|
|
if (position > 0 or o.isDeleted()) and not (o instanceof types.Delimiter)
|
|
while o.isDeleted() and not (o instanceof types.Delimiter)
|
|
# find first non deleted op
|
|
o = o.next_cl
|
|
while true
|
|
# find the i-th op
|
|
if o instanceof types.Delimiter
|
|
break
|
|
if position <= 0 and not o.isDeleted()
|
|
break
|
|
o = o.next_cl
|
|
if not o.isDeleted()
|
|
position -= 1
|
|
o
|
|
|
|
#
|
|
# @nodoc
|
|
# Adds support for replace. The ReplaceManager manages Replaceable operations.
|
|
# Each Replaceable holds a value that is now replaceable.
|
|
#
|
|
# The WordType-type has implemented support for replace
|
|
# @see WordType
|
|
#
|
|
class ReplaceManager extends ListManager
|
|
#
|
|
# @param {Operation} initial_content Initialize this with a Replaceable that holds the initial_content.
|
|
# @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.
|
|
# @param {Delimiter} beginning Reference or Object.
|
|
# @param {Delimiter} end Reference or Object.
|
|
constructor: (initial_content, uid, beginning, end, prev, next, origin)->
|
|
super uid, beginning, end, prev, next, origin
|
|
if initial_content?
|
|
@replace initial_content
|
|
|
|
type: "ReplaceManager"
|
|
|
|
applyDelete: ()->
|
|
o = @beginning
|
|
while o?
|
|
o.applyDelete()
|
|
o = o.next_cl
|
|
# if this was created by an AddName operation, delete it too
|
|
if @add_name_ops?
|
|
for o in @add_name_ops
|
|
o.applyDelete()
|
|
super()
|
|
|
|
cleanup: ()->
|
|
super()
|
|
|
|
#
|
|
# Replace the existing word with a new word.
|
|
#
|
|
# @param content {Operation} The new value of this ReplaceManager.
|
|
# @param replaceable_uid {UID} Optional: Unique id of the Replaceable that is created
|
|
#
|
|
replace: (content, replaceable_uid)->
|
|
o = @getLastOperation()
|
|
op = new Replaceable content, @, replaceable_uid, o, o.next_cl
|
|
HB.addOperation(op).execute()
|
|
undefined
|
|
|
|
#
|
|
# Add change listeners for parent.
|
|
#
|
|
setParent: (parent, property_name)->
|
|
repl_manager = this
|
|
@on 'insert', (event, op)->
|
|
if op.next_cl instanceof types.Delimiter
|
|
repl_manager.parent.callEvent 'change', property_name, op
|
|
@on 'change', (event, op)->
|
|
if repl_manager isnt this
|
|
repl_manager.parent.callEvent 'change', property_name, op
|
|
# Call this, when the first element is inserted. Then delete the listener.
|
|
addPropertyListener = (event, op)->
|
|
repl_manager.deleteListener 'insert', addPropertyListener
|
|
repl_manager.parent.callEvent 'addProperty', property_name, op
|
|
@on 'insert', addPropertyListener
|
|
super parent
|
|
|
|
#
|
|
# Get the value of this WordType
|
|
# @return {String}
|
|
#
|
|
val: ()->
|
|
o = @getLastOperation()
|
|
#if o instanceof types.Delimiter
|
|
# throw new Error "Replace Manager doesn't contain anything."
|
|
o.val?() # ? - for the case that (currently) the RM does not contain anything (then o is a Delimiter)
|
|
|
|
#
|
|
# Encode this operation in such a way that it can be parsed by remote peers.
|
|
#
|
|
_encode: ()->
|
|
json =
|
|
{
|
|
'type': "ReplaceManager"
|
|
'uid' : @getUid()
|
|
'beginning' : @beginning.getUid()
|
|
'end' : @end.getUid()
|
|
}
|
|
if @prev_cl? and @next_cl?
|
|
json['prev'] = @prev_cl.getUid()
|
|
json['next'] = @next_cl.getUid()
|
|
if @origin? # and @origin isnt @prev_cl
|
|
json["origin"] = @origin().getUid()
|
|
json
|
|
|
|
parser["ReplaceManager"] = (json)->
|
|
{
|
|
'content' : content
|
|
'uid' : uid
|
|
'prev': prev
|
|
'next': next
|
|
'origin' : origin
|
|
'beginning' : beginning
|
|
'end' : end
|
|
} = json
|
|
new ReplaceManager content, uid, beginning, end, prev, next, origin
|
|
|
|
|
|
#
|
|
# @nodoc
|
|
# The ReplaceManager manages Replaceables.
|
|
# @see ReplaceManager
|
|
#
|
|
class Replaceable extends types.Insert
|
|
|
|
#
|
|
# @param {Operation} content The value that this Replaceable holds.
|
|
# @param {ReplaceManager} parent Used to replace this Replaceable with another one.
|
|
# @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.
|
|
#
|
|
constructor: (content, parent, uid, prev, next, origin)->
|
|
@saveOperation 'content', content
|
|
@saveOperation 'parent', parent
|
|
if not (prev? and next?)
|
|
throw new Error "You must define prev, and next for Replaceable-types!"
|
|
super uid, prev, next, origin
|
|
|
|
type: "Replaceable"
|
|
|
|
#
|
|
# Return the content that this operation holds.
|
|
#
|
|
val: ()->
|
|
@content
|
|
|
|
#
|
|
# Replace the content of this replaceable with new content.
|
|
#
|
|
replace: (content)->
|
|
@parent.replace content
|
|
|
|
applyDelete: ()->
|
|
if @content?
|
|
if @next_cl.type isnt "Delimiter"
|
|
@content.deleteAllListeners()
|
|
@content.applyDelete()
|
|
@content.dontSync()
|
|
@content = null
|
|
super
|
|
|
|
cleanup: ()->
|
|
super
|
|
|
|
#
|
|
# If possible set the replace manager in the content.
|
|
# @see WordType.setReplaceManager
|
|
#
|
|
execute: ()->
|
|
if not @validateSavedOperations()
|
|
return false
|
|
else
|
|
@content?.setReplaceManager?(@parent)
|
|
# only fire 'insert-event' (which will result in addProperty and change events),
|
|
# when content is added. In case of Json, empty content means that this is not the last update,
|
|
# since content is deleted when 'applyDelete' was exectuted.
|
|
ins_result = super(@content?) # @content? whether to fire or not
|
|
if ins_result
|
|
if @next_cl.type is "Delimiter" and @prev_cl.type isnt "Delimiter"
|
|
@prev_cl.applyDelete()
|
|
else if @next_cl.type isnt "Delimiter"
|
|
@applyDelete()
|
|
|
|
return ins_result
|
|
|
|
#
|
|
# Encode this operation in such a way that it can be parsed by remote peers.
|
|
#
|
|
_encode: ()->
|
|
json =
|
|
{
|
|
'type': "Replaceable"
|
|
'content': @content?.getUid()
|
|
'ReplaceManager' : @parent.getUid()
|
|
'prev': @prev_cl.getUid()
|
|
'next': @next_cl.getUid()
|
|
'uid' : @getUid()
|
|
}
|
|
if @origin? and @origin isnt @prev_cl
|
|
json["origin"] = @origin.getUid()
|
|
json
|
|
|
|
parser["Replaceable"] = (json)->
|
|
{
|
|
'content' : content
|
|
'ReplaceManager' : parent
|
|
'uid' : uid
|
|
'prev': prev
|
|
'next': next
|
|
'origin' : origin
|
|
} = json
|
|
new Replaceable content, parent, uid, prev, next, origin
|
|
|
|
types['ListManager'] = ListManager
|
|
types['MapManager'] = MapManager
|
|
types['ReplaceManager'] = ReplaceManager
|
|
types['Replaceable'] = Replaceable
|
|
|
|
basic_types
|
|
|
|
|
|
|
|
|
|
|
|
|