/**
* PublishSubscribe
* A simple publish-subscribe implementation for PHP, Python, Node/XPCOM/JS
*
* @version: 1.1.0
* https://github.com/foo123/PublishSubscribe
*
**/
!function( root, name, factory ){
"use strict";
if ( ('undefined'!==typeof Components)&&('object'===typeof Components.classes)&&('object'===typeof Components.classesByID)&&Components.utils&&('function'===typeof Components.utils['import']) ) /* XPCOM */
(root.$deps = root.$deps||{}) && (root.EXPORTED_SYMBOLS = [name]) && (root[name] = root.$deps[name] = factory.call(root));
else if ( ('object'===typeof module)&&module.exports ) /* CommonJS */
(module.$deps = module.$deps||{}) && (module.exports = module.$deps[name] = factory.call(root));
else if ( ('undefined'!==typeof System)&&('function'===typeof System.register)&&('function'===typeof System['import']) ) /* ES6 module */
System.register(name,[],function($__export){$__export(name, factory.call(root));});
else if ( ('function'===typeof define)&&define.amd&&('function'===typeof require)&&('function'===typeof require.specified)&&require.specified(name) /*&& !require.defined(name)*/ ) /* AMD */
define(name,['module'],function(module){factory.moduleUri = module.uri; return factory.call(root);});
else if ( !(name in root) ) /* Browser/WebWorker/.. */
(root[name] = factory.call(root)||1)&&('function'===typeof(define))&&define.amd&&define(function(){return root[name];} );
}( /* current root */ 'undefined' !== typeof self ? self : this,
/* module name */ "PublishSubscribe",
/* module factory */ function ModuleFactory__PublishSubscribe( undef ){
"use strict";
var __version__ = "1.1.0",
PROTO = 'prototype', HAS = Object[PROTO].hasOwnProperty,
TOPIC_SEP = '/', TAG_SEP = '#', NS_SEP = '@',
OTOPIC_SEP = '/', OTAG_SEP = '#', ONS_SEP = '@',
KEYS = Object.keys,
NOW = Date.now ? Date.now : function( ){ return new Date().getTime(); }
;
function PublishSubscribeData( props )
{
if ( props )
{
for (var k in props)
{
if ( HAS.call(props,k) )
this[ k ] = props[ k ];
}
}
}
PublishSubscribeData[PROTO] = {
constructor: PublishSubscribeData,
dispose: function( props ) {
if ( props )
{
for (var k=0; k<props.length; k++)
{
this[ props[ k ] ] = null;
}
}
return this;
}
};
function PublishSubscribeEvent(target, topic, original, tags, namespaces)
{
var self = this;
self.target = target;
if ( topic ) self.topic = [].concat( topic );
else self.topic = [ ];
if ( original ) self.originalTopic = [].concat( original );
if ( tags ) self.tags = [].concat( tags );
else self.tags = [ ];
if ( namespaces ) self.namespaces = [].concat( namespaces );
else self.namespaces = [ ];
self.data = null;//new PublishSubscribeData();
self.timestamp = NOW( );
self._propagates = true;
self._stopped = false;
self._aborted = false;
}
PublishSubscribeEvent[PROTO] = {
constructor: PublishSubscribeEvent,
target: null,
topic: null,
originalTopic: null,
tags: null,
namespaces: null,
data: null,
timestamp: 0,
is_pipelined: false,
_next: null,
_propagates: true,
_stopped: false,
_aborted: false,
dispose: function( ) {
var self = this;
self.target = null;
self.topic = null;
self.originalTopic = null;
self.tags = null;
self.namespaces = null;
if (self.data instanceof PublishSubscribeData) self.data.dispose();
self.data = null;
self.timestamp = null;
self.is_pipelined = false;
self._propagates = true;
self._stopped = true;
self._aborted = false;
self._next = null;
return self;
},
next: function( ) {
if ('function' === typeof this._next) this._next(this);
return this;
},
pipeline: function( next ) {
if ( !arguments.length ) next = null;
if ('function' === typeof next)
{
this._next = next;
this.is_pipelined = true;
}
else
{
this._next = null;
this.is_pipelined = false;
}
return this;
},
propagate: function( enable ) {
if ( !arguments.length ) enable = true;
this._propagates = !!enable;
return this;
},
stop: function( enable ) {
if ( !arguments.length ) enable = true;
this._stopped = !!enable;
return this;
},
abort: function( enable ) {
if ( !arguments.length ) enable = true;
this._aborted = !!enable;
return this;
},
aborted: function( ) {
return this._aborted;
},
propagates: function( ) {
return this._propagates;
},
stopped: function( ) {
return this._stopped;
}
};
function get_pubsub( ) { return { notopics: { notags: {namespaces: {}, list: [], oneOffs: 0}, tags: {} }, topics: {} }; }
function not_empty( s ) { return s.length > 0; }
function parse_topic( seps, topic )
{
var nspos, tagspos, tags, namespaces;
topic = String( topic );
nspos = topic.indexOf( seps[2] );
tagspos = topic.indexOf( seps[1] );
if ( -1 < nspos )
{
namespaces = topic
.slice( nspos )
.split( seps[2] )
.filter( not_empty )
.sort( )
;
topic = topic.slice( 0, nspos );
}
else
{
namespaces = [ ];
}
if ( -1 < tagspos )
{
tags = topic
.slice( tagspos )
.split( seps[1] )
.filter( not_empty )
.sort( )
;
topic = topic.slice( 0, tagspos );
}
else
{
tags = [ ];
}
topic = topic.split( seps[0] ).filter( not_empty );
return [topic, tags, namespaces];
}
function get_all_topics( seps, topic )
{
var topics = [ ], tags = [ ], namespaces/* = [ ]*/,
ttags, tns, l, i, j, jj, tmp, combinations;
topic = parse_topic( seps, topic );
//tns = topic[2];
namespaces = topic[2];
ttags = topic[1];
topic = topic[0];
l = topic.length;
while ( l )
{
topics.push( topic.join( OTOPIC_SEP ) );
topic.pop( );
l--;
}
l = ttags.length;
if ( l > 1 )
{
combinations = (1 << l);
for (i=combinations-1; i>=1; i--)
{
tmp = [ ];
for (j=0,jj=1; j<l; j++,jj=(1 << j))
{
if ( (i !== jj) && (i & jj) )
tmp.push( ttags[ j ] );
}
if ( tmp.length )
tags.push( tmp.join( OTAG_SEP ) );
}
tags = tags.concat( ttags );
}
else if ( l ) tags.push( ttags[ 0 ] );
/*l = tns.length;
if ( l > 1 )
{
combinations = (1 << l);
for (i=combinations-1; i>=1; i--)
{
tmp = [ ];
for (j=0,jj=1; j<l; j++,jj=(1 << j))
{
if ( (i !== jj) && (i & jj) )
tmp.push( tns[ j ] );
}
if ( tmp.length )
namespaces.push( tmp.join( OMS_SEP ) );
}
namespaces = namespaces.concat( tns );
}
else if ( l && tns[0].length ) namespaces.push( tns[ 0 ] );*/
return [topics.length ? topics[0] : '', topics, tags, namespaces];
}
function update_namespaces( pbns, namespaces, nl )
{
var n, ns;
for (n=0; n<nl; n++)
{
ns = 'ns_' + namespaces[n];
if ( !HAS.call(pbns,ns) )
{
pbns[ ns ] = 1;
}
else
{
pbns[ ns ]++;
}
}
}
function remove_namespaces( pbns, namespaces, nl )
{
var n, ns;
for (n=0; n<nl; n++)
{
ns = 'ns_' + namespaces[n];
if ( HAS.call(pbns,ns) )
{
pbns[ ns ]--;
if ( pbns[ ns ] <=0 ) delete pbns[ ns ];
}
}
}
function match_namespace( pbns, namespaces, nl )
{
var n, ns;
for (n=0; n<nl; n++)
{
ns = 'ns_' + namespaces[n];
if ( !HAS.call(pbns,ns) || (0 >= pbns[ ns ]) ) return false;
}
return true;
}
function check_is_subscribed( pubsub, subscribedTopics, topic, tag, namespaces, nl )
{
var _topic = !!topic ? 'tp_' + topic : false,
_tag = !!tag ? 'tg_' + tag : false;
if ( _topic && HAS.call(pubsub.topics,_topic) )
{
if ( _tag && HAS.call(pubsub.topics[ _topic ].tags,_tag) )
{
if ( pubsub.topics[ _topic ].tags[ _tag ].list.length &&
(nl <= 0 || match_namespace( pubsub.topics[ _topic ].tags[ _tag ].namespaces, namespaces, nl )) )
{
subscribedTopics.push( [topic, tag, nl > 0, pubsub.topics[ _topic ].tags[ _tag ]] );
return true;
}
}
else
{
if ( pubsub.topics[ _topic ].notags.list.length &&
(nl <= 0 || match_namespace( pubsub.topics[ _topic ].notags.namespaces, namespaces, nl )) )
{
subscribedTopics.push( [topic, null, nl > 0, pubsub.topics[ _topic ].notags] );
return true;
}
}
}
else
{
if ( _tag && HAS.call(pubsub.notopics.tags,_tag) )
{
if ( pubsub.notopics.tags[ _tag ].list.length &&
(nl <= 0 || match_namespace( pubsub.notopics.tags[ _tag ].namespaces, namespaces, nl )) )
{
subscribedTopics.push( [null, tag, nl > 0, pubsub.notopics.tags[ _tag ]] );
return true;
}
}
else
{
if ( pubsub.notopics.notags.list.length &&
(nl <= 0 || match_namespace( pubsub.notopics.notags.namespaces, namespaces, nl )) )
{
subscribedTopics.push( [null, null, true, pubsub.notopics.notags] );
return true;
}
/* else no topics no tags no namespaces, do nothing */
}
}
return false;
}
function get_subscribed_topics( seps, pubsub, atopic )
{
var all = get_all_topics( seps, atopic ), l, topic, tag, ns,
//_topic, _tag,
t, n, tl, nl,
topics = all[ 1 ], tags = all[ 2 ], namespaces = all[ 3 ],
topTopic = all[ 0 ], subscribedTopics = [ ]
;
tl = tags.length;
nl = namespaces.length;
l = topics.length;
if ( l )
{
while ( l )
{
topic = topics[ 0 ]; //_topic = 'tp_' + topic;
if ( HAS.call(pubsub.topics, 'tp_' + topic) )
{
if ( tl > 0 )
{
for (t=0; t<tl; t++)
{
tag = tags[ t ]; //_tag = 'tg_' + tag;
check_is_subscribed( pubsub, subscribedTopics, topic, tag, namespaces, nl );
}
}
else
{
check_is_subscribed( pubsub, subscribedTopics, topic, null, namespaces, nl );
}
}
topics.shift( );
l--;
}
}
if ( tl > 0 )
{
for (t=0; t<tl; t++)
{
tag = tags[ t ];
check_is_subscribed( pubsub, subscribedTopics, null, tag, namespaces, nl );
}
}
check_is_subscribed( pubsub, subscribedTopics, null, null, namespaces, nl );
/*nss = { };
if ( nl > 0 )
{
for (n=0; n<nl; n++)
{
nss[ namespaces[ n ] ] = 1;
}
}*/
return [topTopic, subscribedTopics, namespaces];
}
function unsubscribe_oneoffs( subscribers )
{
if ( subscribers && HAS.call(subscribers,"list") )
{
// unsubscribeOneOffs
var s, sl, subs, subscriber;
if ( (subs=subscribers.list) && (sl=subs.length) )
{
if ( subscribers.oneOffs > 0 )
{
for (s=sl-1; s>=0; s--)
{
subscriber = subs[ s ];
if ( subscriber[1] && subscriber[4] > 0 )
{
subs.splice( s, 1 );
subscribers.oneOffs = subscribers.oneOffs > 0 ? (subscribers.oneOffs-1) : 0;
}
}
}
else
{
subscribers.oneOffs = 0;
}
}
}
return subscribers;
}
function publish( target, seps, pubsub, topic, data )
{
if ( pubsub )
{
var topics = get_subscribed_topics( seps, pubsub, topic ),
t, s, tl, sl, subs, subscribers, subscriber, topTopic, subTopic,
tags, namespaces, hasNamespace, nl, evt, res = false, pos, nskeys
;
topTopic = topics[ 0 ];
namespaces = topics[ 2 ];
nl = namespaces.length;
topics = topics[ 1 ];
tl = topics.length;
evt = null;
if ( tl > 0 )
{
evt = new PublishSubscribeEvent( target );
evt.data = data;
evt.originalTopic = topTopic ? topTopic.split( OTOPIC_SEP ) : [ ];
}
for (t=0; t<tl; t++)
{
subTopic = topics[ t ][ 0 ];
tags = topics[ t ][ 1 ];
evt.topic = subTopic ? subTopic.split( OTOPIC_SEP ) : [ ];
evt.tags = tags ? tags.split( OTAG_SEP ) : [ ];
hasNamespace = topics[ t ][ 2 ];
subscribers = topics[ t ][ 3 ];
// create a copy avoid mutation of pubsub during notifications
subs = [ ];
sl = subscribers.list.length;
for (s=0; s<sl; s++)
{
subscriber = subscribers.list[ s ];
if ( (!subscriber[ 1 ] || !subscriber[ 4 ]) &&
(!hasNamespace ||
(subscriber[ 2 ] && match_namespace(subscriber[ 2 ], namespaces, nl)))
)
{
subs.push( subscriber );
}
}
sl = subs.length;
for (s=0; s<sl; s++)
{
subscriber = subs[ s ];
//if ( subscriber[ 1 ] && subscriber[ 4 ] > 0 ) continue; // oneoff subscriber already called
if ( hasNamespace ) evt.namespaces = subscriber[ 3 ].slice( 0 );
else evt.namespaces = [ ];
subscriber[ 4 ] = 1; // subscriber called
res = subscriber[ 0 ]( evt );
// stop event propagation
if ( (false === res) || evt.stopped() || evt.aborted() ) break;
}
// unsubscribeOneOffs
unsubscribe_oneoffs( subscribers );
// stop event bubble propagation
if ( evt.aborted() || !evt.propagates() ) break;
}
if ( evt )
{
evt.dispose( );
evt = null;
}
}
}
function create_pipeline_loop( evt, topics, abort, finish )
{
var topTopic = topics[ 0 ],
namespaces = topics[ 2 ],
topics = topics[ 1 ];
evt.non_local = new PublishSubscribeData({
't': 0,
's': 0,
'start_topic': true,
'subscribers': null,
'topics': topics,
'namespaces': namespaces,
'hasNamespace': false,
'abort': abort,
'finish': finish
});
evt.originalTopic = topTopic ? topTopic.split( OTOPIC_SEP ) : [ ];
var pipeline_loop = function pipeline_loop( evt ) {
if ( !evt.non_local ) return;
var res, non_local = evt.non_local, subTopic, tags, subscriber, done, abort, finish;
if (non_local.t < non_local.topics.length)
{
if (non_local.start_topic)
{
// unsubscribeOneOffs
unsubscribe_oneoffs( non_local.subscribers );
// stop event propagation
if ( evt.aborted() || !evt.propagates() )
{
if ( evt.aborted() && 'function' === typeof non_local.abort )
{
abort = non_local.abort;
non_local.abort = null;
abort( evt );
if ( 'function' === typeof non_local.finish )
{
finish = non_local.finish;
non_local.finish = null;
finish( evt );
}
}
return false;
}
subTopic = non_local.topics[ non_local.t ][ 0 ];
tags = non_local.topics[ non_local.t ][ 1 ];
evt.topic = subTopic ? subTopic.split( OTOPIC_SEP ) : [ ];
evt.tags = tags ? tags.split( OTAG_SEP ) : [ ];
non_local.hasNamespace = non_local.topics[ non_local.t ][ 2 ];
non_local.subscribers = non_local.topics[ non_local.t ][ 3 ];
non_local.s = 0;
non_local.start_topic = false;
}
//if (non_local.subscribers) non_local.sl = non_local.subscribers.list.length;
if (non_local.s < non_local.subscribers.list.length)
{
// stop event propagation
if ( evt.aborted() || evt.stopped() )
{
// unsubscribeOneOffs
unsubscribe_oneoffs( non_local.subscribers );
if ( evt.aborted() && 'function' === typeof non_local.abort )
{
abort = non_local.abort;
non_local.abort = null;
abort( evt );
if ( 'function' === typeof non_local.finish )
{
finish = non_local.finish;
non_local.finish = null;
finish( evt );
}
}
return false;
}
done = false;
while ( non_local.s < non_local.subscribers.list.length && !done )
{
subscriber = non_local.subscribers.list[ non_local.s ];
if ( (!subscriber[ 1 ] || !subscriber[ 4 ]) &&
(!non_local.hasNamespace ||
(subscriber[ 2 ] && match_namespace(subscriber[ 2 ], non_local.namespaces, non_local.namespaces.length)))
)
{
done = true;
}
non_local.s += 1;
}
if (non_local.s >= non_local.subscribers.list.length)
{
non_local.t += 1;
non_local.start_topic = true;
}
if ( done )
{
if ( non_local.hasNamespace ) evt.namespaces = subscriber[ 3 ].slice( 0 );
else evt.namespaces = [ ];
subscriber[ 4 ] = 1; // subscriber called
res = subscriber[ 0 ]( evt );
}
}
else
{
non_local.t += 1;
non_local.start_topic = true;
}
}
if ( !evt.non_local ) return;
if (non_local.t >= non_local.topics.length)
{
// unsubscribeOneOffs
unsubscribe_oneoffs( non_local.subscribers );
if ( 'function' === typeof non_local.finish )
{
finish = non_local.finish;
non_local.finish = null;
finish( evt );
}
if ( evt )
{
evt.non_local.dispose([
't',
's',
'start_topic',
'subscribers',
'topics',
'namespaces',
'hasNamespace',
'abort',
'finish'
]);
evt.non_local = null;
evt.dispose();
evt = null;
}
}
};
return pipeline_loop;
}
function pipeline( target, seps, pubsub, topic, data, abort, finish )
{
if ( pubsub )
{
var topics = get_subscribed_topics( seps, pubsub, topic ), evt = null, pipeline_loop;
if ( topics[ 1 ].length > 0 )
{
evt = new PublishSubscribeEvent( target );
evt.data = data;
evt.pipeline( pipeline_loop = create_pipeline_loop( evt, topics, abort, finish ) );
pipeline_loop( evt );
}
}
}
function subscribe( seps, pubsub, topic, subscriber, oneOff, on1 )
{
if ( pubsub && "function" === typeof(subscriber) )
{
topic = parse_topic( seps, topic );
var tags = topic[1].join( OTAG_SEP ), tagslen = tags.length, entry, queue,
_topic, _tag,
namespaces = topic[2], nshash, namespaces_ref, n, nslen = namespaces.length;
topic = topic[0].join( OTOPIC_SEP );
oneOff = (true === oneOff);
on1 = (true === on1);
nshash = { };
if ( nslen )
{
for (n=0; n<nslen; n++)
{
nshash['ns_'+namespaces[n]] = 1;
}
}
namespaces_ref = namespaces.slice( 0 );
queue = null;
if ( topic.length )
{
_topic = 'tp_' + topic;
if ( !HAS.call(pubsub.topics,_topic) )
pubsub.topics[ _topic ] = { notags: {namespaces: {}, list: [], oneOffs: 0}, tags: {} };
if ( tagslen )
{
_tag = 'tg_' + tags;
if ( !HAS.call(pubsub.topics[ _topic ].tags,_tag) )
pubsub.topics[ _topic ].tags[ _tag ] = {namespaces: {}, list: [], oneOffs: 0};
queue = pubsub.topics[ _topic ].tags[ _tag ];
}
else
{
queue = pubsub.topics[ _topic ].notags;
}
}
else
{
if ( tagslen )
{
_tag = 'tg_' + tags;
if ( !HAS.call(pubsub.notopics.tags,_tag) )
pubsub.notopics.tags[ _tag ] = {namespaces: {}, list: [], oneOffs: 0};
queue = pubsub.notopics.tags[ _tag ];
}
else if ( nslen )
{
queue = pubsub.notopics.notags;
}
}
if ( null !== queue )
{
entry = nslen
? [subscriber, oneOff, nshash, namespaces_ref, 0]
: [subscriber, oneOff, false, [], 0]
;
if ( on1 ) queue.list.unshift( entry );
else queue.list.push( entry );
if ( oneOff ) queue.oneOffs++;
if ( nslen ) update_namespaces( queue.namespaces, namespaces, nslen );
}
}
}
function remove_subscriber( pb, hasSubscriber, subscriber, namespaces, nslen )
{
var pos = pb.list.length, nskeys;
if ( hasSubscriber )
{
if ( (null != subscriber) && (pos > 0) )
{
while ( --pos >= 0 )
{
if ( subscriber === pb.list[pos][0] )
{
if ( nslen && pb.list[pos][2] && match_namespace( pb.list[pos][2], namespaces, nslen ) )
{
nskeys = KEYS(pb.list[pos][2]);
remove_namespaces( pb.namespaces, nskeys, nskeys.length );
if ( pb.list[pos][1] ) pb.oneOffs = pb.oneOffs > 0 ? (pb.oneOffs-1) : 0;
pb.list.splice( pos, 1 );
}
else if ( !nslen )
{
if ( pb.list[pos][2] )
{
nskeys = KEYS(pb.list[pos][2]);
remove_namespaces( pb.namespaces, nskeys, nskeys.length );
}
if ( pb.list[pos][1] ) pb.oneOffs = pb.oneOffs > 0 ? (pb.oneOffs-1) : 0;
pb.list.splice( pos, 1 );
}
}
}
}
}
else if ( !hasSubscriber && (nslen > 0) && (pos > 0) )
{
while ( --pos >= 0 )
{
if ( pb.list[pos][2] && match_namespace( pb.list[pos][2], namespaces, nslen ) )
{
nskeys = KEYS(pb.list[pos][2]);
remove_namespaces( pb.namespaces, nskeys, nskeys.length );
if ( pb.list[pos][1] ) pb.oneOffs = pb.oneOffs > 0 ? (pb.oneOffs-1) : 0;
pb.list.splice( pos, 1 );
}
}
}
else if ( !hasSubscriber && (pos > 0) )
{
pb.list = [ ];
pb.oneOffs = 0;
pb.namespaces = { };
}
}
function unsubscribe( seps, pubsub, topic, subscriber )
{
if ( pubsub )
{
topic = parse_topic( seps, topic );
var t, t2, tags = topic[1].join( OTAG_SEP ), namespaces = topic[2],
_topic, _tag,
tagslen = tags.length, nslen = namespaces.length, topiclen,
hasSubscriber
;
topic = topic[0].join( OTOPIC_SEP );
topiclen = topic.length;
_topic = topiclen ? 'tp_' + topic : false; _tag = tagslen ? 'tg_' + tags : false;
hasSubscriber = !!(subscriber && ("function" === typeof( subscriber )));
if ( !hasSubscriber ) subscriber = null;
if ( topiclen && HAS.call(pubsub.topics,_topic) )
{
if ( tagslen && HAS.call(pubsub.topics[ _topic ].tags,_tag) )
{
remove_subscriber( pubsub.topics[ _topic ].tags[ _tag ], hasSubscriber, subscriber, namespaces, nslen );
if ( !pubsub.topics[ _topic ].tags[ _tag ].list.length )
delete pubsub.topics[ _topic ].tags[ _tag ];
}
else if ( !tagslen )
{
remove_subscriber( pubsub.topics[ _topic ].notags, hasSubscriber, subscriber, namespaces, nslen );
}
if ( !pubsub.topics[ _topic ].notags.list.length && !KEYS(pubsub.topics[ _topic ].tags).length )
delete pubsub.topics[ _topic ];
}
else if ( !topiclen && (tagslen || nslen) )
{
if ( tagslen )
{
if ( HAS.call(pubsub.notopics.tags,_tag) )
{
remove_subscriber( pubsub.notopics.tags[ _tag ], hasSubscriber, subscriber, namespaces, nslen );
if ( !pubsub.notopics.tags[ _tag ].list.length )
delete pubsub.notopics.tags[ _tag ];
}
// remove from any topics as well
for ( t in pubsub.topics )
{
if ( HAS.call(pubsub.topics,t) && HAS.call(pubsub.topics[ t ].tags,_tag) )
{
remove_subscriber( pubsub.topics[ t ].tags[ _tag ], hasSubscriber, subscriber, namespaces, nslen );
if ( !pubsub.topics[ t ].tags[ _tag ].list.length )
delete pubsub.topics[ t ].tags[ _tag ];
}
}
}
else
{
remove_subscriber( pubsub.notopics.notags, hasSubscriber, subscriber, namespaces, nslen );
// remove from any tags as well
for ( t2 in pubsub.notopics.tags )
{
if ( HAS.call(pubsub.notopics.tags,t2) )
{
remove_subscriber( pubsub.notopics.tags[ t2 ], hasSubscriber, subscriber, namespaces, nslen );
if ( !pubsub.notopics.tags[ t2 ].list.length )
delete pubsub.notopics.tags[ t2 ];
}
}
// remove from any topics and tags as well
for ( t in pubsub.topics )
{
if ( HAS.call(pubsub.topics,t) )
{
remove_subscriber( pubsub.topics[ t ].notags, hasSubscriber, subscriber, namespaces, nslen );
for ( t2 in pubsub.topics[ t ].tags )
{
if ( HAS.call(pubsub.topics[ t ].tags,t2) )
{
remove_subscriber( pubsub.topics[ t ].tags[ t2 ], hasSubscriber, subscriber, namespaces, nslen );
if ( !pubsub.topics[ t ].tags[ t2 ].list.length )
delete pubsub.topics[ t ].tags[ t2 ];
}
}
}
}
}
}
}
}
//
// PublishSubscribe (Interface)
var PublishSubscribe = function( ) {
if ( !(this instanceof PublishSubscribe) ) return new PublishSubscribe( );
this.initPubSub( );
};
PublishSubscribe.VERSION = __version__;
PublishSubscribe.Event = PublishSubscribeEvent;
PublishSubscribe.Data = function( props ) {
return new PublishSubscribeData(props);
};
PublishSubscribe[PROTO] = {
constructor: PublishSubscribe
,_seps: null
,_pubsub$: null
,initPubSub: function( ) {
var self = this;
self._seps = [TOPIC_SEP, TAG_SEP, NS_SEP];
self._pubsub$ = get_pubsub( );
return self;
}
,disposePubSub: function( ) {
var self = this;
self._seps = null;
self._pubsub$ = null;
return self;
}
,setSeparators: function( seps ) {
var self = this, l;
if ( seps && (l=seps.length) )
{
if ( l > 0 && seps[0] ) self._seps[0] = seps[0];
if ( l > 1 && seps[1] ) self._seps[1] = seps[1];
if ( l > 2 && seps[2] ) self._seps[2] = seps[2];
}
return self;
}
,trigger: function( message, data, delay ) {
var self = this;
if ( 3 > arguments.length ) delay = 0;
delay = +delay;
if ( 2 > arguments.length ) data = { };
if ( delay > 0 )
{
setTimeout(function( ) {
publish( self, self._seps, self._pubsub$, message, data );
}, delay);
}
else
{
//console.log(JSON.stringify(self._pubsub$, null, 4));
publish( self, self._seps, self._pubsub$, message, data );
//console.log(JSON.stringify(self._pubsub$, null, 4));
}
return self;
}
,pipeline: function( message, data, abort, finish, delay ) {
var self = this;
if ( 5 > arguments.length ) delay = 0;
delay = +delay;
if ( 2 > arguments.length ) data = { };
if ( delay > 0 )
{
setTimeout(function( ) {
pipeline( self, self._seps, self._pubsub$, message, data, abort||null, finish||null );
}, delay);
}
else
{
//console.log(JSON.stringify(self._pubsub$, null, 4));
pipeline( self, self._seps, self._pubsub$, message, data, abort||null, finish||null );
//console.log(JSON.stringify(self._pubsub$, null, 4));
}
return self;
}
,on: function( message, callback ) {
var self = this;
if ( callback && "function" === typeof(callback) )
{
//console.log(JSON.stringify(self._pubsub$, null, 4));
subscribe( self._seps, self._pubsub$, message, callback );
//console.log(JSON.stringify(self._pubsub$, null, 4));
}
return self;
}
,one: function( message, callback ) {
var self = this;
if ( callback && "function" === typeof(callback) )
{
//console.log(JSON.stringify(self._pubsub$, null, 4));
subscribe( self._seps, self._pubsub$, message, callback, true );
//console.log(JSON.stringify(self._pubsub$, null, 4));
}
return self;
}
,on1: function( message, callback ) {
var self = this;
if ( callback && "function" === typeof(callback) )
{
//console.log(JSON.stringify(self._pubsub$, null, 4));
subscribe( self._seps, self._pubsub$, message, callback, false, true );
//console.log(JSON.stringify(self._pubsub$, null, 4));
}
return self;
}
,one1: function( message, callback ) {
var self = this;
if ( callback && "function" === typeof(callback) )
{
//console.log(JSON.stringify(self._pubsub$, null, 4));
subscribe( self._seps, self._pubsub$, message, callback, true, true );
//console.log(JSON.stringify(self._pubsub$, null, 4));
}
return self;
}
,off: function( message, callback ) {
var self = this;
//console.log(JSON.stringify(self._pubsub$, null, 4));
unsubscribe( self._seps, self._pubsub$, message, callback || null );
//console.log(JSON.stringify(self._pubsub$, null, 4));
return self;
}
};
// export it
return PublishSubscribe;
});
|
Download
