Subscribe to the PlaceObject identified by _placeId and
call {@link #gotPlaceObject} with the result.
765719
protected void subscribeToPlace ()
    {
        _subber = new SafeSubscriber<PlaceObject>(_placeId, new Subscriber<PlaceObject>() {
            public void objectAvailable (PlaceObject object) {
                gotPlaceObject(object);
            }
            public void requestFailed (int oid, ObjectAccessException cause) {
                // aiya! we were unable to fetch our new place object; something is badly wrong
                log.warning("Aiya! Unable to fetch place object for new location", "plid", oid,
                            "reason", cause);
                // clear out our half initialized place info
                int placeId = _placeId;
                _placeId = -1;
                // let the kids know shit be fucked
                handleFailure(placeId, "m.unable_to_fetch_place_object");
            }
        });
        _subber.subscribe(_ctx.getDObjectManager());
    }
1013437
@Override
    public Object put(Object key, Object value) {
        return localMap.put(key, value);
    }
340602
def subscribe(self, obj, handler):
    """"""
    if not isinstance(obj, LutronEntity):
      raise InvalidSubscription("Subscription target not a LutronEntity")
    _LOGGER.warning("DEPRECATED: Subscribing via Lutron.subscribe is obsolete. "
                    "Please use LutronEntity.subscribe")
    if obj not in self._legacy_subscribers:
      self._legacy_subscribers[obj] = handler
      obj.subscribe(self._dispatch_legacy_subscriber, None)
74008
public Object get(String propName) {
        if (propName.equals("repositoryId")) {
            return getRepositoryId();
        }
        if (propName.equals("repositoryCheckPoint")) {
            return getRepositoryCheckPoint();
        }
        return null;
    }
591381
private boolean updateExistingObject(DBObject dbObj, Map<String, String> currScalarMap) {
        if (objectIsChangingShards(dbObj, currScalarMap)) {
            return updateShardedObjectMove(dbObj);
        } else {
            return updateObjectSameShard(dbObj, currScalarMap);
        }
    }
848198
public void didLeavePlace ()
    {
        // unsubscribe from our old place object
        if (_subber != null) {
            _subber.unsubscribe(_ctx.getDObjectManager());
            _subber = null;
        }

        // let the old controller know that things are going away
        if (_plobj != null && _controller != null) {
            try {
                _controller.didLeavePlace(_plobj);
            } catch (Exception e) {
                log.warning("Place controller choked in didLeavePlace", "plobj", _plobj, e);
            }
        }

        // and clear out other bits
        _plobj = null;
        _controller = null;
        _placeId = -1;
    }
225403
function (object, property, id) {
  this.subscription.subscribe(object, property, id);
  return this._get(object, property);
}
1247843
protected static <T extends DObject> void informObjectAvailable (Subscriber<T> sub, T obj)
    {
        try {
            sub.objectAvailable(obj);
        } catch (Exception e) {
            log.warning("Subscriber choked during object available",
                        "obj", StringUtil.safeToString(obj), "sub", sub, e);
        }
    }
84022
public void subscriber(String path,
                        @Pin ServiceRefAmp serviceRef,
                        Result<? super Cancel> result)
  {
    if (path.isEmpty()) {
      result.fail(new ServiceException(L.l("Invalid event location '{0}'", path)));
      return;
    }

    String address = address(path);

    EventNodeAsset node = lookupPubSubNode(address);

    Cancel cancel = node.subscribeImpl(serviceRef);

    result.ok(cancel);
  }
1077113
public static void addPropertiesForDataMining(WarningPropertySet<WarningProperty> propertySet, ClassContext classContext,
            Method method, Location location) {
        addReceiverObjectType(propertySet, classContext, method, location);
        addRecentlyCalledMethods(propertySet, classContext, method, location);
    }
547184
public Observable<UsagesListResultInner> listUsagesAsync(String location) {
        return listUsagesWithServiceResponseAsync(location).map(new Func1<ServiceResponse<UsagesListResultInner>, UsagesListResultInner>() {
            @Override
            public UsagesListResultInner call(ServiceResponse<UsagesListResultInner> response) {
                return response.body();
            }
        });
    }
74318
static <T> void subscribe(Subscriber<? super T> s, Iterator<? extends T> it) {
        if (it == null) {
            error(s, new NullPointerException("The iterator is null"));
            return;
        }

        boolean b;

        try {
            b = it.hasNext();
        } catch (Throwable e) {
            error(s, e);
            return;
        }

        if (!b) {
           complete(s);
            return;
        }

        s.onSubscribe(new IterableSubscription<T>(s, it));

    }
910882
def subscribeContext(self, objectID, domain, dist, varIDs=(
            tc.VAR_ROAD_ID, tc.VAR_LANEPOSITION), begin=0, end=2**31 - 1):
        
        Domain.subscribeContext(
            self, objectID, domain, dist, varIDs, begin, end)
853783
function(object, object_id, callback) {
    if (typeof object_id === 'function') callback = object_id;
    request.post(this._endpoint, {
        form: this.subscribeParams(object, object_id)
      }, function(error, response, body) {
        if (!error && response.statusCode == 200) {
          var res = JSON.parse(body);
          callback(null, res.data);
        } else {
          callback(error, null);
        }
      }
    );
  }
550445
public Observable<UsageListResultInner> listAsync(String location) {
        return listWithServiceResponseAsync(location).map(new Func1<ServiceResponse<UsageListResultInner>, UsageListResultInner>() {
            @Override
            public UsageListResultInner call(ServiceResponse<UsageListResultInner> response) {
                return response.body();
            }
        });
    }
126810
function(json){
  
  // Protect against forgetting the new keyword when calling the constructor
  if(!(this instanceof PlaceReference)){
    return new PlaceReference(json);
  }
  
  // If the given object is already an instance then just return it. DON'T copy it.
  if(GedcomX.ExtensibleData.isInstance(json)){
    return json;
  }
  
  this.init(json);
}
1064509
def connect(self, object, callback):
		""""""
		return subscription(self.map.setdefault(object, []), callback)