com.airbus_cyber_security.graylog.events.config.AutoValue_LoggingAlertConfig Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of graylog-plugin-logging-alert Show documentation
Graylog ${project.artifactId} plugin.
There is a newer version: 5.1.4
Show newest version
package com.airbus_cyber_security.graylog.events.config;

import com.fasterxml.jackson.annotation.JsonProperty;
import javax.annotation.Generated;
import javax.annotation.Nullable;

@Generated("com.google.auto.value.processor.AutoValueProcessor")
final class AutoValue_LoggingAlertConfig extends LoggingAlertConfig {

  private final SeverityType accessSeverity;

  private final String accessSeparator;

  private final String accessLogBody;

  private final String accessAggregationStream;

  private final int accessAggregationTime;

  private final int accessLimitOverflow;

  private final String accessFieldAlertId;

  private final String accessAlertTag;

  private final String accessOverflowTag;

  private AutoValue_LoggingAlertConfig(
      SeverityType accessSeverity,
      String accessSeparator,
      String accessLogBody,
      @Nullable String accessAggregationStream,
      int accessAggregationTime,
      int accessLimitOverflow,
      String accessFieldAlertId,
      String accessAlertTag,
      String accessOverflowTag) {
    this.accessSeverity = accessSeverity;
    this.accessSeparator = accessSeparator;
    this.accessLogBody = accessLogBody;
    this.accessAggregationStream = accessAggregationStream;
    this.accessAggregationTime = accessAggregationTime;
    this.accessLimitOverflow = accessLimitOverflow;
    this.accessFieldAlertId = accessFieldAlertId;
    this.accessAlertTag = accessAlertTag;
    this.accessOverflowTag = accessOverflowTag;
  }

  @JsonProperty("severity")
  @Override
  public SeverityType accessSeverity() {
    return accessSeverity;
  }

  @JsonProperty("separator")
  @Override
  public String accessSeparator() {
    return accessSeparator;
  }

  @JsonProperty("log_body")
  @Override
  public String accessLogBody() {
    return accessLogBody;
  }

  @JsonProperty("aggregation_stream")
  @Nullable
  @Override
  public String accessAggregationStream() {
    return accessAggregationStream;
  }

  @JsonProperty("aggregation_time")
  @Override
  public int accessAggregationTime() {
    return accessAggregationTime;
  }

  @JsonProperty("limit_overflow")
  @Override
  public int accessLimitOverflow() {
    return accessLimitOverflow;
  }

  @JsonProperty("field_alert_id")
  @Override
  public String accessFieldAlertId() {
    return accessFieldAlertId;
  }

  @JsonProperty("alert_tag")
  @Override
  public String accessAlertTag() {
    return accessAlertTag;
  }

  @JsonProperty("overflow_tag")
  @Override
  public String accessOverflowTag() {
    return accessOverflowTag;
  }

  @Override
  public String toString() {
    return "LoggingAlertConfig{"
        + "accessSeverity=" + accessSeverity + ", "
        + "accessSeparator=" + accessSeparator + ", "
        + "accessLogBody=" + accessLogBody + ", "
        + "accessAggregationStream=" + accessAggregationStream + ", "
        + "accessAggregationTime=" + accessAggregationTime + ", "
        + "accessLimitOverflow=" + accessLimitOverflow + ", "
        + "accessFieldAlertId=" + accessFieldAlertId + ", "
        + "accessAlertTag=" + accessAlertTag + ", "
        + "accessOverflowTag=" + accessOverflowTag
        + "}";
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (o instanceof LoggingAlertConfig) {
      LoggingAlertConfig that = (LoggingAlertConfig) o;
      return this.accessSeverity.equals(that.accessSeverity())
          && this.accessSeparator.equals(that.accessSeparator())
          && this.accessLogBody.equals(that.accessLogBody())
          && (this.accessAggregationStream == null ? that.accessAggregationStream() == null : this.accessAggregationStream.equals(that.accessAggregationStream()))
          && this.accessAggregationTime == that.accessAggregationTime()
          && this.accessLimitOverflow == that.accessLimitOverflow()
          && this.accessFieldAlertId.equals(that.accessFieldAlertId())
          && this.accessAlertTag.equals(that.accessAlertTag())
          && this.accessOverflowTag.equals(that.accessOverflowTag());
    }
    return false;
  }

  @Override
  public int hashCode() {
    int h$ = 1;
    h$ *= 1000003;
    h$ ^= accessSeverity.hashCode();
    h$ *= 1000003;
    h$ ^= accessSeparator.hashCode();
    h$ *= 1000003;
    h$ ^= accessLogBody.hashCode();
    h$ *= 1000003;
    h$ ^= (accessAggregationStream == null) ? 0 : accessAggregationStream.hashCode();
    h$ *= 1000003;
    h$ ^= accessAggregationTime;
    h$ *= 1000003;
    h$ ^= accessLimitOverflow;
    h$ *= 1000003;
    h$ ^= accessFieldAlertId.hashCode();
    h$ *= 1000003;
    h$ ^= accessAlertTag.hashCode();
    h$ *= 1000003;
    h$ ^= accessOverflowTag.hashCode();
    return h$;
  }

