com.almworks.jira.structure.api2g.attribute.AttributeSpecBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of structure-api Show documentation
Public API for the Structure Plugin for JIRA
There is a newer version: 17.25.3
package com.almworks.jira.structure.api2g.attribute;

import com.almworks.jira.structure.util.JsonMapUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.*;

import static com.almworks.jira.structure.api2g.attribute.AttributeSpecUtil.*;

public class AttributeSpecBuilder {
  private String myId;
  private ValueFormat myFormat;
  private ParamsBuilder> myParams;

  public static AttributeSpecBuilder create() {
    return new AttributeSpecBuilder<>();
  }

  public static AttributeSpecBuilder create(String id) {
    return new AttributeSpecBuilder().setId(id);
  }

  public static  AttributeSpecBuilder create(String id, ValueFormat format) {
    return new AttributeSpecBuilder().setId(id).setFormat(format);
  }

  public static  AttributeSpecBuilder create(String id, ValueFormat format, Map params) {
    return new AttributeSpecBuilder()
      .setId(id)
      .setFormat(format)
      .params().copyFrom(params).done();
  }

  public AttributeSpec build() {
    return new AttributeSpec<>(myId, myFormat, myParams.buildMap(), true);
  }

  public static  AttributeSpecBuilder create(AttributeSpec sample) {
    if (sample == null) return new AttributeSpecBuilder<>();
    return create(sample.getId(), sample.getFormat(), sample.getParamsMap());
  }

  public AttributeSpecBuilder setId(String id) {
    myId = id;
    return this;
  }

  @SuppressWarnings("unchecked")
  public  AttributeSpecBuilder setFormat(ValueFormat format) {
    myFormat = (ValueFormat) format;
    return (AttributeSpecBuilder) this;
  }

  public ParamsBuilder> params() {
    if (myParams == null) {
      myParams = new ParamsBuilder<>(this);
    }
    return myParams;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    AttributeSpecBuilder that = (AttributeSpecBuilder) o;

    if (myId != null ? !myId.equals(that.myId) : that.myId != null) return false;
    if (myFormat != null ? !myFormat.equals(that.myFormat) : that.myFormat != null) return false;
    return !(myParams != null ? !myParams.equals(that.myParams) : that.myParams != null);

  }

  @Override
  public int hashCode() {
    int result = myId != null ? myId.hashCode() : 0;
    result = 31 * result + (myFormat != null ? myFormat.hashCode() : 0);
    result = 31 * result + (myParams != null ? myParams.hashCode() : 0);
    return result;
  }

  @Override
  public String toString() {
    return "AttributeSpecBuilder('" + myId + "', " + myFormat + ", " + myParams + ")";
  }


  public class ParamsBuilder {
    private final P myParent;
    private final Map myParams = new LinkedHashMap<>();

    public ParamsBuilder(P parent) {
      myParent = parent;
    }

    public P done() {
      return myParent;
    }

    public ParamsBuilder> object(String key) {
      Object existing = myParams.get(key);
      ParamsBuilder> r;
      if (existing instanceof ParamsBuilder) {
        //noinspection unchecked
        r = (ParamsBuilder>) existing;
      } else {
        r = new ParamsBuilder<>(this);
        put(key, r);
      }
      return r;
    }

    public ParamsBuilder
 set(String key, Object value) {
      if (value == null) return this;
      if (value instanceof AttributeSpec) {
        return setAttribute(key, (AttributeSpec) value);
      }
      JsonMapUtil.checkValidParameter(value);
      return setValidated(key, value);
    }

    public ParamsBuilder
 setAttribute(AttributeSpec value) {
      return setAttribute(DEFAULT_ATTRIBUTESPEC_PARAMETER_NAME, value);
    }

    public ParamsBuilder
 setAttribute(String key, AttributeSpec value) {
      return object(key)
        .set(DEFAULT_ID_PARAMETER_NAME, value.getId())
        .set(DEFAULT_FORMAT_PARAMETER_NAME, value.getFormat().getFormatId())
        .setValidatedMap(DEFAULT_PARAMS_PARAMETER_NAME, value.getParamsMap())
        .done();
    }

    public ParamsBuilder
 copyFrom(@Nullable Map map) {
      if (map == null || map.isEmpty()) return this;
      JsonMapUtil.checkValidParameter(map);
      return copyFromValidated(map);
    }

    private ParamsBuilder
 setValidated(String key, Object value) {
      if (value instanceof Map) {
        //noinspection unchecked
        return setValidatedMap(key, (Map) value);
      } else {
        put(key, value);
      }
      return this;
    }

    private ParamsBuilder
 setValidatedMap(String key, Map map) {
      if (map == null || map.isEmpty()) return this;
      return object(key).copyFromValidated(map).done();
    }

    @NotNull
    private ParamsBuilder copyFromValidated(Map map) {
      if (map != null) {
        for (Map.Entry e : map.entrySet()) {
          setValidated(e.getKey(), e.getValue());
        }
      }
      return this;
    }

    private void put(String key, Object r) {
      if (key == null) {
        throw new IllegalArgumentException("null key is not allowed");
      }
      myParams.put(key, r);
    }

    @Override
    public boolean equals(Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;
      ParamsBuilder that = (ParamsBuilder) o;
      return myParams.equals(that.myParams);
    }

    @Override
    public int hashCode() {
      return myParams.hashCode();
    }

    @Override
    public String toString() {
      return myParams.toString();
    }

    @Nullable
    public Map buildMap() {
      if (myParams.isEmpty()) return null;
      LinkedHashMap r = new LinkedHashMap<>(myParams);
      for (Iterator> ii = r.entrySet().iterator(); ii.hasNext(); ) {
        Map.Entry e = ii.next();
        Object value = e.getValue();
        if (value instanceof ParamsBuilder) {
          value = ((ParamsBuilder)value).buildMap();
          if (value == null) {
            ii.remove();
          } else {
            e.setValue(value);
          }
        }
      }
      return r;
    }

    public AttributeSpec build() {
      return AttributeSpecBuilder.this.build();
    }
  }
}