Get the names of all of the <code>{@link org.quartz.Calendar}</code> s in the <code>JobStore</code>.
@param jedis a thread-safe Redis connection
@return the names of all calendars or an empty list if no calendars exist
330217
public List<String> getCalendarNames(T jedis){
        final Set<String> calendarsSet = jedis.smembers(redisSchema.calendarsSet());
        List<String> calendars = new ArrayList<>(calendarsSet.size());
        for (String group : calendarsSet) {
            calendars.add(redisSchema.calendarName(group));
        }
        return calendars;
    }
1292218
public JSONArray names() {
      verifyIsNull();
      JSONArray ja = new JSONArray();
      Iterator keys = keys();
      while( keys.hasNext() ){
         ja.element( keys.next() );
      }
      return ja;
   }
602035
@Override
    public Collection<String> resumeTriggers(GroupMatcher<TriggerKey> matcher, JedisCluster jedis) throws JobPersistenceException {
        Set<String> resumedTriggerGroups = new HashSet<>();
        if (matcher.getCompareWithOperator() == StringMatcher.StringOperatorName.EQUALS) {
            final String triggerGroupSetKey = redisSchema.triggerGroupSetKey(new TriggerKey("", matcher.getCompareToValue()));
            jedis.srem(redisSchema.pausedJobGroupsSet(), triggerGroupSetKey);
            Set<String> triggerHashKeysResponse = jedis.smembers(triggerGroupSetKey);
            for (String triggerHashKey : triggerHashKeysResponse) {
                OperableTrigger trigger = retrieveTrigger(redisSchema.triggerKey(triggerHashKey), jedis);
                resumeTrigger(trigger.getKey(), jedis);
                resumedTriggerGroups.add(trigger.getKey().getGroup());
            }
        } else {
            for (final String triggerGroupSetKey : jedis.smembers(redisSchema.triggerGroupsSet())) {
                if (matcher.getCompareWithOperator().evaluate(redisSchema.triggerGroup(triggerGroupSetKey), matcher.getCompareToValue())) {
                    resumedTriggerGroups.addAll(resumeTriggers(GroupMatcher.triggerGroupEquals(redisSchema.triggerGroup(triggerGroupSetKey)), jedis));
                }
            }
        }
        return resumedTriggerGroups;
    }
1007572
public void setScheduledActionNames(java.util.Collection<String> scheduledActionNames) {
        if (scheduledActionNames == null) {
            this.scheduledActionNames = null;
            return;
        }

        this.scheduledActionNames = new java.util.ArrayList<String>(scheduledActionNames);
    }
1015470
ProviderList getJarList(String[] jarClassNames) {
        List<ProviderConfig> newConfigs = new ArrayList<>();
        for (String className : jarClassNames) {
            ProviderConfig newConfig = new ProviderConfig(className);
            for (ProviderConfig config : configs) {
                // if the equivalent object is present in this provider list,
                // use the old object rather than the new object.
                // this ensures that when the provider is loaded in the
                // new thread local list, it will also become available
                // in this provider list
                if (config.equals(newConfig)) {
                    newConfig = config;
                    break;
                }
            }
            newConfigs.add(newConfig);
        }
        ProviderConfig[] configArray = newConfigs.toArray(PC0);
        return new ProviderList(configArray, false);
    }
945148
public void clearAllSchedulingData(T jedis) throws JobPersistenceException, ClassNotFoundException {
        // delete triggers
        for (String jobHashKey : jedis.smembers(redisSchema.jobsSet())) {
            removeJob(redisSchema.jobKey(jobHashKey), jedis);
        }

        // delete remaining jobs
        for (String triggerHashKey : jedis.smembers(redisSchema.triggersSet())) {
            removeTrigger(redisSchema.triggerKey(triggerHashKey), jedis);
        }

        // remove calendars
        for (String calendarHashKey : jedis.smembers(redisSchema.calendarsSet())) {
            removeCalendar(redisSchema.calendarName(calendarHashKey), jedis);
        }
    }
995927
public Collection<String> getAllInstanceDataSourceNames() {
        Collection<String> result = new LinkedList<>();
        for (Entry<String, DataSourceMetaData> entry : dataSourceMetaDataMap.entrySet()) {
            if (!isExisted(entry.getKey(), result)) {
                result.add(entry.getKey());
            }
        }
        return result;
    }
884943
public ICommonsSet <JobKey> getJobKeys (final GroupMatcher <JobKey> matcher) throws SchedulerException
  {
    validateState ();

    return m_aResources.getJobStore ().getJobKeys (_getOrDefault (matcher));
  }
28863
@Override
    public List<JobInstance> getJobs(Query query)
    {
        return JqmClientFactory.getClient().getJobs(query);
    }
883856
public JsonArray names() throws JsonException {
        return nameValuePairs.isEmpty()
                ? null
                : new JsonArray(new ArrayList<String>(nameValuePairs.keySet()));
    }
1266248
public final List<SequenceLabel> getNames(final String[] tokens) {

    final Span[] origSpans = nercToSpans(tokens);
    final Span[] neSpans = SequenceLabelerME.dropOverlappingSpans(origSpans);
    final List<SequenceLabel> names = getNamesFromSpans(neSpans, tokens);
    return names;
  }
1366875
public static Map<String, String> getSchedulerNames(){
		Map<String, String> schedulerNames = new HashMap<String, String>();
		MySchedule mySchedule = MySchedule.getInstance();
		for(String settingsName: mySchedule.getSchedulerSettingsNames()){
			SchedulerSettings settings = mySchedule.getSchedulerSettings(settingsName);
			schedulerNames.put(settingsName, settings.getSchedulerFullName());
		}
		return schedulerNames;
	}
826766
public static void doBatchEnqueue(final Jedis jedis, final String namespace, final String queue, final List<String> jobJsons) {
        Pipeline pipelined = jedis.pipelined();
        pipelined.sadd(JesqueUtils.createKey(namespace, QUEUES), queue);
        for (String jobJson : jobJsons) {
            pipelined.rpush(JesqueUtils.createKey(namespace, QUEUE, queue), jobJson);
        }
        pipelined.sync();
    }
177337
public static List<Long> getDelayMillsList(String schedulePlans) {
		List<Long> result = new ArrayList<>();
		String[] plans = StringUtils.split(schedulePlans, ',');
		for (String plan : plans) {
			result.add(getDelayMillis(plan));
		}
		return result;
	}
850803
public java.util.List<String> getAlarmNames() {
        if (alarmNames == null) {
            alarmNames = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return alarmNames;
    }
1149072
List<String> getNames() {
     if (addrList == null)
       return jmfNames;

     // Create a readonly list that extracts the 'names' information from the main list
     return new AbstractList<String>() {
       public int size() {
         return addrList.size();
       }
       public String get(int index) {
         return ((JsDestinationAddress)addrList.get(index)).getDestinationName();
       }
     };
   }
1219661
def get_all_schedules
      schedules = {}

      if SidekiqScheduler::RedisManager.schedule_exist?
        SidekiqScheduler::RedisManager.get_all_schedules.tap do |h|
          h.each do |name, config|
            schedules[name] = JSON.parse(config)
          end
        end
      end

      schedules
    end