subscribe(list(integer), double, double) -> None

        Subscribe to one or more simulation values for the given interval.
16803
def subscribe(self, varIDs=(tc.VAR_DEPARTED_VEHICLES_IDS,), begin=0, end=2**31 - 1):
        
        Domain.subscribe(self, "", varIDs, begin, end)
1328250
function (fn, create, update) {
  var subscriber = new Subscription(fn, update, this);

  // Immediately alias the starting value.
  subscriber.value = subscriber.execute();
  Utils.isFunction(create) && (subscriber.value = create(subscriber.value));

  return subscriber;
}
963122
def listen_to_event_updates():
    """"""
    def callback(event):
        print('Event:', event)

    client.create_event_subscription(instance='simulator', on_data=callback)

    sleep(5)
884930
def auto_subscribe(self, app_manager):
        """"""
        for handler in app_manager.handler_classes:
            app_manager.subscribe(handler.channel(), self)
323490
private static int toInterval(String interval) throws ScheduleException {
	interval = interval.trim().toLowerCase();
	int i = Caster.toIntValue(interval, 0);
	if (i == 0) {
	    interval = interval.trim();
	    if (interval.equals("once")) return INTERVAL_ONCE;
	    else if (interval.equals("daily")) return INTERVAL_DAY;
	    else if (interval.equals("day")) return INTERVAL_DAY;
	    else if (interval.equals("monthly")) return INTERVAL_MONTH;
	    else if (interval.equals("month")) return INTERVAL_MONTH;
	    else if (interval.equals("weekly")) return INTERVAL_WEEK;
	    else if (interval.equals("week")) return INTERVAL_WEEK;
	    throw new ScheduleException("invalid interval definition [" + interval + "], valid values are [once,daily,monthly,weekly or number]");
	}
	if (i < 10) {
	    throw new ScheduleException("interval must be at least 10");
	}
	return i;
    }
1099894
function autoSubscribe(args) {
  var rtm = args.rtm;
  var listSubscriptions = args.listSubscriptions;
  var filterFn = args.filterFn || _autoSubscribeDefaultFilterFn;
  var subscriptionLoadLimit = 50;

  _observeSubscriptionSyncEvents({
    rtm: rtm,
    filterFn: filterFn
  });

  return listSubscriptions({limit: subscriptionLoadLimit}).then(function(list) {
    return _fetchAllReadSubscriptions({
      list: list,
      loadMore: listSubscriptions,
      batchSize: subscriptionLoadLimit
    }).then(function(fetchedSubscriptions) {
      var subscriptions = Array.prototype.concat.apply(
        [],
        fetchedSubscriptions
      );
      return Promise.all(subscriptions.map(filterFn)).then(function(
        filterResults
      ) {
        var promisedSubscriptions = [];
        filterResults.forEach(function(canSubscribe, subscriptionIndex) {
          if (canSubscribe) {
            promisedSubscriptions.push(
              rtm.subscribe({
                channel: subscriptions[subscriptionIndex].channelId
              })
            );
          }
        });

        return Promise.all(promisedSubscriptions);
      });
    });
  });
}
743500
public void setInterval(Interval interval) {
        if (interval == null) {
            interval = INTERVAL_FACTORY.getInstance();
        }
        this.interval = interval;
    }
618250
function subscribe(message) {
		reply(proto.writeSubscribe(message.id));
		subscritions[message.itemName] = message.id;
		if (!isSnapshotAvailable(message.itemName)) {
			notify(proto.writeEndOfSnapshot(message.id, message.itemName));
		}
		dequeueSubUnsubRequest(message.itemName);
		fireFirstSubUnsubEvent(message.itemName);
	}
158512
def insert(self, index, x):
        
        self.real_list.insert(index, x)
        self.observer(UpdateType.CREATED, x, index)
1361410
def subscribe(self, *, create_task=True, **params):
        
        if create_task and not self.task:
            self.task = asyncio.ensure_future(self.run(**params))
        return self.channel.subscribe()
445359
def __set_interval(self, value):
        '''
        
        '''
        if not isinstance(self, Interval):
            raise ValueError("'value' must be of type Interval")

        self.__interval = value
906716
def set_observable(self,tseq,qseq):
    
    tnt = None
    qnt = None
    if len(tseq) > 0: tnt = tseq[0]
    if len(qseq) > 0: qnt = qseq[0]
    self._observable.set(len(tseq),len(qseq),tnt,qnt)
862500
def subscribe(&blk)
      pres = connection.presence_stanza('to'=>jid.bare, 'type' => 'subscribe')
      connection.send_stanza pres, &blk
    end
1202346
def subscribe(caller = nil, &block)
      if block_given?
        notify_when = block.call(state)
        @listeners << { obj: block.binding.receiver, notify_when: notify_when }
      else
        @listeners << { obj: caller }
      end
    end
1067800
def subscribe(self, topic, channel):
        """"""
        self.send(nsq.subscribe(topic, channel))
587473
def subscribe_param():
    """"""
    def print_data(data):
        for parameter in data.parameters:
            print(parameter)

    processor.create_parameter_subscription('/YSS/SIMULATOR/BatteryVoltage2',
                                            on_data=print_data)
1216611
function interval(period, scheduler) {
    if (period === void 0) {
        period = 0;
    }
    if (scheduler === void 0) {
        scheduler = _scheduler_async__WEBPACK_IMPORTED_MODULE_1__["async"];
    }
    if (!Object(_util_isNumeric__WEBPACK_IMPORTED_MODULE_2__["isNumeric"])(period) || period < 0) {
        period = 0;
    }
    if (!scheduler || typeof scheduler.schedule !== 'function') {
        scheduler = _scheduler_async__WEBPACK_IMPORTED_MODULE_1__["async"];
    }
    return new _Observable__WEBPACK_IMPORTED_MODULE_0__["Observable"](function (subscriber) {
        subscriber.add(scheduler.schedule(dispatch, period, { subscriber: subscriber, counter: 0, period: period }));
        return subscriber;
    });
}