CUnion.java

  1. /*
  2.  * Copyright 2016 Providence Authors
  3.  *
  4.  * Licensed to the Apache Software Foundation (ASF) under one
  5.  * or more contributor license agreements. See the NOTICE file
  6.  * distributed with this work for additional information
  7.  * regarding copyright ownership. The ASF licenses this file
  8.  * to you under the Apache License, Version 2.0 (the
  9.  * "License"); you may not use this file except in compliance
  10.  * with the License. You may obtain a copy of the License at
  11.  *
  12.  *   http://www.apache.org/licenses/LICENSE-2.0
  13.  *
  14.  * Unless required by applicable law or agreed to in writing,
  15.  * software distributed under the License is distributed on an
  16.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17.  * KIND, either express or implied. See the License for the
  18.  * specific language governing permissions and limitations
  19.  * under the License.
  20.  */
  21. package net.morimekta.providence.reflect.contained;

  23. import net.morimekta.providence.PMessage;
  24. import net.morimekta.providence.PMessageBuilder;
  25. import net.morimekta.providence.PType;
  26. import net.morimekta.providence.PUnion;
  27. import net.morimekta.providence.descriptor.PAnnotation;
  28. import net.morimekta.providence.descriptor.PContainer;
  29. import net.morimekta.providence.descriptor.PMessageDescriptor;
  30. import net.morimekta.providence.descriptor.PUnionDescriptor;
  31. import net.morimekta.util.collect.UnmodifiableList;
  32. import net.morimekta.util.collect.UnmodifiableMap;
  33. import net.morimekta.util.collect.UnmodifiableSet;
  34. import net.morimekta.util.collect.UnmodifiableSortedMap;
  35. import net.morimekta.util.collect.UnmodifiableSortedSet;

  37. import javax.annotation.Nonnull;
  38. import java.util.ArrayList;
  39. import java.util.Collection;
  40. import java.util.LinkedHashMap;
  41. import java.util.LinkedHashSet;
  42. import java.util.List;
  43. import java.util.Map;
  44. import java.util.Objects;
  45. import java.util.Set;

  47. /**
  48.  * @author Stein Eldar Johnsen
  49.  * @since 07.09.15
  50.  */
  51. public class CUnion implements PUnion<CUnion> {
  52.     private final CUnionDescriptor descriptor;
  53.     private final CField<CUnion>   unionField;
  54.     private final Object           unionValue;

  56.     @SuppressWarnings("unchecked")
  57.     private CUnion(Builder builder) {
  58.         this.unionField = builder.unionField;
  59.         this.descriptor = builder.descriptor;

  61.         if (builder.currentValue instanceof PMessageBuilder) {
  62.             this.unionValue = ((PMessageBuilder<?>) builder.currentValue).build();
  63.         } else if (builder.currentValue instanceof List) {
  64.             this.unionValue = UnmodifiableList.copyOf((List<?>) builder.currentValue);
  65.         } else if (builder.currentValue instanceof Map) {
  66.             if (PContainer.typeForName(unionField.getAnnotationValue(PAnnotation.CONTAINER)) ==
  67.                 PContainer.Type.SORTED) {
  68.                 this.unionValue = UnmodifiableSortedMap.copyOf((Map<?,?>) builder.currentValue);
  69.             } else {
  70.                 this.unionValue = UnmodifiableMap.copyOf((Map<?,?>) builder.currentValue);
  71.             }
  72.         } else if (builder.currentValue instanceof Set) {
  73.             if (PContainer.typeForName(unionField.getAnnotationValue(PAnnotation.CONTAINER)) ==
  74.                 PContainer.Type.SORTED) {
  75.                 this.unionValue = UnmodifiableSortedSet.copyOf((Set<?>) builder.currentValue);
  76.             } else {
  77.                 this.unionValue = UnmodifiableSet.copyOf((Set<?>) builder.currentValue);
  78.             }
  79.         } else {
  80.             this.unionValue = builder.currentValue;
  81.         }
  82.     }

  84.     @Override
  85.     public boolean has(int key) {
  86.         return unionField != null && unionField.getId() == key && unionValue != null;
  87.     }

  89.     @Override
  90.     @SuppressWarnings("unchecked")
  91.     public <T> T get(int key) {
  92.         return has(key) ? (T) unionValue : null;
  93.     }

  95.     @Nonnull
  96.     @Override
  97.     public PMessageBuilder<CUnion> mutate() {
  98.         return new Builder(this);
  99.     }

  101.     @Nonnull
  102.     @Override
  103.     public String asString() {
  104.         return CStruct.asString(this);
  105.     }

  107.     @Override
  108.     public String toString() {
  109.         return descriptor.getQualifiedName() + asString();
  110.     }

  112.     @Nonnull
  113.     @Override
  114.     public CUnionDescriptor descriptor() {
  115.         return descriptor;
  116.     }

  118.     @Override
  119.     public boolean unionFieldIsSet() {
  120.         return unionField != null;
  121.     }

  123.     @Nonnull
  124.     @Override
  125.     public CField<CUnion> unionField() {
  126.         if (unionField == null) throw new IllegalStateException("No union field set in " + descriptor.getQualifiedName());
  127.         return unionField;
  128.     }

  130.     @Override
  131.     public boolean equals(Object o) {
  132.         if (this == o) return true;
  133.         if (!(o instanceof CUnion)) {
  134.             return false;
  135.         }

  137.         CUnion other = (CUnion) o;
  138.         return Objects.equals(descriptor, other.descriptor) &&
  139.                Objects.equals(unionField, other.unionField) &&
  140.                Objects.equals(unionValue, other.unionValue);
  141.     }

  143.     @Override
  144.     public int hashCode() {
  145.         return Objects.hash(descriptor().getQualifiedName(), unionField, unionValue);
  146.     }

  148.     @Override
  149.     public int compareTo(@Nonnull CUnion other) {
  150.         return CStruct.compareMessages(this, other);
  151.     }

  153.     public static class Builder extends PMessageBuilder<CUnion> {
  154.         private final CUnionDescriptor descriptor;
  155.         private       CField<CUnion>   originalField;
  156.         private       boolean          updated;

  158.         private CField<CUnion> unionField;
  159.         private Object currentValue;

  161.         public Builder(CUnionDescriptor descriptor) {
  162.             this.descriptor = descriptor;
  163.             this.originalField = null;
  164.             this.updated = false;
  165.         }

  167.         public Builder(CUnion union) {
  168.             this.descriptor = union.descriptor;
  169.             if (union.unionField != null) {
  170.                 this.set(union.unionField, union.unionValue);
  171.             }
  172.             this.originalField = union.unionField;
  173.             this.updated = false;
  174.         }

  176.         @Nonnull
  177.         @Override
  178.         public PMessageBuilder<?> mutator(int key) {
  179.             CField<CUnion> field = descriptor.findFieldById(key);
  180.             if (field == null) {
  181.                 throw new IllegalArgumentException("No such field ID " + key);
  182.             } else if (field.getType() != PType.MESSAGE) {
  183.                 throw new IllegalArgumentException("Not a message field ID " + key + ": " + field.getName());
  184.             }
  185.             if (unionField != field) {
  186.                 unionField = field;
  187.                 currentValue = null;
  188.             }

  190.             updated = true;
  191.             if (currentValue == null) {
  192.                 currentValue = ((PMessageDescriptor<?>) field.getDescriptor()).builder();
  193.             } else if (currentValue instanceof PMessage) {
  194.                 currentValue = ((PMessage<?>) currentValue).mutate();
  195.             } else if (!(currentValue instanceof PMessageBuilder)) {
  196.                 // This should in theory not be possible. This is just a safe-guard.
  197.                 throw new IllegalArgumentException("Invalid currentValue in map on message type: " + currentValue.getClass().getSimpleName());
  198.             }

  200.             return (PMessageBuilder<?>) currentValue;
  201.         }

  203.         @Nonnull
  204.         @Override
  205.         @SuppressWarnings("unchecked,rawtypes")
  206.         public Builder merge(@Nonnull CUnion from) {
  207.             if (unionField == null || unionField != from.unionField) {
  208.                 if (from.unionField != null) {
  209.                     set(from.unionField.getId(), from.unionValue);
  210.                 }
  211.             } else {
  212.                 this.updated = true;
  213.                 int key = unionField.getId();
  214.                 switch (unionField.getType()) {
  215.                     case MESSAGE: {
  216.                         PMessageBuilder src;
  217.                         if (currentValue instanceof PMessageBuilder) {
  218.                             src = (PMessageBuilder<?>) currentValue;
  219.                         } else {
  220.                             src = ((PMessage<?>) currentValue).mutate();
  221.                         }
  222.                         PMessage toMerge = from.get(key);

  224.                         currentValue = src.merge(toMerge);
  225.                         break;
  226.                     }
  227.                     case SET:
  228.                         ((Set<Object>) currentValue).addAll(from.get(key));
  229.                         break;
  230.                     case MAP:
  231.                         ((Map<Object, Object>) currentValue).putAll(from.get(key));
  232.                         break;
  233.                     default:
  234.                         // Lists replace, not add.
  235.                         set(key, from.get(key));
  236.                         break;
  237.                 }
  238.             }

  240.             return this;
  241.         }

  243.         @Override
  244.         public boolean has(int key) {
  245.             CField<?> field = descriptor.findFieldById(key);
  246.             return field != null && unionField == field;
  247.         }

  249.         @Override
  250.         @SuppressWarnings("unchecked")
  251.         public <T> T get(int key) {
  252.             CField<?> field = descriptor.findFieldById(key);
  253.             if (unionField == field) {
  254.                 return (T) currentValue;
  255.             }
  256.             return null;
  257.         }

  259.         @Nonnull
  260.         @Override
  261.         public PUnionDescriptor<CUnion> descriptor() {
  262.             return descriptor;
  263.         }

  265.         @Nonnull
  266.         @Override
  267.         public CUnion build() {
  268.             return new CUnion(this);
  269.         }

  271.         @Override
  272.         public boolean valid() {
  273.             return unionField != null && currentValue != null;
  274.         }

  276.         @Override
  277.         public Builder validate() {
  278.             if (!valid()) {
  279.                 throw new IllegalStateException("No union field set in " +
  280.                                                 descriptor().getQualifiedName());
  281.             }
  282.             return this;
  283.         }

  285.         @Nonnull
  286.         @Override
  287.         public Builder set(int key, Object value) {
  288.             CField<CUnion> field = descriptor.findFieldById(key);
  289.             if (field == null) {
  290.                 return this; // soft ignoring unsupported fields.
  291.             }
  292.             if (value == null) {
  293.                 return clear(key);
  294.             }
  295.             this.updated = true;
  296.             this.unionField = field;
  297.             switch (field.getType()) {
  298.                 case SET:
  299.                     this.currentValue = new LinkedHashSet<>((Collection<?>) value);
  300.                     break;
  301.                 case LIST:
  302.                     this.currentValue = new ArrayList<>((Collection<?>) value);
  303.                     break;
  304.                 case MAP:
  305.                     this.currentValue = new LinkedHashMap<>((Map<?,?>) value);
  306.                     break;
  307.                 default:
  308.                     this.currentValue = value;
  309.                     break;
  310.             }

  312.             return this;
  313.         }

  315.         @Override
  316.         public boolean isSet(int key) {
  317.             return unionField != null && unionField.getId() == key;
  318.         }

  320.         @Override
  321.         public boolean isModified(int key) {
  322.             if (updated) {
  323.                 if (unionField != null && unionField.getId() == key) return true;
  324.                 return originalField != null && originalField.getId() == key;
  325.             }
  326.             return false;
  327.         }

  329.         @Nonnull
  330.         @Override
  331.         @SuppressWarnings("unchecked")
  332.         public Builder addTo(int key, Object value) {
  333.             CField<CUnion> field = descriptor.findFieldById(key);
  334.             if (field == null) {
  335.                 return this; // soft ignoring unsupported fields.
  336.             }
  337.             if (field.getType() != PType.LIST &&
  338.                 field.getType() != PType.SET) {
  339.                 throw new IllegalArgumentException("Unable to accept addTo on non-list field " + field.getName());
  340.             }
  341.             if (value == null) {
  342.                 throw new IllegalArgumentException("Adding null item to collection " + field.getName());
  343.             }
  344.             this.updated = true;
  345.             if (this.unionField != field || this.currentValue == null) {
  346.                 this.unionField = field;
  347.                 switch (field.getType()) {
  348.                     case LIST: {
  349.                         this.currentValue = new ArrayList<>();
  350.                         break;
  351.                     }
  352.                     case SET: {
  353.                         this.currentValue = new LinkedHashSet<>();
  354.                         break;
  355.                     }
  356.                     default:
  357.                         break;
  358.                 }
  359.             }
  360.             ((Collection<Object>) this.currentValue).add(value);
  361.             return this;
  362.         }

  364.         @Nonnull
  365.         @Override
  366.         public Builder clear(int key) {
  367.             if (isSet(key)) {
  368.                 this.updated = true;
  369.                 if (originalField == null) {
  370.                     originalField = unionField;
  371.                 }
  372.                 this.unionField = null;
  373.                 this.currentValue = null;
  374.             }
  375.             return this;
  376.         }
  377.     }
  378. }
Created with JaCoCo 0.8.5.201910111838