in progress...

[jalview.git] / forester / java / src / org / forester / surfacing / BasicBinaryDomainCombination.java

diff --git a/forester/java/src/org/forester/surfacing/BasicBinaryDomainCombination.java b/forester/java/src/org/forester/surfacing/BasicBinaryDomainCombination.java
index 350c2e9..b5844a1 100644 (file)
--- a/forester/java/src/org/forester/surfacing/BasicBinaryDomainCombination.java
+++ b/forester/java/src/org/forester/surfacing/BasicBinaryDomainCombination.java
@@ -26,39 +26,45 @@
 
 package org.forester.surfacing;
 
+import java.util.HashMap;
+import java.util.Map;
+
+import org.forester.protein.BasicDomain;
 import org.forester.protein.BinaryDomainCombination;
 import org.forester.util.ForesterUtil;
 
 public class BasicBinaryDomainCombination implements BinaryDomainCombination {
 
-    // String _id0;
-    // String _id1;
-    String _data;
+    final static boolean                                            VERBOSE = false;
+    final private static Map<Integer, BasicBinaryDomainCombination> DC_POOL = new HashMap<Integer, BasicBinaryDomainCombination>();
+    final private static Map<Integer, String>                       S_POOL  = new HashMap<Integer, String>();
+    short                                                           _id0;
+    short                                                           _id1;
+
+    BasicBinaryDomainCombination() {
+        _id0 = -1;
+        _id1 = -1;
+    }
 
-    public BasicBinaryDomainCombination( final String id0, final String id1 ) {
+    private BasicBinaryDomainCombination( final String id0, final String id1 ) {
         if ( ( id0 == null ) || ( id1 == null ) ) {
             throw new IllegalArgumentException( "attempt to create binary domain combination using null" );
         }
+        if ( ( id0.indexOf( SEPARATOR ) != -1 ) || ( id1.indexOf( SEPARATOR ) != -1 ) ) {
+            throw new IllegalArgumentException( "ill formatted domain id: " + id0 + ", " + id1 );
+        }
         if ( id0.toLowerCase().compareTo( id1.toLowerCase() ) < 0 ) {
-            //  _id0 = id0;
-            //  _id1 = id1;
-            _data = id0 + SEPARATOR + id1;
+            _id0 = BasicDomain.obtainIdAsShort( id0 );
+            _id1 = BasicDomain.obtainIdAsShort( id1 );
         }
         else {
-            // _id0 = id1;
-            // _id1 = id0;
-            _data = id1 + SEPARATOR + id0;
+            _id0 = BasicDomain.obtainIdAsShort( id1 );
+            _id1 = BasicDomain.obtainIdAsShort( id0 );
         }
     }
 
-    BasicBinaryDomainCombination() {
-        //_id0 = null;
-        // _id1 = null;
-        _data = null;
-    }
-
     @Override
-    public int compareTo( final BinaryDomainCombination binary_domain_combination ) {
+    final public int compareTo( final BinaryDomainCombination binary_domain_combination ) {
         if ( binary_domain_combination.getClass() != this.getClass() ) {
             throw new IllegalArgumentException( "attempt to compare [" + binary_domain_combination.getClass() + "] to "
                     + "[" + this.getClass() + "]" );
@@ -76,7 +82,7 @@ public class BasicBinaryDomainCombination implements BinaryDomainCombination {
     }
 
     @Override
-    public boolean equals( final Object o ) {
+    final public boolean equals( final Object o ) {
         if ( this == o ) {
             return true;
         }
@@ -88,32 +94,40 @@ public class BasicBinaryDomainCombination implements BinaryDomainCombination {
                     + o.getClass() + "]" );
         }
         else {
-            return ( getId0().equals( ( ( BinaryDomainCombination ) o ).getId0() ) )
-                    && ( getId1().equals( ( ( BinaryDomainCombination ) o ).getId1() ) );
+            return ( getId0Code() == ( ( BinaryDomainCombination ) o ).getId0Code() )
+                    && ( getId1Code() == ( ( BinaryDomainCombination ) o ).getId1Code() );
         }
     }
 
     @Override
-    public String getId0() {
-        return _data.substring( 0, _data.indexOf( SEPARATOR ) );
-        // return _id0;
+    final public String getId0() {
+        return BasicDomain.obtainIdFromShort( _id0 );
     }
 
     @Override
-    public String getId1() {
-        return _data.substring( _data.indexOf( SEPARATOR ) + 1 );
-        //return _id1;
+    final public short getId0Code() {
+        return _id0;
     }
 
     @Override
-    public int hashCode() {
-        return getAsStr().hashCode();
+    final public String getId1() {
+        return BasicDomain.obtainIdFromShort( _id1 );
     }
 
     @Override
-    public StringBuffer toGraphDescribingLanguage( final OutputFormat format,
-                                                   final String node_attribute,
-                                                   final String edge_attribute ) {
+    final public short getId1Code() {
+        return _id1;
+    }
+
+    @Override
+    final public int hashCode() {
+        return calcCode( _id0, _id1 );
+    }
+
+    @Override
+    final public StringBuffer toGraphDescribingLanguage( final OutputFormat format,
+                                                         final String node_attribute,
+                                                         final String edge_attribute ) {
         final StringBuffer sb = new StringBuffer();
         switch ( format ) {
             case DOT:
@@ -155,16 +169,19 @@ public class BasicBinaryDomainCombination implements BinaryDomainCombination {
     }
 
     @Override
-    public String toString() {
-        return getAsStr();
-    }
-
-    private String getAsStr() {
-        // return _id0 + SEPARATOR + _id1;
-        return _data;
+    final public String toString() {
+        final int code = calcCode( _id0, _id1 );
+        if ( S_POOL.containsKey( code ) ) {
+            return S_POOL.get( code );
+        }
+        else {
+            final String s = getId0() + SEPARATOR + getId1();
+            S_POOL.put( code, s );
+            return s;
+        }
     }
 
-    public static BinaryDomainCombination createInstance( final String ids ) {
+    public static BinaryDomainCombination obtainInstance( final String ids ) {
         if ( ids.indexOf( BinaryDomainCombination.SEPARATOR ) < 1 ) {
             throw new IllegalArgumentException( "Unexpected format for binary domain combination [" + ids + "]" );
         }
@@ -172,6 +189,31 @@ public class BasicBinaryDomainCombination implements BinaryDomainCombination {
         if ( ids_ary.length != 2 ) {
             throw new IllegalArgumentException( "Unexpected format for binary domain combination [" + ids + "]" );
         }
-        return new BasicBinaryDomainCombination( ids_ary[ 0 ], ids_ary[ 1 ] );
+        return BasicBinaryDomainCombination.obtainInstance( ids_ary[ 0 ], ids_ary[ 1 ] );
+    }
+
+    public static BasicBinaryDomainCombination obtainInstance( final String id0, final String id1 ) {
+        int code;
+        if ( id0.toLowerCase().compareTo( id1.toLowerCase() ) < 0 ) {
+            code = calcCode( BasicDomain.obtainIdAsShort( id0 ), BasicDomain.obtainIdAsShort( id1 ) );
+        }
+        else {
+            code = calcCode( BasicDomain.obtainIdAsShort( id1 ), BasicDomain.obtainIdAsShort( id0 ) );
+        }
+        if ( DC_POOL.containsKey( code ) ) {
+            return DC_POOL.get( code );
+        }
+        else {
+            final BasicBinaryDomainCombination dc = new BasicBinaryDomainCombination( id0, id1 );
+            DC_POOL.put( code, dc );
+            if ( VERBOSE && ( ( DC_POOL.size() % 100 ) == 0 ) ) {
+                System.out.println( " dc pool size: " + DC_POOL.size() );
+            }
+            return dc;
+        }
+    }
+
+    final static int calcCode( final int id0, final int id1 ) {
+        return ( id0 * ( Short.MAX_VALUE + 1 ) ) + id1;
     }
 }