<p>
The log events.
</p>

@return The log events.
332581
public java.util.List<InputLogEvent> getLogEvents() {
        if (logEvents == null) {
            logEvents = new com.amazonaws.internal.SdkInternalList<InputLogEvent>();
        }
        return logEvents;
    }
31963
private List<Logger> getLoggers() {

        // list of all loggers
        List<Logger> definedLoggers = new ArrayList<Logger>();
        // list of all parent loggers
        List<Logger> packageLoggers = new ArrayList<Logger>();
        LoggerContext logContext = (LoggerContext) LogManager.getContext(false);
        Iterator<Logger> it_curentlogger = logContext.getLoggers().iterator();
        // get all current loggers
        while (it_curentlogger.hasNext()) {
            // get the logger
            Logger log = it_curentlogger.next();
            String logname = log.getName();
            String[] prefix = buildsufix(logname);
            // create all possible package logger from given logger name
            for (int i = 0; i < prefix.length; i++) {
                // get the name of the logger without the prefix
                String temp = log.getName().replace(prefix[i], "");
                // if the name has suffix
                if (temp.length() > 1) {
                    temp = temp.substring(1);
                }
                if (temp.lastIndexOf(".") > 1) {
                    // generate new logger with "org.opencms" prefix and the next element
                    // between the points e.g.: "org.opencms.search"
                    Logger temp_logger = getLoggerImpl(prefix[i] + "." + temp.substring(0, temp.indexOf(".")));
                    // activate the heredity so the logger get the appender from parent logger
                    temp_logger.setAdditive(true);
                    // add the logger to the packageLoggers list if it is not part of it
                    if (!packageLoggers.contains(temp_logger)) {
                        packageLoggers.add(temp_logger);
                    }
                }
            }
            definedLoggers.add(log);

        }

        Iterator<Logger> it_logger = packageLoggers.iterator();
        // iterate about all packageLoggers
        while (it_logger.hasNext()) {
            Logger temp = it_logger.next();
            // check if the logger is part of the logger list
            if (!definedLoggers.contains(temp)) {
                // add the logger to the logger list
                definedLoggers.add(temp);
            }
        }

        // sort all loggers by name
        Collections.sort(definedLoggers, new Comparator<Object>() {

            public int compare(Logger o1, Logger o2) {

                return String.CASE_INSENSITIVE_ORDER.compare(o1.getName(), o2.getName());
            }

            public int compare(Object obj, Object obj1) {

                return compare((Logger)obj, (Logger)obj1);
            }

        });
        // return all loggers
        return definedLoggers;
    }
444250
public List<String> getEventTypes() {
        ArrayList<String> allEvents = new ArrayList<>();
        if (isDelivered()) {
            allEvents.add(MessageEvent.DELIVERED);
        }
        if (!isMessageEventRequest() && isCancelled()) {
            allEvents.add(MessageEvent.CANCELLED);
        }
        if (isComposing()) {
            allEvents.add(MessageEvent.COMPOSING);
        }
        if (isDisplayed()) {
            allEvents.add(MessageEvent.DISPLAYED);
        }
        if (isOffline()) {
            allEvents.add(MessageEvent.OFFLINE);
        }
        return allEvents;
    }
482510
private LoggingEvent buildEvent() {
    if (currentMap.size() == 0) {
      if (additionalLines.size() > 0) {
        for (Iterator iter = additionalLines.iterator();iter.hasNext();) {
          getLogger().info("found non-matching line: " + iter.next());
        }
      }
      additionalLines.clear();
      return null;
    }
    //the current map contains fields - build an event
    int exceptionLine = getExceptionLine();
    String[] exception = buildException(exceptionLine);

    //messages are listed before exceptions in additionallines
    if (additionalLines.size() > 0 && exception.length > 0) {
      currentMap.put(MESSAGE, buildMessage((String) currentMap.get(MESSAGE),
          exceptionLine));
    }
    LoggingEvent event = convertToEvent(currentMap, exception);
    currentMap.clear();
    additionalLines.clear();
    return event;
  }
969599
public java.util.List<ListenerDescription> getListenerDescriptions() {
        if (listenerDescriptions == null) {
            listenerDescriptions = new com.amazonaws.internal.SdkInternalList<ListenerDescription>();
        }
        return listenerDescriptions;
    }
251086
public List<Pair<UIEvent, Table>> readEvents() throws IOException {
        //TODO eventually we'll support working out the offset for files that were not written in this session
        Preconditions.checkState(endStaticInfoOffset >= 0, "Cannot read events - have not written end of static info marker");
        return readEvents(endStaticInfoOffset);
    }
1341050
protected String prepareEventHandlers() {
		StringBuffer handlers = new StringBuffer();

		prepareMouseEvents(handlers);
		prepareKeyEvents(handlers);

		return handlers.toString();
	}
585047
@Override
    public LogProperties logProperties() {
        if (tc.isDebugEnabled())
            Tr.debug(tc, "logProperties", _customLogProperties);
        return _customLogProperties;
    }
1264106
public java.util.List<LifecycleHook> getLifecycleHooks() {
        if (lifecycleHooks == null) {
            lifecycleHooks = new com.amazonaws.internal.SdkInternalList<LifecycleHook>();
        }
        return lifecycleHooks;
    }
877158
public java.util.List<LifecycleEvent> getLifecycleEvents() {
        if (lifecycleEvents == null) {
            lifecycleEvents = new com.amazonaws.internal.SdkInternalList<LifecycleEvent>();
        }
        return lifecycleEvents;
    }
519325
public Logger logger() {
        if (logger == null) {
            logger = LoggerFactory.getLogger(this.getClass().getName());
        }
        return logger;
    }
553687
public java.util.List<EventSubscription> getEventSubscriptionsList() {
        if (eventSubscriptionsList == null) {
            eventSubscriptionsList = new com.amazonaws.internal.SdkInternalList<EventSubscription>();
        }
        return eventSubscriptionsList;
    }
887108
public java.util.List<LogStream> getLogStreams() {
        if (logStreams == null) {
            logStreams = new com.amazonaws.internal.SdkInternalList<LogStream>();
        }
        return logStreams;
    }
1357197
def events(self):
        
        if self._events is None:
            self._events = EventList(self)
        return self._events
1112881
public SynchronizedCollection<EventListener> getListeners() {
		final Object mutex = mutex();
		synchronized (mutex) {
			return Collections3.synchronizedCollection(this.listeners.values(), mutex);
		}
	}
701677
public java.util.List<LogSubscription> getLogSubscriptions() {
        if (logSubscriptions == null) {
            logSubscriptions = new com.amazonaws.internal.SdkInternalList<LogSubscription>();
        }
        return logSubscriptions;
    }
340197
public List<TaskHistoricalEvent> getHistoricalEvents() {
        List<TaskHistoricalEvent> result = new ArrayList<TaskHistoricalEvent>();
        List<TaskHistoricalEventType> historicalEventTypes = getContent()
                .getHistoricalEventTypes();

        if (historicalEventTypes != null) {
            for (TaskHistoricalEventType taskHistoricalEventType : historicalEventTypes) {
                String message = taskHistoricalEventType.getMessage();
                if ((message != null) && (message.isEmpty())) {
                    message = null;
                }
                TaskHistoricalEvent taskHistoricalEvent = new TaskHistoricalEvent(
                        taskHistoricalEventType.getCode(), message,
                        taskHistoricalEventType.getTimeStamp());
                result.add(taskHistoricalEvent);
            }
        }

        return result;
    }