trunk/proteinstructure/CatalSiteSet.java

package proteinstructure;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;

/** This class encapsulates the catalytic site annotation of a single protein chain. */
public class CatalSiteSet {

        /*------------------------------ constants ------------------------------*/
        
        private static final String LATEST_VERSION = "2.2.7"; // default version
        
        /*--------------------------- member variables --------------------------*/
        
        private HashMap<Integer,HashSet<CatalyticSite>> resser2catalsite;   // residue serials to set of catalytic sites
        private Vector<CatalyticSite> catalyticSites;                                           // the actual collection of catalytic sites
        private String version;                                                                                         // an optional comment describing the version of the catalytic site annotation
        
        /*----------------------------- constructors ----------------------------*/
        
        /** Create an empty catalytic site object */
        public CatalSiteSet() {
                this.catalyticSites = new Vector<CatalyticSite>();
                this.resser2catalsite = new HashMap<Integer,HashSet<CatalyticSite>>();
                this.version = LATEST_VERSION;
        }
        
        /*---------------------------- public methods ---------------------------*/
        
        /**
         * Add the given catalytic site to this set of catalytic sites object.
         */
        public void add(CatalyticSite e) {
                this.catalyticSites.add(e);
                Set<Integer> ressers = e.getRes();
                Iterator<Integer> iter = ressers.iterator();
            while (iter.hasNext()) {
                int resser = (Integer)iter.next();
                        HashSet<CatalyticSite> values = resser2catalsite.get(resser);
                        if (values == null) {
                                values = new HashSet<CatalyticSite>();
                                resser2catalsite.put(resser,values);
                        }
                        values.add(e);
            }
        }
        
        /**
         * Returns true iff this catalytic sites set object contains no catalytic sites.
         */
        public boolean isEmpty() {
                return this.catalyticSites.isEmpty();
        }
        
        /** 
         * Returns an iterator over all assigned catalytic sites in this object.
         */
        public Iterator<CatalyticSite> getIterator() {
                return catalyticSites.iterator();
        }
        
        /** 
         * For a given residue returns the catalytic sites this residue participates in,
         * or null if the residue is not in an assigned catalytic site.
         */
        public HashSet<CatalyticSite> getCatalSite(int resser){
                if(resser2catalsite.containsKey(resser)) {
                        return this.resser2catalsite.get(resser);
                } else {
                        return null;
                }
        }
        
        public String getCatalSiteNum(int resser) {
                String csNums = null;
                if (resser2catalsite.containsKey(resser)) {
                        csNums = "";
                        HashSet<CatalyticSite> css = getCatalSite(resser);
                        Iterator<CatalyticSite> it = css.iterator();
                        while (it.hasNext()) {
                                CatalyticSite cs = (CatalyticSite)it.next();
                                csNums += cs.getSerial();
                                if (it.hasNext()) {
                                        csNums += ",";
                                }
                        }
                }
                return csNums;
        }
        
        public String getCatalSiteChemFunc(int resser) {
                String csChemFuncs = null;
                if (resser2catalsite.containsKey(resser)) {
                        csChemFuncs = "";
                        HashSet<CatalyticSite> css = getCatalSite(resser);
                        Iterator<CatalyticSite> it = css.iterator();
                        while (it.hasNext()) {
                                CatalyticSite cs = (CatalyticSite)it.next();
                                csChemFuncs += cs.getChemFuncFromResSerial(resser);
                                if (it.hasNext()) {
                                        csChemFuncs += ",";
                                }
                        }
                }
                return csChemFuncs;
        }
        
        public String getCatalSiteEvid(int resser) {
                String csEvids = null;
                if (resser2catalsite.containsKey(resser)) {
                        csEvids = "";
                        HashSet<CatalyticSite> css = getCatalSite(resser);
                        Iterator<CatalyticSite> it = css.iterator();
                        while (it.hasNext()) {
                                CatalyticSite cs = (CatalyticSite)it.next();
                                csEvids += cs.getEvidence();
                                if (it.hasNext()) {
                                        csEvids += ",";
                                }
                        }
                }
                return csEvids;
        }
        
        public void removeCatalSiteRes(int resser) {
                if (resser2catalsite.containsKey(resser)) {
                        HashSet<CatalyticSite> css = getCatalSite(resser);
                        Iterator<CatalyticSite> it = css.iterator();
                        while (it.hasNext()) {
                                CatalyticSite cs = (CatalyticSite)it.next();
                                cs.remRes(resser);
                                if (cs.getRes().size() == 0) {
                                        catalyticSites.remove(cs);
                                }
                        }
                        resser2catalsite.remove(resser);
                }               
        }
        
        /** Return a deep copy of this catalytic site set object */
        public CatalSiteSet copy() {
                CatalSiteSet newS = new CatalSiteSet();
                for(CatalyticSite e:catalyticSites) {
                        newS.add(e.copy());
                }
                return newS;
        }
                
        /** Sets the version to c */
        public void setVersion(String c) {
                this.version = c;
        }
        
        /** Returns the version */
        public String getVersion() {
                return this.version;
        }
        
        /** Returns the number of catalytic sites in this catalytic sites set object */
        public int getNumCatalSites() {
                return this.catalyticSites.size();
        }
        