  @Override
  public LoggingAlertConfig.Builder toBuilder() {
    return new Builder(this);
  }

  static final class Builder extends LoggingAlertConfig.Builder {
    private SeverityType accessSeverity;
    private String accessSeparator;
    private String accessLogBody;
    private String accessAggregationStream;
    private Integer accessAggregationTime;
    private Integer accessLimitOverflow;
    private String accessFieldAlertId;
    private String accessAlertTag;
    private String accessOverflowTag;
    Builder() {
    }
    private Builder(LoggingAlertConfig source) {
      this.accessSeverity = source.accessSeverity();
      this.accessSeparator = source.accessSeparator();
      this.accessLogBody = source.accessLogBody();
      this.accessAggregationStream = source.accessAggregationStream();
      this.accessAggregationTime = source.accessAggregationTime();
      this.accessLimitOverflow = source.accessLimitOverflow();
      this.accessFieldAlertId = source.accessFieldAlertId();
      this.accessAlertTag = source.accessAlertTag();
      this.accessOverflowTag = source.accessOverflowTag();
    }
    @Override
    public LoggingAlertConfig.Builder accessSeverity(SeverityType accessSeverity) {
      if (accessSeverity == null) {
        throw new NullPointerException("Null accessSeverity");
      }
      this.accessSeverity = accessSeverity;
      return this;
    }
    @Override
    public LoggingAlertConfig.Builder accessSeparator(String accessSeparator) {
      if (accessSeparator == null) {
        throw new NullPointerException("Null accessSeparator");
      }
      this.accessSeparator = accessSeparator;
      return this;
    }
    @Override
    public LoggingAlertConfig.Builder accessLogBody(String accessLogBody) {
      if (accessLogBody == null) {
        throw new NullPointerException("Null accessLogBody");
      }
      this.accessLogBody = accessLogBody;
      return this;
    }
    @Override
    public LoggingAlertConfig.Builder accessAggregationStream(String accessAggregationStream) {
      this.accessAggregationStream = accessAggregationStream;
      return this;
    }
    @Override
    public LoggingAlertConfig.Builder accessAggregationTime(int accessAggregationTime) {
      this.accessAggregationTime = accessAggregationTime;
      return this;
    }
    @Override
    public LoggingAlertConfig.Builder accessLimitOverflow(int accessLimitOverflow) {
      this.accessLimitOverflow = accessLimitOverflow;
      return this;
    }
    @Override
    public LoggingAlertConfig.Builder accessFieldAlertId(String accessFieldAlertId) {
      if (accessFieldAlertId == null) {
        throw new NullPointerException("Null accessFieldAlertId");
      }
      this.accessFieldAlertId = accessFieldAlertId;
      return this;
    }
    @Override
    public LoggingAlertConfig.Builder accessAlertTag(String accessAlertTag) {
      if (accessAlertTag == null) {
        throw new NullPointerException("Null accessAlertTag");
      }
      this.accessAlertTag = accessAlertTag;
      return this;
    }
    @Override
    public LoggingAlertConfig.Builder accessOverflowTag(String accessOverflowTag) {
      if (accessOverflowTag == null) {
        throw new NullPointerException("Null accessOverflowTag");
      }
      this.accessOverflowTag = accessOverflowTag;
      return this;
    }
    @Override
    public LoggingAlertConfig build() {
      String missing = "";
      if (this.accessSeverity == null) {
        missing += " accessSeverity";
      }
      if (this.accessSeparator == null) {
        missing += " accessSeparator";
      }
      if (this.accessLogBody == null) {
        missing += " accessLogBody";
      }
      if (this.accessAggregationTime == null) {
        missing += " accessAggregationTime";
      }
      if (this.accessLimitOverflow == null) {
        missing += " accessLimitOverflow";
      }
      if (this.accessFieldAlertId == null) {
        missing += " accessFieldAlertId";
      }
      if (this.accessAlertTag == null) {
        missing += " accessAlertTag";
      }
      if (this.accessOverflowTag == null) {
        missing += " accessOverflowTag";
      }
      if (!missing.isEmpty()) {
        throw new IllegalStateException("Missing required properties:" + missing);
      }
      return new AutoValue_LoggingAlertConfig(
          this.accessSeverity,
          this.accessSeparator,
          this.accessLogBody,
          this.accessAggregationStream,
          this.accessAggregationTime,
          this.accessLimitOverflow,
          this.accessFieldAlertId,
          this.accessAlertTag,
          this.accessOverflowTag);
    }
  }

}