Proxy unsubscriber to unsubscribe from the CalendarGroup's child Calendars' CustomEvents
@method unsub
@private
@param {Function} fn The function to subscribe to this CustomEvent
@param {Object} obj The CustomEvent's scope object
19926
function(fn, obj) {
            for (var p=0;p<me.pages.length;++p) {
                var cal = me.pages[p];
                cal[this.type + strEvent].unsubscribe(fn, obj);
            }
        }
522515
function unsubscribeRecursively( self, node, parts, subscriber ) {
   if( parts.length === 0 && Array.isArray( node[ SUBSCRIBER_FIELD ] ) ) {
      const subscribers = node[ SUBSCRIBER_FIELD ];
      for( let i = subscribers.length - 1; i >= 0; --i ) {
         if( subscribers[ i ].subscriber === subscriber ) {
            notifyInspectors( self, {
               action: 'unsubscribe',
               source: subscribers[ i ].subscriberName,
               target: '-',
               event: subscribers[ i ].name,
               cycleId: self.currentCycle_
            } );
            subscribers.splice( i, 1 );
         }
      }
   }

   const [ part, ...rest ] = parts;
   const searchPart = part || WILDCARD;
   if( searchPart in node ) {
      unsubscribeRecursively( self, node[ searchPart ], rest, subscriber );
   }
}
393250
public <T extends DObject> void unsubscribeFromObject (int oid, Subscriber<T> target)
    {
        // queue up an access object event
        postEvent(new AccessObjectEvent<T>(oid, target, AccessObjectEvent.UNSUBSCRIBE));
    }
486069
@Override
    public java.util.concurrent.Future<UnsubscribeResult> unsubscribeAsync(String subscriptionArn) {

        return unsubscribeAsync(new UnsubscribeRequest().withSubscriptionArn(subscriptionArn));
    }
1321757
@Override
    public void subscribeRemoteEvent(String eventName, boolean subscribe) {
        String channelName = EventUtil.getChannelName(eventName);
        
        if (subscribe) {
            consumer.subscribe(channelName, this);
        } else {
            consumer.unsubscribe(channelName, this);
        }
    }
37940
function unsubscribe(message) {
		reply(proto.writeUnsubscribe(message.id));
		subscritions[message.itemName] = undefined;
		dequeueSubUnsubRequest(message.itemName);
		handleLateSubUnsubRequests(message.itemName);
		fireFirstSubUnsubEvent(message.itemName);
	}
204122
function(channel) {
      if (!channels[channel]) return;

      var args = [].slice.call(arguments, 1),
          subscription;

      for (var i = 0; i < channels[channel].length; i++) {
        subscription = channels[channel][i];
        subscription.fn.apply(subscription.context, args);
        if (subscription.once) {
          Backbone.Mediator.unsubscribe(channel, subscription.fn, subscription.context);
          i--;
        }
      }
    }
1238817
function(listener) {
            var instance = this;
            if (listener) {
                instance._removeSubscribers(listener, '*:*');
            }
            else {
                // we cannot just redefine _subs, for it is set as readonly
                instance._subs.itsa_each(
                    function(value, key) {
                        delete instance._subs[key];
                    }
                );
            }
        }
166687
def remove(self, event, subscriber):
        
        subs = self._subscribers
        if event not in subs:
            raise ValueError('No subscribers: %r' % event)
        subs[event].remove(subscriber)
794455
function NativeSubscribeQueue(obj) {
  if (!(this instanceof NativeSubscribeQueue)) {
    return new NativeSubscribeQueue(obj);
  }

  EventEmitter.call(this);

  obj = obj || {};

  this.name = obj.name;
  this.type = 'sub';
  this.queue = obj.queue || null;
  this._onPublish = [];
  this._onMessage = [];
}
1195266
private void hostSubscribe(String eventName, boolean subscribe) {
        if (globalEventDispatcher != null) {
            try {
                globalEventDispatcher.subscribeRemoteEvent(eventName, subscribe);
            } catch (Throwable e) {
                log.error(
                    "Error " + (subscribe ? "subscribing to" : "unsubscribing from") + " remote event '" + eventName + "'",
                    e);
            }
        }
    }
560009
function ( obj, fn ) {
		var remove;

		if ( typeof fn !== "function" ) {
			throw new Error( label.error.invalidArguments );
		}

		remove = obj.filter( fn );

		array.each( remove, function ( i ) {
			array.remove( obj, array.index ( obj, i ) );
		});

		return obj;
	}
1004355
function () {
            /*  determine parameters  */
            var params = $cs.params("unsubscribe", arguments, {
                id: { pos: 0, req: true }
            });

            /*  detach parameters from component  */
            if (typeof this.__subscription[params.id] === "undefined")
                throw _cs.exception("unsubscribe", "subscription not found");
            delete this.__subscription[params.id];
            return;
        }
718002
public function unsub($obj)
    {
        $this->detach($obj);
        if ($this->count() === 0) {
            if (($func = $this->deactCb) !== null) {
                $func($this);
            }
        }
        return $this;
    }
870758
public function unsubFromAll($obj)
    {
        foreach ($this->events as $event) {
            $event->unsub($obj);
        }
        return true;
    }
638170
function unsubscribeError(message, exceptionMessage, exceptionType) {
		reply(proto.writeUnsubscribeException(
			message.id, exceptionMessage, exceptionType));
		dequeueSubUnsubRequest(message.itemName);
		fireFirstSubUnsubEvent(message.itemName);
	}
908565
public <T extends DObject> void unsubscribeFromObject (int oid, Subscriber<T> target)
    {
        queueAction(oid, target, false);
    }