forester/java/src/org/forester/surfacing/BasicCombinableDomains.java

   1 // $Id:
   2 //
   3 // FORESTER -- software libraries and applications
   4 // for evolutionary biology research and applications.
   5 //
   6 // Copyright (C) 2008-2009 Christian M. Zmasek
   7 // Copyright (C) 2008-2009 Burnham Institute for Medical Research
   8 // All rights reserved
   9 //
  10 // This library is free software; you can redistribute it and/or
  11 // modify it under the terms of the GNU Lesser General Public
  12 // License as published by the Free Software Foundation; either
  13 // version 2.1 of the License, or (at your option) any later version.
  14 //
  15 // This library is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18 // Lesser General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU Lesser General Public
  21 // License along with this library; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  23 //
  24 // Contact: phylosoft @ gmail . com
  25 // WWW: https://sites.google.com/site/cmzmasek/home/software/forester
  26
  27 package org.forester.surfacing;
  28
  29 import java.util.ArrayList;
  30 import java.util.Iterator;
  31 import java.util.List;
  32 import java.util.SortedMap;
  33 import java.util.TreeMap;
  34
  35 import org.forester.protein.BinaryDomainCombination;
  36 import org.forester.species.Species;
  37 import org.forester.util.DescriptiveStatistics;
  38
  39 public class BasicCombinableDomains implements CombinableDomains {
  40
  41     final private String                   _key_domain;
  42     private int                            _key_domain_count;
  43     private int                            _key_domain_proteins_count;
  44     final private Species                  _species;
  45     final private TreeMap<String, Integer> _combining_domains;
  46     private DescriptiveStatistics          _key_domain_confidence_statistics;
  47
  48     public BasicCombinableDomains( final String key_domain, final Species species ) {
  49         _key_domain = key_domain;
  50         _species = species;
  51         _combining_domains = new TreeMap<String, Integer>();
  52         init();
  53     }
  54
  55     @Override
  56     public void addCombinableDomain( final String protein_domain ) {
  57         if ( getCombiningDomains().containsKey( protein_domain ) ) {
  58             getCombiningDomains().put( protein_domain, getCombiningDomains().get( protein_domain ) + 1 );
  59         }
  60         else {
  61             getCombiningDomains().put( protein_domain, 1 );
  62         }
  63     }
  64
  65     @Override
  66     public List<String> getAllDomains() {
  67         final List<String> domains = getCombinableDomains();
  68         if ( !domains.contains( getKeyDomain() ) ) {
  69             domains.add( getKeyDomain() );
  70         }
  71         return domains;
  72     }
  73
  74     @Override
  75     public List<String> getCombinableDomains() {
  76         final List<String> domains = new ArrayList<String>( getNumberOfCombinableDomains() );
  77         for( final String domain : getCombiningDomains().keySet() ) {
  78             domains.add( domain );
  79         }
  80         return domains;
  81     }
  82
  83     @Override
  84     public SortedMap<String, Integer> getCombinableDomainsIds() {
  85         final SortedMap<String, Integer> ids = new TreeMap<String, Integer>();
  86         for( final String domain : getCombiningDomains().keySet() ) {
  87             final String pd = domain;
  88             ids.put( pd, getCombiningDomains().get( pd ) );
  89         }
  90         return ids;
  91     }
  92
  93     @Override
  94     public StringBuilder getCombiningDomainIdsAsStringBuilder() {
  95         final StringBuilder sb = new StringBuilder();
  96         for( final Iterator<String> iter = getCombiningDomains().keySet().iterator(); iter.hasNext(); ) {
  97             final String key = iter.next();
  98             sb.append( key.toString() );
  99             sb.append( " [" );
 100             final int count = getCombiningDomains().get( key );
 101             sb.append( count );
 102             sb.append( "]" );
 103             if ( iter.hasNext() ) {
 104                 sb.append( ", " );
 105             }
 106         }
 107         return sb;
 108     }
 109
 110     protected TreeMap<String, Integer> getCombiningDomains() {
 111         return _combining_domains;
 112     }
 113
 114     @Override
 115     public String getKeyDomain() {
 116         return _key_domain;
 117     }
 118
 119     @Override
 120     public DescriptiveStatistics getKeyDomainConfidenceDescriptiveStatistics() {
 121         return _key_domain_confidence_statistics;
 122     }
 123
 124     @Override
 125     public int getKeyDomainCount() {
 126         return _key_domain_count;
 127     }
 128
 129     @Override
 130     public int getKeyDomainProteinsCount() {
 131         return _key_domain_proteins_count;
 132     }
 133
 134     @Override
 135     public int getNumberOfCombinableDomains() {
 136         return _combining_domains.size();
 137     }
 138
 139     @Override
 140     public int getNumberOfProteinsExhibitingCombination( final String protein_domain ) {
 141         if ( getCombiningDomains().containsKey( protein_domain ) ) {
 142             return getCombiningDomains().get( protein_domain );
 143         }
 144         else {
 145             return 0;
 146         }
 147     }
 148
 149     @Override
 150     public Species getSpecies() {
 151         return _species;
 152     }
 153
 154     private void init() {
 155         _key_domain_count = 0;
 156         _key_domain_proteins_count = 0;
 157         _key_domain_confidence_statistics = null;
 158     }
 159
 160     @Override
 161     public boolean isCombinable( final String protein_domain ) {
 162         return getCombiningDomains().containsKey( protein_domain );
 163     }
 164
 165     @Override
 166     public void setKeyDomainConfidenceDescriptiveStatistics( final DescriptiveStatistics key_domain_confidence_statistics ) {
 167         _key_domain_confidence_statistics = key_domain_confidence_statistics;
 168     }
 169
 170     @Override
 171     public void setKeyDomainCount( final int key_domain_count ) {
 172         _key_domain_count = key_domain_count;
 173     }
 174
 175     @Override
 176     public void setKeyDomainProteinsCount( final int key_domain_proteins_count ) {
 177         _key_domain_proteins_count = key_domain_proteins_count;
 178     }
 179
 180     @Override
 181     public List<BinaryDomainCombination> toBinaryDomainCombinations() {
 182         final List<BinaryDomainCombination> binary_combinations = new ArrayList<BinaryDomainCombination>( getNumberOfCombinableDomains() );
 183         for( final String domain : getCombiningDomains().keySet() ) {
 184             binary_combinations.add( new BasicBinaryDomainCombination( getKeyDomain(), domain ) );
 185         }
 186         return binary_combinations;
 187     }
 188
 189     @Override
 190     public String toString() {
 191         final StringBuilder sb = new StringBuilder();
 192         sb.append( getKeyDomain() );
 193         sb.append( " [" );
 194         sb.append( getKeyDomainCount() );
 195         sb.append( ", " );
 196         sb.append( getKeyDomainProteinsCount() );
 197         sb.append( ", " );
 198         sb.append( getNumberOfCombinableDomains() );
 199         sb.append( "]: " );
 200         sb.append( getCombiningDomainIdsAsStringBuilder() );
 201         return sb.toString();
 202     }
 203 }