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