        public void print() {
                Iterator<CatalyticSite> iterator = catalyticSites.iterator ();
        while (iterator.hasNext ()) {
                CatalyticSite cs = (CatalyticSite)iterator.next();
                cs.print();
        } 
        }
}
Revision:	514
Committed:	Fri Jan 11 14:59:43 2008 UTC (16 years, 9 months ago) by filippis
File size:	4928 byte(s)
Log Message:	Latest scop and csa versions updated.
Line	File contents
1	package proteinstructure;
2
3	import java.util.HashMap;
4	import java.util.HashSet;
5	import java.util.Iterator;
6	import java.util.Set;
7	import java.util.Vector;
8
9	/** This class encapsulates the catalytic site annotation of a single protein chain. */
10	public class CatalSiteSet {
11
12	/------------------------------ constants ------------------------------/
13
14	private static final String LATEST_VERSION = "2.2.7"; // default version
15
16	/--------------------------- member variables --------------------------/
17
18	private HashMap<Integer,HashSet<CatalyticSite>> resser2catalsite; // residue serials to set of catalytic sites
19	private Vector<CatalyticSite> catalyticSites; // the actual collection of catalytic sites
20	private String version; // an optional comment describing the version of the catalytic site annotation
21
22	/----------------------------- constructors ----------------------------/
23
24	/** Create an empty catalytic site object */
25	public CatalSiteSet() {
26	this.catalyticSites = new Vector<CatalyticSite>();
27	this.resser2catalsite = new HashMap<Integer,HashSet<CatalyticSite>>();
28	this.version = LATEST_VERSION;
29	}
30
31	/---------------------------- public methods ---------------------------/
32
33	/**
34	* Add the given catalytic site to this set of catalytic sites object.
35	*/
36	public void add(CatalyticSite e) {
37	this.catalyticSites.add(e);
38	Set<Integer> ressers = e.getRes();
39	Iterator<Integer> iter = ressers.iterator();
40	while (iter.hasNext()) {
41	int resser = (Integer)iter.next();
42	HashSet<CatalyticSite> values = resser2catalsite.get(resser);
43	if (values == null) {
44	values = new HashSet<CatalyticSite>();
45	resser2catalsite.put(resser,values);
46	}
47	values.add(e);
48	}
49	}
50
51	/**
52	* Returns true iff this catalytic sites set object contains no catalytic sites.
53	*/
54	public boolean isEmpty() {
55	return this.catalyticSites.isEmpty();
56	}
57
58	/**
59	* Returns an iterator over all assigned catalytic sites in this object.
60	*/
61	public Iterator<CatalyticSite> getIterator() {
62	return catalyticSites.iterator();
63	}
64
65	/**
66	* For a given residue returns the catalytic sites this residue participates in,
67	* or null if the residue is not in an assigned catalytic site.
68	*/
69	public HashSet<CatalyticSite> getCatalSite(int resser){
70	if(resser2catalsite.containsKey(resser)) {
71	return this.resser2catalsite.get(resser);
72	} else {
73	return null;
74	}
75	}
76
77	public String getCatalSiteNum(int resser) {
78	String csNums = null;
79	if (resser2catalsite.containsKey(resser)) {
80	csNums = "";
81	HashSet<CatalyticSite> css = getCatalSite(resser);
82	Iterator<CatalyticSite> it = css.iterator();
83	while (it.hasNext()) {
84	CatalyticSite cs = (CatalyticSite)it.next();
85	csNums += cs.getSerial();
86	if (it.hasNext()) {
87	csNums += ",";
88	}
89	}
90	}
91	return csNums;
92	}
93
94	public String getCatalSiteChemFunc(int resser) {
95	String csChemFuncs = null;
96	if (resser2catalsite.containsKey(resser)) {
97	csChemFuncs = "";
98	HashSet<CatalyticSite> css = getCatalSite(resser);
99	Iterator<CatalyticSite> it = css.iterator();
100	while (it.hasNext()) {
101	CatalyticSite cs = (CatalyticSite)it.next();
102	csChemFuncs += cs.getChemFuncFromResSerial(resser);
103	if (it.hasNext()) {
104	csChemFuncs += ",";
105	}
106	}
107	}
108	return csChemFuncs;
109	}
110
111	public String getCatalSiteEvid(int resser) {
112	String csEvids = null;
113	if (resser2catalsite.containsKey(resser)) {
114	csEvids = "";
115	HashSet<CatalyticSite> css = getCatalSite(resser);
116	Iterator<CatalyticSite> it = css.iterator();
117	while (it.hasNext()) {
118	CatalyticSite cs = (CatalyticSite)it.next();
119	csEvids += cs.getEvidence();
120	if (it.hasNext()) {
121	csEvids += ",";
122	}
123	}
124	}
125	return csEvids;
126	}
127
128	public void removeCatalSiteRes(int resser) {
129	if (resser2catalsite.containsKey(resser)) {
130	HashSet<CatalyticSite> css = getCatalSite(resser);
131	Iterator<CatalyticSite> it = css.iterator();
132	while (it.hasNext()) {
133	CatalyticSite cs = (CatalyticSite)it.next();
134	cs.remRes(resser);
135	if (cs.getRes().size() == 0) {
136	catalyticSites.remove(cs);
137	}
138	}
139	resser2catalsite.remove(resser);
140	}
141	}
142
143	/** Return a deep copy of this catalytic site set object */
144	public CatalSiteSet copy() {
145	CatalSiteSet newS = new CatalSiteSet();
146	for(CatalyticSite e:catalyticSites) {
147	newS.add(e.copy());
148	}
149	return newS;
150	}
151
152	/** Sets the version to c */
153	public void setVersion(String c) {
154	this.version = c;
155	}
156
157	/** Returns the version */
158	public String getVersion() {
159	return this.version;
160	}
161
162	/** Returns the number of catalytic sites in this catalytic sites set object */
163	public int getNumCatalSites() {
164	return this.catalyticSites.size();
165	}
166
167	public void print() {
168	Iterator<CatalyticSite> iterator = catalyticSites.iterator ();
169	while (iterator.hasNext ()) {
170	CatalyticSite cs = (CatalyticSite)iterator.next();
171	cs.print();
172	}
173	}
174	}