001/*
002 * Copyright 2009-2022 Ping Identity Corporation
003 * All Rights Reserved.
004 */
005/*
006 * Copyright 2009-2022 Ping Identity Corporation
007 *
008 * Licensed under the Apache License, Version 2.0 (the "License");
009 * you may not use this file except in compliance with the License.
010 * You may obtain a copy of the License at
011 *
012 *    http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing, software
015 * distributed under the License is distributed on an "AS IS" BASIS,
016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017 * See the License for the specific language governing permissions and
018 * limitations under the License.
019 */
020/*
021 * Copyright (C) 2009-2022 Ping Identity Corporation
022 *
023 * This program is free software; you can redistribute it and/or modify
024 * it under the terms of the GNU General Public License (GPLv2 only)
025 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
026 * as published by the Free Software Foundation.
027 *
028 * This program is distributed in the hope that it will be useful,
029 * but WITHOUT ANY WARRANTY; without even the implied warranty of
030 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
031 * GNU General Public License for more details.
032 *
033 * You should have received a copy of the GNU General Public License
034 * along with this program; if not, see <http://www.gnu.org/licenses>.
035 */
036package com.unboundid.ldap.sdk.unboundidds.logs;
037
038
039
040import java.util.Collections;
041import java.util.LinkedList;
042import java.util.List;
043import java.util.StringTokenizer;
044
045import com.unboundid.ldap.sdk.ResultCode;
046import com.unboundid.ldap.sdk.unboundidds.controls.AssuredReplicationLocalLevel;
047import com.unboundid.ldap.sdk.unboundidds.controls.
048            AssuredReplicationRemoteLevel;
049import com.unboundid.util.NotExtensible;
050import com.unboundid.util.NotMutable;
051import com.unboundid.util.NotNull;
052import com.unboundid.util.Nullable;
053import com.unboundid.util.ThreadSafety;
054import com.unboundid.util.ThreadSafetyLevel;
055
056
057
058/**
059 * This class provides a data structure that holds information about a log
060 * message that may appear in the Directory Server access log about the result
061 * of an add operation processed by the Directory Server.
062 * <BR>
063 * <BLOCKQUOTE>
064 *   <B>NOTE:</B>  This class, and other classes within the
065 *   {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
066 *   supported for use against Ping Identity, UnboundID, and
067 *   Nokia/Alcatel-Lucent 8661 server products.  These classes provide support
068 *   for proprietary functionality or for external specifications that are not
069 *   considered stable or mature enough to be guaranteed to work in an
070 *   interoperable way with other types of LDAP servers.
071 * </BLOCKQUOTE>
072 */
073@NotExtensible()
074@NotMutable()
075@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
076public class AddResultAccessLogMessage
077       extends AddRequestAccessLogMessage
078       implements OperationResultAccessLogMessage
079{
080  /**
081   * The serial version UID for this serializable class.
082   */
083  private static final long serialVersionUID = -6660463102516326216L;
084
085
086
087  // The assured replication level to use for local servers.
088  @Nullable private final AssuredReplicationLocalLevel
089       assuredReplicationLocalLevel;
090
091  // The assured replication level to use for remote servers.
092  @Nullable private final AssuredReplicationRemoteLevel
093       assuredReplicationRemoteLevel;
094
095  // Indicates whether the response was known to be delayed by replication
096  // assurance processing.
097  @Nullable private final Boolean responseDelayedByAssurance;
098
099  // Indicates whether the any uncached data was accessed in the course of
100  // processing this operation.
101  @Nullable private final Boolean uncachedDataAccessed;
102
103  // The processing time for the operation.
104  @Nullable private final Double processingTime;
105
106  // The queue time for the operation.
107  @Nullable private final Double queueTime;
108
109  // The port of the backend server to which the request has been forwarded.
110  @Nullable private final Integer targetPort;
111
112  // The list of indexes for which keys near the index entry limit were accessed
113  // while processing the operation.
114  @NotNull private final List<String> indexesWithKeysAccessedNearEntryLimit;
115
116  // The list of indexes for which keys over the index entry limit were accessed
117  // while processing the operation.
118  @NotNull private final List<String> indexesWithKeysAccessedOverEntryLimit;
119
120  // The list of privileges required for processing the operation that the
121  // requester did not have.
122  @NotNull private final List<String> missingPrivileges;
123
124  // The list of privileges used during the course of processing the operation
125  // before an alternate authorization identity was assigned.
126  @NotNull private final List<String> preAuthZUsedPrivileges;
127
128  // The list of referral URLs for the operation.
129  @NotNull private final List<String> referralURLs;
130
131  // The list of response control OIDs for the operation.
132  @NotNull private final List<String> responseControlOIDs;
133
134  // The list of servers accessed while processing the operation.
135  @NotNull private final List<String> serversAccessed;
136
137  // The list of privileges used during the course of processing the operation.
138  @NotNull private final List<String> usedPrivileges;
139
140  // The assured replication timeout, in milliseconds.
141  @Nullable private final Long assuredReplicationTimeoutMillis;
142
143  // The number of intermediate response messages returned to the client.
144  @Nullable private final Long intermediateResponsesReturned;
145
146  // The result code for the operation.
147  @Nullable private final ResultCode resultCode;
148
149  // Additional information about the operation result.
150  @Nullable private final String additionalInformation;
151
152  // The alternate authorization DN for the operation.
153  @Nullable private final String authzDN;
154
155  // The diagnostic message for the operation.
156  @Nullable private final String diagnosticMessage;
157
158  // The intermediate client result for the operation.
159  @Nullable private final String intermediateClientResult;
160
161  // The matched DN for the operation.
162  @Nullable private final String matchedDN;
163
164  // The replication change ID for the operation.
165  @Nullable private final String replicationChangeID;
166
167  // The address of the backend server to which the request has been forwarded.
168  @Nullable private final String targetHost;
169
170  // The protocol used to forward the request to the backend server.
171  @Nullable private final String targetProtocol;
172
173  // The DN of the soft-deleted entry from which the resulting entry was
174  // undeleted.
175  @Nullable private final String undeleteFromDN;
176
177
178
179  /**
180   * Creates a new add result access log message from the provided message
181   * string.
182   *
183   * @param  s  The string to be parsed as an add result access log message.
184   *
185   * @throws  LogException  If the provided string cannot be parsed as a valid
186   *                        log message.
187   */
188  public AddResultAccessLogMessage(@NotNull final String s)
189         throws LogException
190  {
191    this(new LogMessage(s));
192  }
193
194
195
196  /**
197   * Creates a new add result access log message from the provided message
198   * string.
199   *
200   * @param  m  The log message to be parsed as an add result access log
201   *            message.
202   */
203  public AddResultAccessLogMessage(@NotNull final LogMessage m)
204  {
205    super(m);
206
207    diagnosticMessage        = getNamedValue("message");
208    additionalInformation    = getNamedValue("additionalInfo");
209    matchedDN                = getNamedValue("matchedDN");
210    processingTime           = getNamedValueAsDouble("etime");
211    queueTime                = getNamedValueAsDouble("qtime");
212    intermediateClientResult = getNamedValue("from");
213    authzDN                  = getNamedValue("authzDN");
214    replicationChangeID      = getNamedValue("replicationChangeID");
215    targetHost               = getNamedValue("targetHost");
216    targetPort               = getNamedValueAsInteger("targetPort");
217    targetProtocol           = getNamedValue("targetProtocol");
218    undeleteFromDN           = getNamedValue("undeleteFromDN");
219
220    intermediateResponsesReturned =
221         getNamedValueAsLong("intermediateResponsesReturned");
222
223    final Integer rcInteger = getNamedValueAsInteger("resultCode");
224    if (rcInteger == null)
225    {
226      resultCode = null;
227    }
228    else
229    {
230      resultCode = ResultCode.valueOf(rcInteger);
231    }
232
233    final String refStr = getNamedValue("referralURLs");
234    if ((refStr == null) || refStr.isEmpty())
235    {
236      referralURLs = Collections.emptyList();
237    }
238    else
239    {
240      final LinkedList<String> refs = new LinkedList<>();
241      int startPos = 0;
242      while (true)
243      {
244        final int commaPos = refStr.indexOf(",ldap", startPos);
245        if (commaPos < 0)
246        {
247          refs.add(refStr.substring(startPos));
248          break;
249        }
250        else
251        {
252          refs.add(refStr.substring(startPos, commaPos));
253          startPos = commaPos+1;
254        }
255      }
256      referralURLs = Collections.unmodifiableList(refs);
257    }
258
259    final String controlStr = getNamedValue("responseControls");
260    if (controlStr == null)
261    {
262      responseControlOIDs = Collections.emptyList();
263    }
264    else
265    {
266      final LinkedList<String> controlList = new LinkedList<>();
267      final StringTokenizer t = new StringTokenizer(controlStr, ",");
268      while (t.hasMoreTokens())
269      {
270        controlList.add(t.nextToken());
271      }
272      responseControlOIDs = Collections.unmodifiableList(controlList);
273    }
274
275    final String serversAccessedStr = getNamedValue("serversAccessed");
276    if ((serversAccessedStr == null) || serversAccessedStr.isEmpty())
277    {
278      serversAccessed = Collections.emptyList();
279    }
280    else
281    {
282      final LinkedList<String> servers = new LinkedList<>();
283      final StringTokenizer tokenizer =
284           new StringTokenizer(serversAccessedStr, ",");
285      while (tokenizer.hasMoreTokens())
286      {
287        servers.add(tokenizer.nextToken());
288      }
289      serversAccessed = Collections.unmodifiableList(servers);
290    }
291
292    uncachedDataAccessed = getNamedValueAsBoolean("uncachedDataAccessed");
293
294
295    final String localLevelStr = getNamedValue("localAssuranceLevel");
296    if (localLevelStr == null)
297    {
298      assuredReplicationLocalLevel = null;
299    }
300    else
301    {
302      assuredReplicationLocalLevel =
303           AssuredReplicationLocalLevel.valueOf(localLevelStr);
304    }
305
306    final String remoteLevelStr = getNamedValue("remoteAssuranceLevel");
307    if (remoteLevelStr == null)
308    {
309      assuredReplicationRemoteLevel = null;
310    }
311    else
312    {
313      assuredReplicationRemoteLevel =
314           AssuredReplicationRemoteLevel.valueOf(remoteLevelStr);
315    }
316
317    assuredReplicationTimeoutMillis =
318         getNamedValueAsLong("assuranceTimeoutMillis");
319    responseDelayedByAssurance =
320         getNamedValueAsBoolean("responseDelayedByAssurance");
321
322    final String usedPrivilegesStr = getNamedValue("usedPrivileges");
323    if ((usedPrivilegesStr == null) || usedPrivilegesStr.isEmpty())
324    {
325      usedPrivileges = Collections.emptyList();
326    }
327    else
328    {
329      final LinkedList<String> privileges = new LinkedList<>();
330      final StringTokenizer tokenizer =
331           new StringTokenizer(usedPrivilegesStr, ",");
332      while (tokenizer.hasMoreTokens())
333      {
334        privileges.add(tokenizer.nextToken());
335      }
336      usedPrivileges = Collections.unmodifiableList(privileges);
337    }
338
339    final String preAuthZUsedPrivilegesStr =
340         getNamedValue("preAuthZUsedPrivileges");
341    if ((preAuthZUsedPrivilegesStr == null) ||
342        preAuthZUsedPrivilegesStr.isEmpty())
343    {
344      preAuthZUsedPrivileges = Collections.emptyList();
345    }
346    else
347    {
348      final LinkedList<String> privileges = new LinkedList<>();
349      final StringTokenizer tokenizer =
350           new StringTokenizer(preAuthZUsedPrivilegesStr, ",");
351      while (tokenizer.hasMoreTokens())
352      {
353        privileges.add(tokenizer.nextToken());
354      }
355      preAuthZUsedPrivileges = Collections.unmodifiableList(privileges);
356    }
357
358    final String missingPrivilegesStr = getNamedValue("missingPrivileges");
359    if ((missingPrivilegesStr == null) || missingPrivilegesStr.isEmpty())
360    {
361      missingPrivileges = Collections.emptyList();
362    }
363    else
364    {
365      final LinkedList<String> privileges = new LinkedList<>();
366      final StringTokenizer tokenizer =
367           new StringTokenizer(missingPrivilegesStr, ",");
368      while (tokenizer.hasMoreTokens())
369      {
370        privileges.add(tokenizer.nextToken());
371      }
372      missingPrivileges = Collections.unmodifiableList(privileges);
373    }
374
375    final String indexesNearLimitStr =
376         getNamedValue("indexesWithKeysAccessedNearEntryLimit");
377    if ((indexesNearLimitStr == null) || indexesNearLimitStr.isEmpty())
378    {
379      indexesWithKeysAccessedNearEntryLimit = Collections.emptyList();
380    }
381    else
382    {
383      final LinkedList<String> indexes = new LinkedList<>();
384      final StringTokenizer tokenizer =
385           new StringTokenizer(indexesNearLimitStr, ",");
386      while (tokenizer.hasMoreTokens())
387      {
388        indexes.add(tokenizer.nextToken());
389      }
390      indexesWithKeysAccessedNearEntryLimit =
391           Collections.unmodifiableList(indexes);
392    }
393
394    final String indexesOverLimitStr =
395         getNamedValue("indexesWithKeysAccessedExceedingEntryLimit");
396    if ((indexesOverLimitStr == null) || indexesOverLimitStr.isEmpty())
397    {
398      indexesWithKeysAccessedOverEntryLimit = Collections.emptyList();
399    }
400    else
401    {
402      final LinkedList<String> indexes = new LinkedList<>();
403      final StringTokenizer tokenizer =
404           new StringTokenizer(indexesOverLimitStr, ",");
405      while (tokenizer.hasMoreTokens())
406      {
407        indexes.add(tokenizer.nextToken());
408      }
409      indexesWithKeysAccessedOverEntryLimit =
410           Collections.unmodifiableList(indexes);
411    }
412  }
413
414
415
416  /**
417   * Retrieves the result code for the operation.
418   *
419   * @return  The result code for the operation, or {@code null} if it is not
420   *          included in the log message.
421   */
422  @Override()
423  @Nullable()
424  public ResultCode getResultCode()
425  {
426    return resultCode;
427  }
428
429
430
431  /**
432   * Retrieves the diagnostic message for the operation.
433   *
434   * @return  The diagnostic message for the operation, or {@code null} if it is
435   *          not included in the log message.
436   */
437  @Override()
438  @Nullable()
439  public String getDiagnosticMessage()
440  {
441    return diagnosticMessage;
442  }
443
444
445
446  /**
447   * Retrieves a message with additional information about the result of the
448   * operation.
449   *
450   * @return  A message with additional information about the result of the
451   *          operation, or {@code null} if it is not included in the log
452   *          message.
453   */
454  @Override()
455  @Nullable()
456  public String getAdditionalInformation()
457  {
458    return additionalInformation;
459  }
460
461
462
463  /**
464   * Retrieves the matched DN for the operation.
465   *
466   * @return  The matched DN for the operation, or {@code null} if it is not
467   *          included in the log message.
468   */
469  @Override()
470  @Nullable()
471  public String getMatchedDN()
472  {
473    return matchedDN;
474  }
475
476
477
478  /**
479   * Retrieves the list of referral URLs for the operation.
480   *
481   * @return  The list of referral URLs for the operation, or an empty list if
482   *          it is not included in the log message.
483   */
484  @Override()
485  @NotNull()
486  public List<String> getReferralURLs()
487  {
488    return referralURLs;
489  }
490
491
492
493  /**
494   * Retrieves the number of intermediate response messages returned in the
495   * course of processing the operation.
496   *
497   * @return  The number of intermediate response messages returned to the
498   *          client in the course of processing the operation, or {@code null}
499   *          if it is not included in the log message.
500   */
501  @Override()
502  @Nullable()
503  public Long getIntermediateResponsesReturned()
504  {
505    return intermediateResponsesReturned;
506  }
507
508
509
510  /**
511   * Retrieves the length of time in milliseconds required to process the
512   * operation.
513   *
514   * @return  The length of time in milliseconds required to process the
515   *          operation, or {@code null} if it is not included in the log
516   *          message.
517   */
518  @Override()
519  @Nullable()
520  public Double getProcessingTimeMillis()
521  {
522    return processingTime;
523  }
524
525
526
527  /**
528   * Retrieves the length of time in milliseconds the operation was required to
529   * wait on the work queue.
530   *
531   * @return  The length of time in milliseconds the operation was required to
532   *          wait on the work queue, or {@code null} if it is not included in
533   *          the log message.
534   */
535  @Override()
536  @Nullable()
537  public Double getQueueTimeMillis()
538  {
539    return queueTime;
540  }
541
542
543
544  /**
545   * Retrieves the OIDs of any response controls contained in the log message.
546   *
547   * @return  The OIDs of any response controls contained in the log message, or
548   *          an empty list if it is not included in the log message.
549   */
550  @Override()
551  @NotNull()
552  public List<String> getResponseControlOIDs()
553  {
554    return responseControlOIDs;
555  }
556
557
558
559  /**
560   * Retrieves a list of the additional servers that were accessed in the course
561   * of processing the operation.  For example, if the access log message is
562   * from a Directory Proxy Server instance, then this may contain a list of the
563   * backend servers used to process the operation.
564   *
565   * @return  A list of the additional servers that were accessed in the course
566   *          of processing the operation, or an empty list if it is not
567   *          included in the log message.
568   */
569  @Override()
570  @NotNull()
571  public List<String> getServersAccessed()
572  {
573    return serversAccessed;
574  }
575
576
577
578  /**
579   * Indicates whether the server accessed any uncached data in the course of
580   * processing the operation.
581   *
582   * @return  {@code true} if the server was known to access uncached data in
583   *          the course of processing the operation, {@code false} if the
584   *          server was known not to access uncached data, or {@code null} if
585   *          it is not included in the log message (and the server likely did
586   *          not access uncached data).
587   */
588  @Nullable()
589  public Boolean getUncachedDataAccessed()
590  {
591    return uncachedDataAccessed;
592  }
593
594
595
596  /**
597   * Retrieves the content of the intermediate client result for the
598   * operation.
599   *
600   * @return  The content of the intermediate client result for the operation,
601   *          or {@code null} if it is not included in the log message.
602   */
603  @Override()
604  @Nullable()
605  public String getIntermediateClientResult()
606  {
607    return intermediateClientResult;
608  }
609
610
611
612  /**
613   * Retrieves the alternate authorization DN for the operation.
614   *
615   * @return  The alternate authorization DN for the operation, or {@code null}
616   *          if it is not included in the log message.
617   */
618  @Nullable()
619  public String getAlternateAuthorizationDN()
620  {
621    return authzDN;
622  }
623
624
625
626  /**
627   * Retrieves the replication change ID for the operation, if available.
628   *
629   * @return  The replication change ID for the operation, or {@code null} if it
630   *          is not included in the log message.
631   */
632  @Nullable()
633  public String getReplicationChangeID()
634  {
635    return replicationChangeID;
636  }
637
638
639
640  /**
641   * Retrieves the address of the backend server to which the request has been
642   * forwarded.
643   *
644   * @return  The address of the backend server to which the request has been
645   *          forwarded, or {@code null} if it is not included in the log
646   *          message.
647   */
648  @Nullable()
649  public String getTargetHost()
650  {
651    return targetHost;
652  }
653
654
655
656  /**
657   * Retrieves the port of the backend server to which the request has been
658   * forwarded.
659   *
660   * @return  The port of the backend server to which the request has been
661   *          forwarded, or {@code null} if it is not included in the log
662   *          message.
663   */
664  @Nullable()
665  public Integer getTargetPort()
666  {
667    return targetPort;
668  }
669
670
671
672  /**
673   * Retrieves the protocol used to forward the request to the backend server.
674   *
675   * @return  The protocol used to forward the request to the backend server, or
676   *          {@code null} if it is not included in the log message.
677   */
678  @Nullable()
679  public String getTargetProtocol()
680  {
681    return targetProtocol;
682  }
683
684
685
686  /**
687   * Retrieves the DN of the soft-deleted entry from which the contents of the
688   * added entry were obtained, if it was an undelete rather than a normal add.
689   *
690   * @return  The DN of the soft-deleted entry from which the contents of the
691   *          added entry were obtained, or {@code null} if it is not included
692   *          in the log message (e.g., because the operation was a normal add
693   *          rather than an undelete).
694   */
695  @Nullable()
696  public String getUndeleteFromDN()
697  {
698    return undeleteFromDN;
699  }
700
701
702
703  /**
704   * Retrieves the local level that will be used for assured replication
705   * processing, if available.
706   *
707   * @return  The local level that will be used for assured replication
708   *          processing, or {@code null} if this is not included in the log
709   *          message (e.g., because assured replication will not be performed
710   *          for the operation).
711   */
712  @Nullable()
713  public AssuredReplicationLocalLevel getAssuredReplicationLocalLevel()
714  {
715    return assuredReplicationLocalLevel;
716  }
717
718
719
720  /**
721   * Retrieves the remote level that will be used for assured replication
722   * processing, if available.
723   *
724   * @return  The remote level that will be used for assured replication
725   *          processing, or {@code null} if this is not included in the log
726   *          message (e.g., because assured replication will not be performed
727   *          for the operation).
728   */
729  @Nullable()
730  public AssuredReplicationRemoteLevel getAssuredReplicationRemoteLevel()
731  {
732    return assuredReplicationRemoteLevel;
733  }
734
735
736
737  /**
738   * Retrieves the maximum length of time in milliseconds that the server will
739   * delay the response to the client while waiting for the replication
740   * assurance requirement to be satisfied.
741   *
742   * @return  The maximum length of time in milliseconds that the server will
743   *          delay the response to the client while waiting for the replication
744   *          assurance requirement to be satisfied, or {@code null} if this is
745   *          not included in the log message (e.g., because assured replication
746   *          will not be performed for the operation).
747   */
748  @Nullable()
749  public Long getAssuredReplicationTimeoutMillis()
750  {
751    return assuredReplicationTimeoutMillis;
752  }
753
754
755
756  /**
757   * Indicates whether the operation response to the client will be delayed
758   * until replication assurance has been satisfied or the timeout has occurred.
759   *
760   * @return  {@code true} if the operation response to the client will be
761   *          delayed until replication assurance has been satisfied,
762   *          {@code false} if the response will not be delayed by assurance
763   *          processing, or {@code null} if this was not included in the
764   *          log message (e.g., because assured replication will not be
765   *          performed for the operation)
766   */
767  @Nullable()
768  public Boolean getResponseDelayedByAssurance()
769  {
770    return responseDelayedByAssurance;
771  }
772
773
774
775  /**
776   * Retrieves the names of any privileges used during the course of processing
777   * the operation.
778   *
779   * @return  The names of any privileges used during the course of processing
780   *          the operation, or an empty list if no privileges were used or this
781   *          is not included in the log message.
782   */
783  @NotNull()
784  public List<String> getUsedPrivileges()
785  {
786    return usedPrivileges;
787  }
788
789
790
791  /**
792   * Retrieves the names of any privileges used during the course of processing
793   * the operation before an alternate authorization identity was assigned.
794   *
795   * @return  The names of any privileges used during the course of processing
796   *          the operation before an alternate authorization identity was
797   *          assigned, or an empty list if no privileges were used or this is
798   *          not included in the log message.
799   */
800  @NotNull()
801  public List<String> getPreAuthorizationUsedPrivileges()
802  {
803    return preAuthZUsedPrivileges;
804  }
805
806
807
808  /**
809   * Retrieves the names of any privileges that would have been required for
810   * processing the operation but that the requester did not have.
811   *
812   * @return  The names of any privileges that would have been required for
813   *          processing the operation but that the requester did not have, or
814   *          an empty list if there were no missing privileges or this is not
815   *          included in the log message.
816   */
817  @NotNull()
818  public List<String> getMissingPrivileges()
819  {
820    return missingPrivileges;
821  }
822
823
824
825  /**
826   * Retrieves the names of any indexes for which one or more keys near
827   * (typically, within 80% of) the index entry limit were accessed while
828   * processing the operation.
829   *
830   * @return  The names of any indexes for which one or more keys near the index
831   *          entry limit were accessed while processing the operation, or an
832   *          empty list if no such index keys were accessed, or if this is not
833   *          included in the log message.
834   */
835  @NotNull()
836  public List<String> getIndexesWithKeysAccessedNearEntryLimit()
837  {
838    return indexesWithKeysAccessedNearEntryLimit;
839  }
840
841
842
843  /**
844   * Retrieves the names of any indexes for which one or more keys over the
845   * index entry limit were accessed while processing the operation.
846   *
847   * @return  The names of any indexes for which one or more keys over the index
848   *          entry limit were accessed while processing the operation, or an
849   *          empty list if no such index keys were accessed, or if this is not
850   *          included in the log message.
851   */
852  @NotNull()
853  public List<String> getIndexesWithKeysAccessedOverEntryLimit()
854  {
855    return indexesWithKeysAccessedOverEntryLimit;
856  }
857
858
859
860  /**
861   * {@inheritDoc}
862   */
863  @Override()
864  @NotNull()
865  public AccessLogMessageType getMessageType()
866  {
867    return AccessLogMessageType.RESULT;
868  }
869}