001: /*
002: This source file is part of Smyle, a database library.
003: For up-to-date information, see http://www.drjava.de/smyle
004: Copyright (C) 2001 Stefan Reich (doc@drjava.de)
005:
006: This library is free software; you can redistribute it and/or
007: modify it under the terms of the GNU Lesser General Public
008: License as published by the Free Software Foundation; either
009: version 2.1 of the License, or (at your option) any later version.
010:
011: This library is distributed in the hope that it will be useful,
012: but WITHOUT ANY WARRANTY; without even the implied warranty of
013: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: Lesser General Public License for more details.
015:
016: You should have received a copy of the GNU Lesser General Public
017: License along with this library; if not, write to the Free Software
018: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
019:
020: For full license text, see doc/license/lgpl.txt in this distribution
021: */
022:
023: package drjava.smyle.core;
024:
025: import java.util.*;
026: import java.io.*;
027: import org.artsProject.mcop.*;
028: import org.artsProject.util.*;
029: import drjava.smyle.*;
030: import drjava.smyle.meta.*;
031:
032: class FieldBasedDemarshaller<T extends Struct<T>> implements
033: Demarshaller<T> {
034: TypeInfo<T> typeInfo;
035: ArrayList<FieldReader> fieldReaders = new ArrayList<FieldReader>();
036:
037: abstract class FieldReader {
038: abstract void readField(Buffer buffer, T t);
039: }
040:
041: FieldBasedDemarshaller(TypeInfo<T> typeInfo) {
042: this .typeInfo = typeInfo;
043: }
044:
045: void addFieldReader(FieldReader fr) {
046: fieldReaders.add(fr);
047: }
048:
049: void addLongField(final int nr) {
050: class LongReader extends FieldReader {
051: public void readField(Buffer buffer, T t) {
052: int v = buffer.readLong();
053: if (nr >= 0)
054: t.setField(nr, new Integer(v));
055: }
056: }
057: fieldReaders.add(new LongReader());
058: }
059:
060: void addLongLongField(final int nr) {
061: class LongLongReader extends FieldReader {
062: public void readField(Buffer buffer, T t) {
063: long v = buffer.readLongLong();
064: if (nr >= 0)
065: t.setField(nr, new Long(v));
066: }
067: }
068: fieldReaders.add(new LongLongReader());
069: }
070:
071: void addBooleanField(final int nr) {
072: class BooleanReader extends FieldReader {
073: public void readField(Buffer buffer, T t) {
074: boolean v = buffer.readBoolean();
075: if (nr >= 0)
076: t.setField(nr, v ? ComparableBoolean.TRUE
077: : ComparableBoolean.FALSE);
078: }
079: }
080: fieldReaders.add(new BooleanReader());
081: }
082:
083: void addStringField(final int nr) {
084: class StringReader extends FieldReader {
085: public void readField(Buffer buffer, T t) {
086: String v = buffer.readString();
087: if (nr >= 0)
088: t.setField(nr, v);
089: }
090: }
091: fieldReaders.add(new StringReader());
092: }
093:
094: <A extends Struct<A>> void addStructField(final int nr,
095: final TypeInfo<A> type) {
096: class StructReader extends FieldReader {
097: public void readField(Buffer buffer, T t) {
098: A v = type.demarshaller.read(buffer);
099: if (nr >= 0)
100: t.setField(nr, v);
101: }
102: }
103: fieldReaders.add(new StructReader());
104: }
105:
106: <A> void addSequenceField(final int nr,
107: final Demarshaller<A> demarshaller) {
108: class SequenceReader extends FieldReader {
109: public void readField(Buffer buffer, T t) {
110: ArrayList<A> v = new ArrayList<A>();
111: MCOP.readSeq(buffer, v, demarshaller);
112: if (nr >= 0)
113: t.setField(nr, v);
114: }
115: }
116: fieldReaders.add(new SequenceReader());
117: }
118:
119: <A> void addDemarshallerField(final int nr,
120: final Demarshaller<A> demarshaller) {
121: class DemarshallerReader extends FieldReader {
122: public void readField(Buffer buffer, T t) {
123: A a = demarshaller.read(buffer);
124: if (nr >= 0)
125: t.setField(nr, a);
126: }
127: }
128: fieldReaders.add(new DemarshallerReader());
129: }
130:
131: void addStringSequenceField(final int nr) {
132: class StringSequenceReader extends FieldReader {
133: public void readField(Buffer buffer, T t) {
134: ArrayList<String> v = new ArrayList<String>();
135: MCOP.readSeq(buffer, v);
136: if (nr >= 0)
137: t.setField(nr, v);
138: }
139: }
140: fieldReaders.add(new StringSequenceReader());
141: }
142:
143: void addByteSequenceField(final int nr) {
144: class ByteSequenceReader extends FieldReader {
145: public void readField(Buffer buffer, T t) {
146: ByteVector v = new ByteVector();
147: MCOP.readSeq(buffer, v);
148: if (nr >= 0)
149: t.setField(nr, v);
150: }
151: }
152: fieldReaders.add(new ByteSequenceReader());
153: }
154:
155: void addLongSequenceField(final int nr) {
156: class LongSequenceReader extends FieldReader {
157: public void readField(Buffer buffer, T t) {
158: IntVector v = new IntVector();
159: MCOP.readSeq(buffer, v);
160: if (nr >= 0)
161: t.setField(nr, v);
162: }
163: }
164: fieldReaders.add(new LongSequenceReader());
165: }
166:
167: public T read(Buffer stream) throws MCOPException {
168: try {
169: // create instance
170: T t = (T) typeInfo.structClass.newInstance(); // compiler warning ok
171:
172: // read and set fields
173: for (int i = 0; i < fieldReaders.size(); i++) {
174: //System.out.println(i+": "+fieldReaders.get(i));
175: fieldReaders.get(i).readField(stream, t);
176: }
177:
178: // return
179: return t; // TODO
180: } catch (InstantiationException e) {
181: throw new MCOPException(e);
182: } catch (IllegalAccessException e) {
183: throw new MCOPException(e);
184: }
185: }
186: }
|