X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=forester%2Fjava%2Fsrc%2Forg%2Fforester%2Fsurfacing%2FBasicGenomeWideCombinableDomains.java;h=2813185b625a095310fa962f687cc2fbdfd224d6;hb=0b49b8e750b34d28a5989facdd8a7959870de996;hp=3e59603bdded2c85e7b9077a631317d1435b2e60;hpb=08a92c65e8b969a3ce2a4b511055cd6029357831;p=jalview.git

diff --git a/forester/java/src/org/forester/surfacing/BasicGenomeWideCombinableDomains.java b/forester/java/src/org/forester/surfacing/BasicGenomeWideCombinableDomains.java
index 3e59603..2813185 100644
--- a/forester/java/src/org/forester/surfacing/BasicGenomeWideCombinableDomains.java
+++ b/forester/java/src/org/forester/surfacing/BasicGenomeWideCombinableDomains.java
@@ -26,75 +26,75 @@ import org.forester.util.ForesterUtil;
 
 public class BasicGenomeWideCombinableDomains implements GenomeWideCombinableDomains {
 
+    private static final Comparator<CombinableDomains> DESCENDING_COMBINATIONS_COUNT_ORDER        = new Comparator<CombinableDomains>() {
+
+        @Override
+        public int compare( final CombinableDomains d1,
+                            final CombinableDomains d2 ) {
+            if ( d1.getNumberOfCombinableDomains() < d2
+                    .getNumberOfCombinableDomains() ) {
+                return 1;
+            }
+            else if ( d1
+                    .getNumberOfCombinableDomains() > d2
+                    .getNumberOfCombinableDomains() ) {
+                return -1;
+            }
+            else {
+                return d1
+                        .getKeyDomain()
+                        .compareTo( d2
+                                    .getKeyDomain() );
+            }
+        }
+    };
     private static final Comparator<CombinableDomains> DESCENDING_KEY_DOMAIN_COUNT_ORDER          = new Comparator<CombinableDomains>() {
 
-                                                                                                      @Override
-                                                                                                      public int compare( final CombinableDomains d1,
-                                                                                                                          final CombinableDomains d2 ) {
-                                                                                                          if ( d1.getKeyDomainCount() < d2
-                                                                                                                  .getKeyDomainCount() ) {
-                                                                                                              return 1;
-                                                                                                          }
-                                                                                                          else if ( d1
-                                                                                                                  .getKeyDomainCount() > d2
-                                                                                                                  .getKeyDomainCount() ) {
-                                                                                                              return -1;
-                                                                                                          }
-                                                                                                          else {
-                                                                                                              return d1
-                                                                                                                      .getKeyDomain()
-                                                                                                                      .compareTo( d2
-                                                                                                                              .getKeyDomain() );
-                                                                                                          }
-                                                                                                      }
-                                                                                                  };
+        @Override
+        public int compare( final CombinableDomains d1,
+                            final CombinableDomains d2 ) {
+            if ( d1.getKeyDomainCount() < d2
+                    .getKeyDomainCount() ) {
+                return 1;
+            }
+            else if ( d1
+                    .getKeyDomainCount() > d2
+                    .getKeyDomainCount() ) {
+                return -1;
+            }
+            else {
+                return d1
+                        .getKeyDomain()
+                        .compareTo( d2
+                                    .getKeyDomain() );
+            }
+        }
+    };
     private static final Comparator<CombinableDomains> DESCENDING_KEY_DOMAIN_PROTEINS_COUNT_ORDER = new Comparator<CombinableDomains>() {
 
-                                                                                                      @Override
-                                                                                                      public int compare( final CombinableDomains d1,
-                                                                                                                          final CombinableDomains d2 ) {
-                                                                                                          if ( d1.getKeyDomainProteinsCount() < d2
-                                                                                                                  .getKeyDomainProteinsCount() ) {
-                                                                                                              return 1;
-                                                                                                          }
-                                                                                                          else if ( d1
-                                                                                                                  .getKeyDomainProteinsCount() > d2
-                                                                                                                  .getKeyDomainProteinsCount() ) {
-                                                                                                              return -1;
-                                                                                                          }
-                                                                                                          else {
-                                                                                                              return d1
-                                                                                                                      .getKeyDomain()
-                                                                                                                      .compareTo( d2
-                                                                                                                              .getKeyDomain() );
-                                                                                                          }
-                                                                                                      }
-                                                                                                  };
-    private static final Comparator<CombinableDomains> DESCENDING_COMBINATIONS_COUNT_ORDER        = new Comparator<CombinableDomains>() {
-
-                                                                                                      @Override
-                                                                                                      public int compare( final CombinableDomains d1,
-                                                                                                                          final CombinableDomains d2 ) {
-                                                                                                          if ( d1.getNumberOfCombinableDomains() < d2
-                                                                                                                  .getNumberOfCombinableDomains() ) {
-                                                                                                              return 1;
-                                                                                                          }
-                                                                                                          else if ( d1
-                                                                                                                  .getNumberOfCombinableDomains() > d2
-                                                                                                                  .getNumberOfCombinableDomains() ) {
-                                                                                                              return -1;
-                                                                                                          }
-                                                                                                          else {
-                                                                                                              return d1
-                                                                                                                      .getKeyDomain()
-                                                                                                                      .compareTo( d2
-                                                                                                                              .getKeyDomain() );
-                                                                                                          }
-                                                                                                      }
-                                                                                                  };
+        @Override
+        public int compare( final CombinableDomains d1,
+                            final CombinableDomains d2 ) {
+            if ( d1.getKeyDomainProteinsCount() < d2
+                    .getKeyDomainProteinsCount() ) {
+                return 1;
+            }
+            else if ( d1
+                    .getKeyDomainProteinsCount() > d2
+                    .getKeyDomainProteinsCount() ) {
+                return -1;
+            }
+            else {
+                return d1
+                        .getKeyDomain()
+                        .compareTo( d2
+                                    .getKeyDomain() );
+            }
+        }
+    };
     final private SortedMap<String, CombinableDomains> _combinable_domains_map;
