/* (non-Javadoc)
@see com.ibm.websphere.logging.hpel.reader.RepositoryReader#getLogLists(com.ibm.websphere.logging.hpel.reader.RepositoryPointer)
542070
public Iterable<ServerInstanceLogRecordList> getLogLists(
			RepositoryPointer after) throws LogRepositoryException {
		logger.entering(thisClass, "getLogLists", new Object[]{after});
		
		LogQueryBean query = new LogQueryBean();
		Iterable<ServerInstanceLogRecordList> result = getLogLists(after, query);
		
		logger.exiting(thisClass, "getLogLists", result);
		return result;
	}
1057505
List<Message> getList() {
        if (mode == StorageMode.MAP) {
            synchronized (this) {
                if (mode == StorageMode.MAP) {
                    listData = convertMapToList(mapData);
                    mode = StorageMode.BOTH;
                }
            }
        }
        return Collections.unmodifiableList(listData);
    }
180325
public Collection<String> getPropertyNames() throws RepositoryException
   {

      HashSet<String> props = new HashSet<String>();
      for (HierarchicalProperty p : properties)
      {
         props.add(p.getStringName());
      }
      return props;

      // PropertyIterator iter = node.getProperties();
      // ArrayList<String> props = new ArrayList<String>();
      // while (iter.hasNext()) {
      // String name = iter.nextProperty().getName();
      // if (!"jcr:primaryType".equals(name) && !"jcr:mixinTypes".equals(name)
      // && !"jcr:data".equals(name) && !"jcr:uuid".equals(name))
      // props.add(name);
      // }
      // return props;
   }
332581
public java.util.List<InputLogEvent> getLogEvents() {
        if (logEvents == null) {
            logEvents = new com.amazonaws.internal.SdkInternalList<InputLogEvent>();
        }
        return logEvents;
    }
898693
private static List<Method> getMethodsWithAnnotation(Class<?> clazz, Class<? extends Annotation> annotation, Logger log) {
    List<Method> annotatedMethods = new ArrayList<Method>();
    Method classMethods[] = clazz.getDeclaredMethods();
    for(Method classMethod : classMethods) {
      if(classMethod.isAnnotationPresent(annotation) && classMethod.getParameterTypes().length == 0) {
        if(!containsMethod(classMethod, annotatedMethods)) {
          annotatedMethods.add(classMethod);
        }
      }
    }
    Collections.sort(annotatedMethods, new Comparator<Method> () {

      @Override
      public int compare(Method method1, Method method2) {
        return method1.getName().compareTo(method2.getName());
      }
    });
    return annotatedMethods;
  }
692920
public static List<FieldDefinition> getKeys(final String repositoryName) {
        final List<RepositoryDefinition> repositoryDefs = getRepositoryDefinitions();
        for (final RepositoryDefinition repositoryDefinition : repositoryDefs) {
            if (StringUtils.equals(repositoryName, repositoryDefinition.getName())) {
                return repositoryDefinition.getKeys();
            }
        }

        return null;
    }
1243546
public List<GcEvent> getLogs() {
    final List<GcEvent> logs = new ArrayList<>();
    for (CircularBuffer<GcEvent> buffer : gcLogs.values()) {
      logs.addAll(buffer.toList());
    }
    Collections.sort(logs, GcEvent.REVERSE_TIME_ORDER);
    return logs;
  }
699893
public static List<RepositoryDefinition> getRepositoryDefinitions() {
        if (null == repositoryDefinitions) {
            try {
                initRepositoryDefinitions();
            } catch (final Exception e) {
                LOGGER.log(Level.ERROR, "Init repository definitions failed", e);
            }
        }

        return repositoryDefinitions;
    }
373394
@SuppressWarnings("unchecked")
    public List<RepositoryType> getAllTypes()
    {
        final Criteria crit = sessionService.getSession().createCriteria(RepositoryType.class);
        List<RepositoryType> list = crit.list();
		HibernateLazyInitializer.initCollection(list);
		return list;
	}
509333
@Route(method = HttpMethod.GET, uri = "/monitor/logs/loggers")
    public Result loggers() {
        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
        List<LoggerModel> loggers = new ArrayList<>();
        for (Logger logger : context.getLoggerList()) {
            loggers.add(new LoggerModel(logger));
        }
        return ok(loggers).json();
    }
628221
public LogStreamResponse getLogs(Log.LogRequestBuilder logRequest) {
        return connection.execute(new Log(logRequest), apiKey);
    }
334918
public RepositoryLogRecord getRecord(RepositoryPointer location) {
		if (!(location instanceof RepositoryPointerImpl)) {
			return null;
		}
		RepositoryPointerImpl real = (RepositoryPointerImpl)location;
		long pos = real.getRecordOffset();
		File file = fileBrowser.findFile(real);
		if (pos < 0 || file == null) {
			return null;
		}
		OneFileRecordIterator current = new OneFileRecordIterator(file, -1, new AllAcceptVerifier());
		RepositoryLogRecord rec = null;
		if (current.setPosition(pos)) {
			rec = current.next();
		}
		current.close();
		if (rec != null && real.equals(rec.getRepositoryPointer())) {
			return rec;
		} 		
		
		return null;
		
	}
833069
@Override
	public List<IXADataRecorder> readIncompleteTransactions() {
		List<IXADataRecorder> messageSequences = new ArrayList<IXADataRecorder>();
		// recover all loggers ....
		try {
			
			IXARecorderRecovery recorderRecovery= new XARecorderRecovery(this.loggerFactory);

			Set<IXADataRecorder> xaDataRecorders = recorderRecovery.getRecoveredXADataRecorders();

			for (Iterator<IXADataRecorder> iterator = xaDataRecorders.iterator(); iterator.hasNext();) {
				IXADataRecorder dataRecorder = iterator.next();

				if (!dataRecorder.isEmpty()) {
					messageSequences.add(dataRecorder);
				} else {
					dataRecorder.destroy();
				}

			}
			return messageSequences;
		} catch (Exception e) {
			throw new DelegatedRuntimeException(e);
		}
	}
632657
@Override
    public LogRepositoryBrowser find(RepositoryPointerImpl location, boolean ignoreTimestamp) {
        String[] instanceIds = location.getInstanceIds();
        if (instanceIds.length == 0) {
            logger.logp(Level.SEVERE, className, "find", "HPEL_NotRepositoryLocation");
            return null;
        }

        String locProcId = ignoreTimestamp ? parsePIDandLabel(instanceIds[0]) : instanceIds[0];
        LogRepositoryBrowser result = null;
        File[] files = listFiles(instanceFilter);
        if (files == null) {
            return null;
        }
        for (File file : files) {
            String curProcId = ignoreTimestamp ? parsePIDandLabel(file.getName()) : file.getName();
            if (locProcId.equalsIgnoreCase(curProcId)) {
                result = new LogRepositoryBrowserImpl(file, new String[] { file.getName() });
                for (int i = 1; i < instanceIds.length && result != null; i++) {
                    Map<String, LogRepositoryBrowser> map = result.getSubProcesses();
                    result = map.get(instanceIds[i]);
                }
            }
        }

        return result;
    }
590368
def _get_loggers():
    """"""
    from .. import loader
    modules = loader.get_package_modules('logger')
    return list(loader.get_plugins(modules, [_Logger]))
247801
public List<Descriptor<RepositoryBrowser<?>>> getBrowserDescriptors() {
        if(repositoryBrowser==null)     return Collections.emptyList();
        return RepositoryBrowsers.filter(repositoryBrowser);
    }
681702
public java.util.List<String> getEnableLogTypes() {
        if (enableLogTypes == null) {
            enableLogTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return enableLogTypes;
    }