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 a modify 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 ModifyResultAccessLogMessage
077       extends ModifyRequestAccessLogMessage
078       implements OperationResultAccessLogMessage
079{
080  /**
081   * The serial version UID for this serializable class.
082   */
083  private static final long serialVersionUID = -4950863829060893245L;
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 delete operation targeted a soft-deleted entry.
100  @Nullable private final Boolean changeToSoftDeletedEntry;
101
102  // Indicates whether the any uncached data was accessed in the course of
103  // processing this operation.
104  @Nullable private final Boolean uncachedDataAccessed;
105
106  // The processing time for the operation.
107  @Nullable private final Double processingTime;
108
109  // The queue time for the operation.
110  @Nullable private final Double queueTime;
111
112  // The port of the backend server to which the request has been forwarded.
113  @Nullable private final Integer targetPort;
114
115  // The list of indexes for which keys near the index entry limit were accessed
116  // while processing the operation.
117  @NotNull private final List<String> indexesWithKeysAccessedNearEntryLimit;
118
119  // The list of indexes for which keys over the index entry limit were accessed
120  // while processing the operation.
121  @NotNull private final List<String> indexesWithKeysAccessedOverEntryLimit;
122
123  // The list of privileges required for processing the operation that the
124  // requester did not have.
125  @NotNull private final List<String> missingPrivileges;
126
127  // The list of privileges used during the course of processing the operation
128  // before an alternate authorization identity was assigned.
129  @NotNull private final List<String> preAuthZUsedPrivileges;
130
131  // The list of referral URLs for the operation.
132  @NotNull private final List<String> referralURLs;
133
134  // The list of response control OIDs for the operation.
135  @NotNull private final List<String> responseControlOIDs;
136
137  // The list of servers accessed while processing the operation.
138  @NotNull private final List<String> serversAccessed;
139
140  // The list of privileges used during the course of processing the operation.
141  @NotNull private final List<String> usedPrivileges;
142
143  // The assured replication timeout, in milliseconds.
144  @Nullable private final Long assuredReplicationTimeoutMillis;
145
146  // The number of intermediate response messages returned to the client.
147  @Nullable private final Long intermediateResponsesReturned;
148
149  // The result code for the operation.
150  @Nullable private final ResultCode resultCode;
151
152  // Additional information about the operation result.
153  @Nullable private final String additionalInformation;
154
155  // The alternate authorization DN for the operation.
156  @Nullable private final String authzDN;
157
158  // The diagnostic message for the operation.
159  @Nullable private final String diagnosticMessage;
160
161  // The intermediate client result for the operation.
162  @Nullable private final String intermediateClientResult;
163
164  // The matched DN for the operation.
165  @Nullable private final String matchedDN;
166
167  // The replication change ID for the operation.
168  @Nullable private final String replicationChangeID;
169
170  // The address of the backend server to which the request has been forwarded.
171  @Nullable private final String targetHost;
172
173  // The protocol used to forward the request to the backend server.
174  @Nullable private final String targetProtocol;
175
176
177
178  /**
179   * Creates a new modify result access log message from the provided message
180   * string.
181   *
182   * @param  s  The string to be parsed as a modify result access log message.
183   *
184   * @throws  LogException  If the provided string cannot be parsed as a valid
185   *                        log message.
186   */
187  public ModifyResultAccessLogMessage(@NotNull final String s)
188         throws LogException
189  {
190    this(new LogMessage(s));
191  }
192
193
194
195  /**
196   * Creates a new modify result access log message from the provided log
197   * message.
198   *
199   * @param  m  The log message to be parsed as a modify result access log
200   *            message.
201   */
202  public ModifyResultAccessLogMessage(@NotNull final LogMessage m)
203  {
204    super(m);
205
206    diagnosticMessage        = getNamedValue("message");
207    additionalInformation    = getNamedValue("additionalInfo");
208    matchedDN                = getNamedValue("matchedDN");
209    processingTime           = getNamedValueAsDouble("etime");
210    queueTime                = getNamedValueAsDouble("qtime");
211    intermediateClientResult = getNamedValue("from");
212    authzDN                  = getNamedValue("authzDN");
213    replicationChangeID      = getNamedValue("replicationChangeID");
214    targetHost               = getNamedValue("targetHost");
215    targetPort               = getNamedValueAsInteger("targetPort");
216    targetProtocol           = getNamedValue("targetProtocol");
217
218    changeToSoftDeletedEntry =
219         getNamedValueAsBoolean("changeToSoftDeletedEntry");
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   * Indicates whether the modify operation targeted a soft-deleted entry.
642   *
643   * @return  {@code true} if the modify operation was known to target a
644   *          soft-deleted entry, {@code false} if it was known to target a
645   *          non-soft-deleted entry, or {@code null} if it is not included in
646   *          the log message (and likely did not target a soft-deleted entry).
647   */
648  @Nullable()
649  public Boolean getChangeToSoftDeletedEntry()
650  {
651    return changeToSoftDeletedEntry;
652  }
653
654
655
656  /**
657   * Retrieves the address of the backend server to which the request has been
658   * forwarded.
659   *
660   * @return  The address 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 String getTargetHost()
666  {
667    return targetHost;
668  }
669
670
671
672  /**
673   * Retrieves the port of the backend server to which the request has been
674   * forwarded.
675   *
676   * @return  The port of the backend server to which the request has been
677   *          forwarded, or {@code null} if it is not included in the log
678   *          message.
679   */
680  @Nullable()
681  public Integer getTargetPort()
682  {
683    return targetPort;
684  }
685
686
687
688  /**
689   * Retrieves the protocol used to forward the request to the backend server.
690   *
691   * @return  The protocol used to forward the request to the backend server, or
692   *          {@code null} if it is not included in the log message.
693   */
694  @Nullable()
695  public String getTargetProtocol()
696  {
697    return targetProtocol;
698  }
699
700
701
702  /**
703   * Retrieves the local level that will be used for assured replication
704   * processing, if available.
705   *
706   * @return  The local level that will be used for assured replication
707   *          processing, or {@code null} if this is not included in the log
708   *          message (e.g., because assured replication will not be performed
709   *          for the operation).
710   */
711  @Nullable()
712  public AssuredReplicationLocalLevel getAssuredReplicationLocalLevel()
713  {
714    return assuredReplicationLocalLevel;
715  }
716
717
718
719  /**
720   * Retrieves the remote level that will be used for assured replication
721   * processing, if available.
722   *
723   * @return  The remote level that will be used for assured replication
724   *          processing, or {@code null} if this is not included in the log
725   *          message (e.g., because assured replication will not be performed
726   *          for the operation).
727   */
728  @Nullable()
729  public AssuredReplicationRemoteLevel getAssuredReplicationRemoteLevel()
730  {
731    return assuredReplicationRemoteLevel;
732  }
733
734
735
736  /**
737   * Retrieves the maximum length of time in milliseconds that the server will
738   * delay the response to the client while waiting for the replication
739   * assurance requirement to be satisfied.
740   *
741   * @return  The maximum length of time in milliseconds that the server will
742   *          delay the response to the client while waiting for the replication
743   *          assurance requirement to be satisfied, or {@code null} if this is
744   *          not included in the log message (e.g., because assured replication
745   *          will not be performed for the operation).
746   */
747  @Nullable()
748  public Long getAssuredReplicationTimeoutMillis()
749  {
750    return assuredReplicationTimeoutMillis;
751  }
752
753
754
755  /**
756   * Indicates whether the operation response to the client will be delayed
757   * until replication assurance has been satisfied or the timeout has occurred.
758   *
759   * @return  {@code true} if the operation response to the client will be
760   *          delayed until replication assurance has been satisfied,
761   *          {@code false} if the response will not be delayed by assurance
762   *          processing, or {@code null} if this was not included in the
763   *          log message (e.g., because assured replication will not be
764   *          performed for the operation)
765   */
766  @Nullable()
767  public Boolean getResponseDelayedByAssurance()
768  {
769    return responseDelayedByAssurance;
770  }
771
772
773
774  /**
775   * Retrieves the names of any privileges used during the course of processing
776   * the operation.
777   *
778   * @return  The names of any privileges used during the course of processing
779   *          the operation, or an empty list if no privileges were used or this
780   *          is not included in the log message.
781   */
782  @NotNull()
783  public List<String> getUsedPrivileges()
784  {
785    return usedPrivileges;
786  }
787
788
789
790  /**
791   * Retrieves the names of any privileges used during the course of processing
792   * the operation before an alternate authorization identity was assigned.
793   *
794   * @return  The names of any privileges used during the course of processing
795   *          the operation before an alternate authorization identity was
796   *          assigned, or an empty list if no privileges were used or this is
797   *          not included in the log message.
798   */
799  @NotNull()
800  public List<String> getPreAuthorizationUsedPrivileges()
801  {
802    return preAuthZUsedPrivileges;
803  }
804
805
806
807  /**
808   * Retrieves the names of any privileges that would have been required for
809   * processing the operation but that the requester did not have.
810   *
811   * @return  The names of any privileges that would have been required for
812   *          processing the operation but that the requester did not have, or
813   *          an empty list if there were no missing privileges or this is not
814   *          included in the log message.
815   */
816  @NotNull()
817  public List<String> getMissingPrivileges()
818  {
819    return missingPrivileges;
820  }
821
822
823
824  /**
825   * Retrieves the names of any indexes for which one or more keys near
826   * (typically, within 80% of) the index entry limit were accessed while
827   * processing the operation.
828   *
829   * @return  The names of any indexes for which one or more keys near the index
830   *          entry limit were accessed while processing the operation, or an
831   *          empty list if no such index keys were accessed, or if this is not
832   *          included in the log message.
833   */
834  @NotNull()
835  public List<String> getIndexesWithKeysAccessedNearEntryLimit()
836  {
837    return indexesWithKeysAccessedNearEntryLimit;
838  }
839
840
841
842  /**
843   * Retrieves the names of any indexes for which one or more keys over the
844   * index entry limit were accessed while processing the operation.
845   *
846   * @return  The names of any indexes for which one or more keys over the index
847   *          entry limit were accessed while processing the operation, or an
848   *          empty list if no such index keys were accessed, or if this is not
849   *          included in the log message.
850   */
851  @NotNull()
852  public List<String> getIndexesWithKeysAccessedOverEntryLimit()
853  {
854    return indexesWithKeysAccessedOverEntryLimit;
855  }
856
857
858
859  /**
860   * {@inheritDoc}
861   */
862  @Override()
863  @NotNull()
864  public AccessLogMessageType getMessageType()
865  {
866    return AccessLogMessageType.RESULT;
867  }
868}