Binding:: =
	## ==========================================================================
	## Subscriber Management
	## ========================================================================== 
	addSub: (sub, options, updateOnce, updateEvenIfSame)->
		if sub.isMulti
			@addSub(subItem, options, updateOnce, updateEvenIfSame) for subItem in sub.bindings
		else
			if metaData=@subsMeta[sub.ID]
				alreadyHadSub = true
			else
				sub.pubsMap[@ID] = @
				@subs.unshift(sub)
				
				metaData = @subsMeta[sub.ID] = genObj()
				metaData.updateOnce = updateOnce
				metaData.opts = cloneObject(options)
				metaData.opts.updateEvenIfSame = true if updateEvenIfSame or @type is 'Event' or @type is 'Proxy' or @type is 'Array'
				metaData.valueRef = if sub.type is 'Func' then 'valuePassed' else 'value'
			
		return alreadyHadSub



	removeSub: (sub, bothWays)->
		if sub.isMulti
			@removeSub(subItem, bothWays) for subItem in sub.bindings
		else
			if @subsMeta[sub.ID]
				@subs.splice(@subs.indexOf(sub), 1)
				delete @subsMeta[sub.ID]
				delete sub.pubsMap[@ID]

			if bothWays
				sub.removeSub(@)
				delete @pubsMap[sub.ID]

		if @subs.length is 0 and Object.keys(@pubsMap).length is 0
			@destroy() # Since it's no longer a subscriber or has any subscribers
	
		return

	

	removeAllSubs: (bothWays)->
		@removeSub(sub, bothWays) for sub in @subs.slice()
		return




	destroy: ()-> # Resets object to initial state (pre-binding state)
		delete boundInstances[@ID]
		@removePollInterval()
		
		if @type is 'Event'
			@unRegisterEvent(event, @customEventMethod.listen) for event in @attachedEvents
		
		else if @type is 'Func'
			delete @object._sb_ID

		### istanbul ignore next ###
		convertToReg(@, @object) if @isLiveProp and @origDescriptor
		convertToReg(@, @value, true) if @type is 'Array'
		
		if @object._sb_map
			delete @object._sb_map[@selector]
			delete @object._sb_map if Object.keys(@object._sb_map).length is 0


		return






	## ==========================================================================
	## Value set/get
	## ========================================================================== 
	fetchDirectValue: ()->
		type = @type
		switch
			when type is 'Func' then @object()
			import [browserOnly] prototype.fetchDirectValue-DOMTypes.coffee
			else @object[@property]
	



	setValue: (newValue, publisher, fromSelf, fromChangeEvent)-> # fromSelf===true when called from eventUpdateHandler or property descriptor setter (unless it's an Array binding)
		publisher ||= @
		newValue = @selfTransform(newValue) if @selfTransform
		
		unless fromSelf then switch @type
			when 'ObjectProp'
				if not @isLiveProp
					@object[@property] = newValue if newValue isnt @value
				import [browserOnly] prototype.setValue-ObjectProp-DOMValue.coffee				
				else if @origSetter
					@origSetter(newValue)


			when 'Pholder'
				parent = @parentBinding
				parent.pholderValues[@pholder] = newValue
				entireValue = applyPlaceholders(parent.pholderContexts, parent.pholderValues, parent.pholderIndexMap)
				import [browserOnly] prototype.setValue-Pholder-DOMText.coffee
				parent.setValue(entireValue, publisher) import [browserOnly] prototype.setValue-Pholder-DOMText-preventParentUpdate.coffee

			when 'Array'
				if newValue isnt @value
					newValue = Array::concat(newValue) if not checkIf.isArray(newValue)
					convertToReg(@, @value, true)
					convertToLive(@, newValue=newValue.slice(), true)


			when 'Func'
				prevValue = @valuePassed
				@valuePassed = newValue
				newValue = @object(newValue, prevValue)

			when 'Event'
				@isEmitter = true
				@emitEvent(newValue)
				@isEmitter = false
		
			import [browserOnly] prototype.setValue-DOMTypes.coffee
		
		@value = newValue
		@updateAllSubs(publisher)

		return





	updateAllSubs: (publisher)-> if i=(arr=@subs).length # Ugly shortcut for index definition in order to limit logic repitiion
		@updateSub(arr[i], publisher) while i--
		return



			

	updateSub: (sub, publisher, isDelayedUpdate)->
		return if (publisher is sub) or (publisher isnt @ and publisher.subsMeta[sub.ID]) # indicates this is an infinite loop
		meta = @subsMeta[sub.ID]

		if meta.opts.throttle
			currentTime = +(new Date)
			timePassed = currentTime - meta.lastUpdate
			
			if timePassed < meta.opts.throttle
				clearTimeout(meta.updateTimer)
				return meta.updateTimer = setTimeout (()=> @updateSub(sub, publisher)), meta.opts.throttle-timePassed
			else
				meta.lastUpdate = currentTime

		else if meta.opts.delay and not isDelayedUpdate
			return setTimeout (()=> @updateSub(sub, publisher, true)), meta.opts.delay

		newValue = if @type is 'Array' and meta.opts.sendArrayCopies then @value.slice() else @value
		subValue = sub[meta.valueRef]
		newValue = if transform=meta.transformFn then transform(newValue, subValue, sub.object) else newValue

		return if newValue is subValue and not meta.opts.updateEvenIfSame or
			meta.conditionFn and not meta.conditionFn(newValue, subValue, sub.object)

		# Why do we need the 'promiseTransforms' option when we can just check for the existance of .then method?
		# Because tests show that when searching for the .then prop on the object results in a performance slowdown of up to 30%!
		# Checking if the promiseTransforms option is enabled first eliminates unnecessary lookups & slowdowns.
		if meta.opts.promiseTransforms and newValue and checkIf.isFunction(newValue.then)
			newValue.then (newValue)-> sub.setValue(newValue, publisher); return
		else
			sub.setValue(newValue, publisher)

		@removeSub(sub) if meta.updateOnce
		return



















	## ==========================================================================
	## Transforms & Conditions
	## ==========================================================================
	addModifierFn: (target, subInterfaces, subjectFn, updateOnBind)->
		if not checkIf.isFunction(subjectFn)
			throwWarning('fnOnly',2)

		else
			for subInterface in subInterfaces
				subscriber = subInterface._ or subInterface # Second is chosen when the passed subscriber interfaces multi-binding (is a recursive call of this method)

				if subscriber.isMulti
					@addModifierFn(target, subscriber.bindings, subjectFn, updateOnBind)
				
				else
					subMetaData = @subsMeta[subscriber.ID]
					subMetaData[target] = subjectFn
					updateOnBind = updateOnBind and not subMetaData.updateOnce

					if @pubsMap[subscriber.ID]
						subscriber.subsMeta[@ID][target] = subjectFn

					@updateSub(subscriber, @) if (updateOnBind or @type is 'Func') and target is 'transformFn'

			return true



	setSelfTransform: (transformFn, updateOnBind)->
		@selfTransform = transformFn
		@setValue(@value) if updateOnBind
		return













	## ==========================================================================
	## Placeholders
	## ========================================================================== 
	scanForPholders: ()-> unless @pholderValues
		@pholderValues = genObj()
		@pholderIndexMap = genObj()
		@pholderContexts = []

		if checkIf.isString(@value)
			@pholderContexts = @value.split pholderRegExSplit
			
			index = 0
			@value = @value.replace pholderRegEx, (e, pholder)=>
				@pholderIndexMap[index++] = pholder
				@pholderValues[pholder] = pholder
		
		import [browserOnly] prototype.scanForPholders-DOMText.coffee
		return
	







	## ==========================================================================
	## Polling
	## ========================================================================== 
	addPollInterval: (time)-> if @type isnt 'Event'
		@removePollInterval()
		
		@pollInterval = setInterval ()=>
			polledValue = @fetchDirectValue()

			@setValue polledValue
		, time


	removePollInterval: ()->
		clearInterval(@pollInterval)
		@pollInterval = null










	## ==========================================================================
	## Events
	## ========================================================================== 
	import [browserOnly] prototype.addUpdateListener.coffee
	
	attachEvents: ()->
		if @eventName
			@registerEvent @eventName, @customEventMethod.listen
		import [browserOnly] prototype.attachEvents-DOM.coffee
		return
	


	registerEvent: (eventName, customListenMethod)->
		import [browserOnly] prototype.registerEvent.defaultInMethod-browser.coffee
		import [nodeOnly] prototype.registerEvent.defaultInMethod-node.coffee

		@attachedEvents.push(eventName)
		attachmentMethod = customListenMethod or defaultInMethod
		
		@invokeEventMethod(eventName, attachmentMethod, defaultInMethod)
		return



	unRegisterEvent: (eventName, customEmitMethod)->
		import [browserOnly] prototype.unRegisterEvent.defaultRemoveMethod-browser.coffee
		import [nodeOnly] prototype.unRegisterEvent.defaultRemoveMethod-node.coffee

		@attachedEvents.splice @attachedEvents.indexOf(eventName), 1
		removalMethod = customEmitMethod or defaultRemoveMethod

		@invokeEventMethod(eventName, removalMethod, defaultRemoveMethod)
		return




	invokeEventMethod: (eventName, eventMethod, backupMethod)->
		subject = @object
		import [browserOnly] prototype.invokeEventMethod-jQuery.coffee
		eventMethod = backupMethod unless subject[eventMethod]
		@eventHandler = eventUpdateHandler.bind(@) unless @eventHandler#exists

		subject[eventMethod]? eventName, @eventHandler
		return



	emitEvent: (extraData)->
		subject = @object
		import [browserOnly] prototype.emitEvent.defaultOutMethod-browser.coffee
		import [nodeOnly] prototype.emitEvent.defaultOutMethod-node.coffee
		
		emitMethod = @customEventMethod.emit or defaultOutMethod
		import [browserOnly] prototype.emitEvent-jQuery.coffee
		emitMethod = defaultOutMethod unless subject[emitMethod]#exists

		import [browserOnly] prototype.emitEvent-dispatchEventObject.coffee
		subject[emitMethod](@eventName, extraData)
		return




eventUpdateHandler = ()-> unless @isEmitter
	@setValue(arguments[@property], null, true)
	return