Gets the active subscribers for this list.
331785
def active(self, date="", page=1, page_size=1000, order_field="email", order_direction="asc", include_tracking_preference=False):
        """"""
        params = {
            "date": date,
            "page": page,
            "pagesize": page_size,
            "orderfield": order_field,
            "orderdirection": order_direction,
            "includetrackingpreference": include_tracking_preference,
        }
        response = self._get(self.uri_for("active"), params=params)
        return json_to_py(response)
385958
public function getListSubscriber($list, $subscriber)
	{
		$result = $this->client->get("lists/{$list}/subscribers/{$subscriber}");
		return $result ? new Resources\Subscriber($this, $result) : null;
	}
231667
public function subscribers()
    {
        return $this->morphToMany(config('follow.user_model'), config('follow.morph_prefix'), config('follow.followable_table'))
                    ->wherePivot('relation', '=', Follow::RELATION_SUBSCRIBE)
                    ->withPivot('followable_type', 'relation', 'created_at');
    }
631262
def members(self):
        
        if self._members is None:
            self.assert_bind_client()
            self._members = self.bind_client.get_club_members(self.id)
        return self._members
666670
function indexSubscribers() {
  const { subscribers = {} } = getComponentsSettings();

  return index({
    file: 'subscribers.js',
    config: {
      type: TYPE_SUBSCRIBERS,
      config: subscribers,
      exportsStart: 'export default [',
      exportsEnd: '];',
      isArray: true,
    },
    defaultContent: 'export default [];\n',
    ...getIndexLogTranslations(TYPE_SUBSCRIBERS),
  });
}
845259
public boolean subscriberLaunched() {
        boolean launched = true;
        for (int i = 0; i < numWorkers; i++) {
            launched = launched && subscriber[i].subscriberLaunched();
        }

        return launched;
    }
17924
public Observable<Page<SubscriptionMediaServiceInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<SubscriptionMediaServiceInner>>, Page<SubscriptionMediaServiceInner>>() {
                @Override
                public Page<SubscriptionMediaServiceInner> call(ServiceResponse<Page<SubscriptionMediaServiceInner>> response) {
                    return response.body();
                }
            });
    }
1189931
public List getSubscriptionList()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getSubscriptionList");

    List list;
    HashMap durableSubs = destinationManager.getDurableSubscriptionsTable();

    synchronized (durableSubs)
    {
      list = new ArrayList(durableSubs.keySet());
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getSubscriptionList", list);

    return list;
  }
635981
protected function getEventSubscribers()
    {
        $eventSubscribers = $this->getOption('event_subscribers');

        if (is_null($eventSubscribers) || !is_array($eventSubscribers)) {
            return;
        }

        return array_filter(
            $eventSubscribers,
            function ($subscriber) {
                return $subscriber instanceof EventSubscriber;
            }
        );
    }
314040
def list_subscribers(self, list_id):
        
        return [User(user._json) for user in self._client.list_subscribers(list_id=list_id)]
937647
function findSubscribers( self, eventName ) {
   const subscribers = [];
   const parts = eventName.split( TOPIC_SEPARATOR );
   const node = self.subscriberTree_;

   findSubscribersRecursively( node, parts, subscribers );
   subscribers.sort( ( a, b ) => {
      const aWeight = a.subscriptionWeight;
      const bWeight = b.subscriptionWeight;
      if( aWeight[ 0 ] === bWeight[ 0 ] ) {
         return bWeight[ 1 ] - aWeight[ 1 ];
      }

      return bWeight[ 0 ] - aWeight[ 0 ];
   } );

   return subscribers;
}
712888
public function subscriptions()
    {
        return $this->client->subscriptions->listFor($this, null, null, $this->getPresetOptions());
    }
697935
List<MemberState> getActiveMemberStates(Comparator<MemberState> comparator) {
    List<MemberState> activeMembers = new ArrayList<>(getActiveMemberStates());
    Collections.sort(activeMembers, comparator);
    return activeMembers;
  }
821847
public int getConsumersCount()
    {
    	synchronized (sessions)
		{
    		if (sessions.isEmpty())
    			return 0;
    
    		int total = 0;
    		Iterator<AbstractSession>sessionsIterator = sessions.values().iterator();
			while (sessionsIterator.hasNext())
			{
				AbstractSession session = sessionsIterator.next();
				total += session.getConsumersCount();
			}
			return total;
		}
    }
1195479
def subscribers(options = {})
      response = call_api_and_parse_response(:get, '/subscribers', {}, false)

      response['subscribers'].map { |s| Subscriber.new(s, self, options) }
    end
522988
def get_watchers(self, username, offset=0, limit=10):

        

        response = self._req('/user/watchers/{}'.format(username), {
            'offset' : offset,
            'limit' : limit
        })

        watchers = []

        for item in response['results']:
            w = {}
            w['user'] = User()
            w['user'].from_dict(item['user'])
            w['is_watching'] = item['is_watching']
            w['lastvisit'] = item['lastvisit']
            w['watch'] = {
                "friend" : item['watch']['friend'],
                "deviations" : item['watch']['deviations'],
                "journals" : item['watch']['journals'],
                "forum_threads" : item['watch']['forum_threads'],
                "critiques" : item['watch']['critiques'],
                "scraps" : item['watch']['scraps'],
                "activity" : item['watch']['activity'],
                "collections" : item['watch']['collections']
            }

            watchers.append(w)

        return {
            "results" : watchers,
            "has_more" : response['has_more'],
            "next_offset" : response['next_offset']
        }
990538
def subscribers(options = {})
      load
      return [] if info['push'].nil? || info['push']['subscribers'].nil?

      info['push']['subscribers'].map { |s| Subscriber.new(s, self, options) }
    end