KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > mr > core > util > byteable > ByteableMap


1 /*
2  * Copyright 2002 by
3  * <a HREF="http://www.coridan.com">Coridan</a>
4  * <a HREF="mailto: support@coridan.com ">support@coridan.com</a>
5  *
6  * The contents of this file are subject to the Mozilla Public License Version
7  * 1.1 (the "License"); you may not use this file except in compliance with the
8  * License. You may obtain a copy of the License at
9  * http://www.mozilla.org/MPL/
10  *
11  * Software distributed under the License is distributed on an "AS IS" basis,
12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13  * for the specific language governing rights and limitations under the
14  * License.
15  *
16  * The Original Code is "MantaRay" (TM).
17  *
18  * The Initial Developer of the Original Code is Amir Shevat.
19  * Portions created by the Initial Developer are Copyright (C) 2006
20  * Coridan Inc. All Rights Reserved.
21  *
22  * Contributor(s): all the names of the contributors are added in the source
23  * code where applicable.
24  *
25  * Alternatively, the contents of this file may be used under the terms of the
26  * LGPL license (the "GNU LESSER GENERAL PUBLIC LICENSE"), in which case the
27  * provisions of LGPL are applicable instead of those above. If you wish to
28  * allow use of your version of this file only under the terms of the LGPL
29  * License and not to allow others to use your version of this file under
30  * the MPL, indicate your decision by deleting the provisions above and
31  * replace them with the notice and other provisions required by the LGPL.
32  * If you do not delete the provisions above, a recipient may use your version
33  * of this file under either the MPL or the GNU LESSER GENERAL PUBLIC LICENSE.
34  
35  *
36  * This library is free software; you can redistribute it and/or modify it
37  * under the terms of the MPL as stated above or under the terms of the GNU
38  * Lesser General Public License as published by the Free Software Foundation;
39  * either version 2.1 of the License, or any later version.
40  *
41  * This library is distributed in the hope that it will be useful, but WITHOUT
42  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
43  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
44  * License for more details.
45  */
46 /*
47  * Created on Feb 12, 2004
48  * Manta LTD
49  */
50 package org.mr.core.util.byteable;
51
52 import java.io.IOException JavaDoc;
53
54 import java.util.Collection JavaDoc;
55 import java.util.HashMap JavaDoc;
56 import java.util.Iterator JavaDoc;
57
58
59
60 /**
61  * acts as a map that can be put as payload in the mantaBusMessage and as member of any byteable object
62  * it encapsulates the Serialization of itself in to a disk or network layer.
63  *
64  * when using the layer without an adapter use this class as payload to the mantaBusMessage
65  *
66  * keys and values can be String or in the byteable interface (do not implement the interface if you are not in manta team).
67  * use ByteableMap as value/key if you need to
68  *
69  * @since Feb 12, 2004
70  * @version 1.0
71  * @author Amir Shevat
72  *
73  *
74  */
75 public class ByteableMap implements Byteable {
76     
77     private HashMap JavaDoc content = new HashMap JavaDoc();
78     
79     /**
80      * adds a pair of key- Byteable object value -Byteable object
81      * @param key the key in the map
82      * @param value the value for the key
83      */
84     public synchronized void put(Byteable key , Byteable value){
85         content.put(key , new ByteableMapEntry(key , value) );
86         
87     }
88     /**
89      * adds a pair of key- String object value -Byteable object
90      * @param key the key in the map
91      * @param value the value for the key
92      */
93     public synchronized void put(String JavaDoc key , Byteable value){
94         content.put(key , new ByteableMapEntry(key , value) );
95         
96     }
97     /**
98      * adds a pair of key- String object value -String object
99      * @param key the key in the map
100      * @param value the value for the key
101      */
102     public synchronized void put(String JavaDoc key , String JavaDoc value){
103         content.put(key , new ByteableMapEntry(key , value) );
104         
105     }
106     /**
107      * removes the entry form the map
108      * @param key the key of the entry
109      */
110     public synchronized void remove(Object JavaDoc key){
111         content.remove(key);
112     }
113     
114     /**
115      * returns the value for the given key
116      * @param key the key of the entry
117      * @return the value of the entry of the key
118      */
119     public synchronized Object JavaDoc get(Object JavaDoc key){
120         ByteableMapEntry entry = (ByteableMapEntry)content.get(key);
121         if(entry == null) return null;
122         return entry.getValue();
123     }
124     
125     static final String JavaDoc name = "BMap";
126     /**
127      * @see org.mr.core.util.byteable.Byteable#getByteableName()
128      */
129     public String JavaDoc getByteableName() {
130         return name;
131     }
132
133     /**
134      * @see org.mr.core.util.byteable.Byteable#toBytes(org.mr.core.util.byteable.ByteableOutputStream)
135      */
136     public synchronized void toBytes(ByteableOutputStream out) throws IOException JavaDoc {
137         
138         Collection JavaDoc entries = content.values();
139         int size = entries.size();
140         out.writeInt(size);
141         Iterator JavaDoc iter = entries.iterator();
142         while(iter.hasNext()){
143             ByteableMapEntry entry = (ByteableMapEntry)iter.next();
144             out.writeByteable(entry);
145         }
146         
147     }//toBytes
148
149
150
151     /**
152      * @see org.mr.core.util.byteable.Byteable#createInstance(org.mr.core.util.byteable.ByteableInputStream)
153      */
154     public Byteable createInstance(ByteableInputStream in) throws IOException JavaDoc {
155         ByteableMap result = new ByteableMap();
156         // Byteable -> Byteable
157 int size = in.readInt();
158         for (int i = 0; i < size; i++) {
159             ByteableMapEntry entry =(ByteableMapEntry) in.readByteable();
160             result.content.put(entry.getKey() , entry);
161         }
162         return result;
163     }
164
165     /**
166      * @see org.mr.core.util.byteable.Byteable#registerToByteableRegistry()
167      */
168     public void registerToByteableRegistry() {
169         ByteableRegistry.registerByteableFactory(getByteableName() , this);
170     }
171
172     /**
173      * @return Returns the content.
174      */
175     public HashMap JavaDoc getUnderlineMap() {
176         return content;
177     }
178     /**
179      * not not use
180      *
181      */
182     public static void register(){
183         ByteableMap instance = new ByteableMap();
184         instance.registerToByteableRegistry();
185     }
186     /**
187      * return the underline toString()
188      */
189     public String JavaDoc toString(){
190         return content.toString();
191     }
192
193 }
194
Popular Tags