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