UniParc light and cross reference

controlled-vocabulary/src/test/java/org/uniprot/cv/xdb/UniProtKBCrossReferenceDisplayOrderTest.java

@@ -1,13 +1,19 @@
 package org.uniprot.cv.xdb;
 
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.uniprot.core.cv.xdb.UniProtDatabaseDetail;
+import org.uniprot.cv.common.CVSystemProperties;
 
 import java.util.List;
 
-import org.junit.jupiter.api.Test;
-import org.uniprot.core.cv.xdb.UniProtDatabaseDetail;
+import static org.junit.jupiter.api.Assertions.*;
 
 class UniProtKBCrossReferenceDisplayOrderTest {
+    @BeforeAll
+    static void setSystemProperty(){
+        System.setProperty(CVSystemProperties.DR_ORD_LOCATION,"src/test/resources/xdb/dr_ord");
+    }
 
     @Test
     void testCreateUniProtXDbDisplayOrder() {

core-common/src/main/java/org/uniprot/core/util/PairImpl.java

@@ -5,6 +5,10 @@ public class PairImpl<K, V> implements Pair<K, V> {
     private final K key;
     private final V value;
 
+    PairImpl(){ // do not use, just to make Jackson serializer happy
+        this(null, null);
+    }
+
     public PairImpl(K key, V value) {
         this.key = key;
         this.value = value;

core-common/src/test/java/org/uniprot/core/util/UtilsTest.java

@@ -191,34 +191,82 @@ void nonEmpty_shouldAlwaysReturnFalse() {
         class unmodifiableList {
             @Test
             void passingNullReturnEmptyList() {
-                List l = Utils.unmodifiableList(null);
-                assertTrue(l.isEmpty());
+                List<Object> unmodifiableList = Utils.unmodifiableList(null);
+                assertTrue(unmodifiableList.isEmpty());
             }
 
             @Test
             void passing_emptyList_returnEmptyList() {
-                List l = Utils.unmodifiableList(new ArrayList<>());
-                assertTrue(l.isEmpty());
+                List<Object> unmodifiableList = Utils.unmodifiableList(new ArrayList<>());
+                assertTrue(unmodifiableList.isEmpty());
             }
 
             @Test
             void passingNullReturnEmptyList_unmodifiable() {
-                List<String> l = Utils.unmodifiableList(null);
-                assertThrows(UnsupportedOperationException.class, () -> l.add("abc"));
+                List<String> unmodifiableList = Utils.unmodifiableList(null);
+                assertThrows(UnsupportedOperationException.class, () -> unmodifiableList.add("abc"));
             }
 
             @Test
             void passing_emptyList_returnEmptyList_unmodifiable() {
-                List<String> l = Utils.unmodifiableList(new ArrayList<>());
-                assertThrows(UnsupportedOperationException.class, () -> l.add("abc"));
+                List<String> unmodifiableList = Utils.unmodifiableList(new ArrayList<>());
+                assertThrows(UnsupportedOperationException.class, () -> unmodifiableList.add("abc"));
             }
 
             @Test
             void passingList_returnUnmodifiable() {
                 List<String> list = new ArrayList<>();
                 list.add("a");
                 list.add("b");
-                List<String> l = Utils.unmodifiableList(list);
+                List<String> unmodifiableList = Utils.unmodifiableList(list);
+                assertThrows(UnsupportedOperationException.class, () -> unmodifiableList.add("c"));
+            }
+        }
+
+        @Nested
+        class unmodifiableSet {
+            @Test
+            void passingNullReturnEmptySet() {
+                Set<Object> unmodifiableSet = Utils.unmodifiableSet(null);
+                assertTrue(unmodifiableSet.isEmpty());
+            }
+
+            @Test
+            void passing_emptySet_returnEmptySet() {
+                Set<String> unmodifiableSet = Utils.unmodifiableSet(new HashSet<>());
+                assertTrue(unmodifiableSet.isEmpty());
+            }
+
+            @Test
+            void passingNullReturnEmptySet_unmodifiable() {
+                Set<String> unmodifiableSet = Utils.unmodifiableSet(null);
+                assertThrows(UnsupportedOperationException.class, () -> unmodifiableSet.add("abc"));
+            }
+
+            @Test
+            void passing_emptySet_returnEmptySet_unmodifiable() {
+                Set<String> unmodifiableSet = Utils.unmodifiableSet(new HashSet<>());
+                assertThrows(UnsupportedOperationException.class, () -> unmodifiableSet.add("abc"));
+            }
+
+            @Test
+            void passingSet_returnUnmodifiable() {
+                Set<String> set = new HashSet<>();
+                set.add("a");
+                set.add("b");
+                Set<String> unmodifiableSet = Utils.unmodifiableSet(set);
+                assertThrows(UnsupportedOperationException.class, () -> unmodifiableSet.add("c"));
+            }
+
+            @Test
+            void passingLinkedHashSet_returnUnmodifiable() {
+                Set<String> list = new LinkedHashSet<>();
+                list.add("a");
+                list.add("b");
+                list.add("d");
+                list.add("c");
+                Set<String> l = Utils.unmodifiableSet(list);
+                assertEquals(list,l);
                 assertThrows(UnsupportedOperationException.class, () -> l.add("c"));
             }
         }

core-domain/src/main/java/org/uniprot/core/uniparc/CommonOrganism.java

@@ -0,0 +1,8 @@
+package org.uniprot.core.uniparc;
+
+import java.io.Serializable;
+
+public interface CommonOrganism extends Serializable {
+    String getTopLevel();
+    String getCommonTaxon();
+}

core-domain/src/main/java/org/uniprot/core/uniparc/Proteome.java

@@ -0,0 +1,10 @@
+package org.uniprot.core.uniparc;
+
+import java.io.Serializable;
+
+public interface Proteome extends Serializable {
+
+    String getId();
+
+    String getComponent();
+}

core-domain/src/main/java/org/uniprot/core/uniparc/UniParcEntryLight.java

@@ -0,0 +1,39 @@
+package org.uniprot.core.uniparc;
+
+import org.uniprot.core.Sequence;
+import org.uniprot.core.uniprotkb.taxonomy.Organism;
+
+import java.io.Serializable;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface UniParcEntryLight extends Serializable {
+    String getUniParcId();
+
+    int getCrossReferenceCount();
+
+    List<CommonOrganism> getCommonTaxons();
+
+    Set<String> getUniProtKBAccessions();
+
+    Sequence getSequence();
+
+    List<SequenceFeature> getSequenceFeatures();
+
+    LocalDate getOldestCrossRefCreated();
+
+    LocalDate getMostRecentCrossRefUpdated();
+
+    Map<String, Object> getExtraAttributes();
+
+    // lazily loaded fields
+    Set<Organism> getOrganisms();// organism id and name pair
+
+    Set<String> getProteinNames();
+
+    Set<String> getGeneNames();
+
+    Set<Proteome> getProteomes();
+}

core-domain/src/main/java/org/uniprot/core/uniparc/impl/CommonOrganismBuilder.java

@@ -0,0 +1,36 @@
+package org.uniprot.core.uniparc.impl;
+
+import org.uniprot.core.Builder;
+import org.uniprot.core.uniparc.CommonOrganism;
+
+import javax.annotation.Nonnull;
+
+public class CommonOrganismBuilder implements Builder<CommonOrganism> {
+
+    private String topLevel;
+    private String commonTaxon;
+
+    @Nonnull
+    @Override
+    public CommonOrganism build() {
+        return new CommonOrganismImpl(topLevel, commonTaxon);
+    }
+
+    public CommonOrganismBuilder topLevel(String topLevel) {
+        this.topLevel = topLevel;
+        return this;
+    }
+
+
+    public CommonOrganismBuilder commonTaxon(String commonTaxon) {
+        this.commonTaxon = commonTaxon;
+        return this;
+    }
+
+    public static @Nonnull CommonOrganismBuilder from(@Nonnull CommonOrganism instance) {
+        CommonOrganismBuilder builder = new CommonOrganismBuilder()
+                .topLevel(instance.getTopLevel())
+                .commonTaxon(instance.getCommonTaxon());
+        return builder;
+    }
+}

core-domain/src/main/java/org/uniprot/core/uniparc/impl/CommonOrganismImpl.java

@@ -0,0 +1,44 @@
+package org.uniprot.core.uniparc.impl;
+
+import org.uniprot.core.uniparc.CommonOrganism;
+
+import java.util.Objects;
+
+public class CommonOrganismImpl implements CommonOrganism {
+
+    private static final long serialVersionUID = 4897886166938610296L;
+
+    private String topLevel;
+    private String commonTaxon;
+
+    CommonOrganismImpl(){
+    }
+
+    CommonOrganismImpl(String topLevel, String commonTaxon) {
+        this.topLevel = topLevel;
+        this.commonTaxon = commonTaxon;
+    }
+
+    @Override
+    public String getTopLevel() {
+        return topLevel;
+    }
+
+    @Override
+    public String getCommonTaxon() {
+        return commonTaxon;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        CommonOrganismImpl that = (CommonOrganismImpl) o;
+        return Objects.equals(topLevel, that.topLevel) && Objects.equals(commonTaxon, that.commonTaxon);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(topLevel, commonTaxon);
+    }
+}

core-domain/src/main/java/org/uniprot/core/uniparc/impl/ProteomeBuilder.java

@@ -0,0 +1,36 @@
+package org.uniprot.core.uniparc.impl;
+
+import org.uniprot.core.Builder;
+import org.uniprot.core.uniparc.Proteome;
+
+import javax.annotation.Nonnull;
+
+public class ProteomeBuilder  implements Builder<Proteome> {
+
+    private String id;
+    private String component;
+
+    @Nonnull
+    @Override
+    public Proteome build() {
+        return new ProteomeImpl(id, component);
+    }
+
+    public ProteomeBuilder id(String id) {
+        this.id = id;
+        return this;
+    }
+
+
+    public ProteomeBuilder component(String component) {
+        this.component = component;
+        return this;
+    }
+
+    public static @Nonnull ProteomeBuilder from(@Nonnull Proteome instance) {
+        ProteomeBuilder builder = new ProteomeBuilder()
+                .id(instance.getId())
+                .component(instance.getComponent());
+        return builder;
+    }
+}

core-domain/src/main/java/org/uniprot/core/uniparc/impl/ProteomeImpl.java

@@ -0,0 +1,44 @@
+package org.uniprot.core.uniparc.impl;
+
+import org.uniprot.core.uniparc.Proteome;
+
+import java.util.Objects;
+
+public class ProteomeImpl implements Proteome {
+
+    private static final long serialVersionUID = -7947022870498125809L;
+
+    private String id;
+    private String component;
+
+    ProteomeImpl() {
+    }
+
+    ProteomeImpl(String id, String component) {
+        this.id = id;
+        this.component = component;
+    }
+
+    @Override
+    public String getId() {
+        return id;
+    }
+
+    @Override
+    public String getComponent() {
+        return component;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ProteomeImpl proteome = (ProteomeImpl) o;
+        return Objects.equals(id, proteome.id) && Objects.equals(component, proteome.component);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, component);
+    }
+}

core-domain/src/main/java/org/uniprot/core/uniparc/impl/UniParcCrossReferencePair.java

@@ -0,0 +1,44 @@
+package org.uniprot.core.uniparc.impl;
+
+import org.uniprot.core.uniparc.UniParcCrossReference;
+import org.uniprot.core.util.Pair;
+
+import java.io.Serial;
+import java.util.List;
+import java.util.Objects;
+
+public class UniParcCrossReferencePair implements Pair<String, List<UniParcCrossReference>>{
+    @Serial
+    private static final long serialVersionUID = 7906365717659009263L;
+    private String key;
+    private List<UniParcCrossReference> value;
+
+    UniParcCrossReferencePair(){}
+    public UniParcCrossReferencePair(String key, List<UniParcCrossReference> value) {
+        this.key = key;
+        this.value = value;
+    }
+
+    @Override
+    public String getKey() {
+        return key;
+    }
+
+    @Override
+    public List<UniParcCrossReference> getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        UniParcCrossReferencePair that = (UniParcCrossReferencePair) o;
+        return Objects.equals(getKey(), that.getKey()) && Objects.equals(getValue(), that.getValue());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getKey(), getValue());
+    }
+}