-    final private Species                              _species;
     final private DomainCombinationType                _dc_type;
+    final private Species                              _species;
 
     private BasicGenomeWideCombinableDomains( final Species species, final DomainCombinationType dc_type ) {
         _combinable_domains_map = new TreeMap<String, CombinableDomains>();
@@ -102,10 +102,6 @@ public class BasicGenomeWideCombinableDomains implements GenomeWideCombinableDom
         _dc_type = dc_type;
     }
 
-    private void add( final String key, final CombinableDomains cdc ) {
-        _combinable_domains_map.put( key, cdc );
-    }
-
     @Override
     public boolean contains( final String key_id ) {
         return _combinable_domains_map.containsKey( key_id );
@@ -189,10 +185,10 @@ public class BasicGenomeWideCombinableDomains implements GenomeWideCombinableDom
         return toStringBuilder( GenomeWideCombinableDomainsSortOrder.ALPHABETICAL_KEY_ID ).toString();
     }
 
-    // Produces something like: 
-    // 2-oxoacid_dh      5       5       2      Biotin_lipoyl [4], E3_binding [3]
-    @Override
-    public StringBuilder toStringBuilder( final GenomeWideCombinableDomainsSortOrder sort_order ) {
+    // Produces something like:
+        // 2-oxoacid_dh      5       5       2      Biotin_lipoyl [4], E3_binding [3]
+                @Override
+                public StringBuilder toStringBuilder( final GenomeWideCombinableDomainsSortOrder sort_order ) {
         final StringBuilder sb = new StringBuilder();
         final List<CombinableDomains> combinable_domains = new ArrayList<CombinableDomains>();
         for( final String key : getAllCombinableDomainsIds().keySet() ) {
@@ -220,16 +216,8 @@ public class BasicGenomeWideCombinableDomains implements GenomeWideCombinableDom
         return sb;
     }
 
-    private static void countDomains( final Map<String, Integer> domain_counts,
-                                      final Set<String> saw_c,
-                                      final String id_i ) {
-        if ( domain_counts.containsKey( id_i ) ) {
-            domain_counts.put( id_i, 1 + domain_counts.get( ( id_i ) ) );
-        }
-        else {
-            domain_counts.put( id_i, 1 );
-        }
-        saw_c.add( id_i );
+    private void add( final String key, final CombinableDomains cdc ) {
+        _combinable_domains_map.put( key, cdc );
     }
 
     public static BasicGenomeWideCombinableDomains createInstance( final List<Protein> protein_list,
@@ -263,7 +251,7 @@ public class BasicGenomeWideCombinableDomains implements GenomeWideCombinableDom
         for( final Protein protein : protein_list ) {
             if ( !protein.getSpecies().equals( species ) ) {
                 throw new IllegalArgumentException( "species (" + protein.getSpecies()
-                        + ") does not match species of combinable domains collection (" + species + ")" );
+                                                              + ") does not match species of combinable domains collection (" + species + ")" );
             }
             final Set<String> saw_i = new HashSet<String>();
             final Set<String> saw_c = new HashSet<String>();
@@ -309,7 +297,7 @@ public class BasicGenomeWideCombinableDomains implements GenomeWideCombinableDom
                                 saw_j.add( id );
                                 if ( dc_type != DomainCombinationType.DIRECTED_ADJACTANT ) {
                                     domain_combination
-                                            .addCombinableDomain( protein.getProteinDomain( j ).getDomainId() );
+                                    .addCombinableDomain( protein.getProteinDomain( j ).getDomainId() );
                                 }
                                 else {
                                     if ( closest == null ) {
@@ -355,4 +343,16 @@ public class BasicGenomeWideCombinableDomains implements GenomeWideCombinableDom
         }
         return instance;
     }
+
+    private static void countDomains( final Map<String, Integer> domain_counts,
+                                      final Set<String> saw_c,
+                                      final String id_i ) {
+        if ( domain_counts.containsKey( id_i ) ) {
+            domain_counts.put( id_i, 1 + domain_counts.get( ( id_i ) ) );
+        }
+        else {
+            domain_counts.put( id_i, 1 );
+        }
+        saw_c.add( id_i );
+    }
 }