KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > objectweb > jorm > facility > naming > basidir > BasidBinder


1 /**
2  * JORM: an implementation of a generic mapping system for persistent Java
3  * objects. Two mapping are supported: to RDBMS and to binary files.
4  * Copyright (C) 2001-2003 France Telecom R&D - INRIA
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  * Contact: jorm-team@objectweb.org
21  *
22  */

23
24 package org.objectweb.jorm.facility.naming.basidir;
25
26 import org.objectweb.jorm.api.PBinding;
27 import org.objectweb.jorm.api.PClassMapping;
28 import org.objectweb.jorm.api.PException;
29 import org.objectweb.jorm.api.PExceptionProtocol;
30 import org.objectweb.jorm.api.PMapper;
31 import org.objectweb.jorm.api.PStateGraph;
32 import org.objectweb.jorm.api.PBindingCtrl;
33 import org.objectweb.jorm.facility.naming.generator.LongGen;
34 import org.objectweb.jorm.facility.naming.generator.LongGenMgr;
35 import org.objectweb.jorm.facility.naming.generator.LongGenMgrRegistry;
36 import org.objectweb.jorm.naming.api.PBinder;
37 import org.objectweb.jorm.naming.api.PExceptionExistingName;
38 import org.objectweb.jorm.naming.api.PExceptionNaming;
39 import org.objectweb.jorm.naming.api.PName;
40 import org.objectweb.jorm.naming.api.PNamingContext;
41 import org.objectweb.jorm.type.api.PType;
42 import org.objectweb.perseus.cache.api.CacheManager;
43 import org.objectweb.perseus.cache.api.CacheEntry;
44 import org.objectweb.perseus.cache.api.CacheException;
45 import org.objectweb.perseus.cache.api.FixableCacheEntry;
46
47 import java.util.Date JavaDoc;
48 import java.math.BigInteger JavaDoc;
49 import java.math.BigDecimal JavaDoc;
50
51 /**
52  *
53  * @author Sebastien Chassande-Barrioz
54  */

55 public class BasidBinder implements PBinder, PNamingContext {
56     // Static binding to LongGenIncrMgr: TO BE REMOVED
57
private final static String JavaDoc LONGGENMGRCLASS
58             = "org.objectweb.jorm.facility.naming.generator.LongGenIncr";
59     protected int codingType = -1;
60     protected Object JavaDoc nullOValue = null;
61     protected long nullValue = -1;
62     PName PNNULL = null;
63     PName PNONULL = null;
64     protected PType ptype = null;
65     protected PClassMapping pcm = null;
66     private CacheManager bindingcache = null;
67     private LongGen longGen = null;
68
69     public BasidBinder() {
70     }
71
72     public BasidBinder(PMapper m, String JavaDoc genname, byte clact) throws PException {
73         this();
74         LongGenMgr lgm;
75         // LongGen initialization
76
synchronized (LongGenMgrRegistry.class) {
77             lgm = LongGenMgrRegistry.getLongGenMgr(m);
78             if (lgm == null) {
79                 try {
80                     lgm = (LongGenMgr) Class.forName(
81                             m.cn2mn(LONGGENMGRCLASS) + PMapper.PCLASSMAPPINGAPPENDER)
82                             .newInstance();
83                 } catch (InstantiationException JavaDoc e) {
84                     throw new PException(e, "Cannot create LongGenMgr: cannot instanciate.");
85                 } catch (IllegalAccessException JavaDoc e) {
86                     throw new PException(e, "Cannot create LongGenMgr: cannot access.");
87                 } catch (ClassNotFoundException JavaDoc e) {
88                     throw new PException(e, "Cannot create LongGenMgr: cannot load.");
89                 }
90                 lgm.init(m, clact);
91                 LongGenMgrRegistry.registerLonGenMgr(lgm);
92             }
93         }
94         longGen = lgm.getLongGen(genname);
95         codingType = PNamingContext.CTLONG;
96         nullValue = -1;
97     }
98
99     public BasidBinder(int codingtype) {
100         this();
101         codingType = codingtype;
102     }
103
104     public BasidBinder(int codingtype, Object JavaDoc nullValue) {
105         this();
106         codingType = codingtype;
107         this.nullOValue = nullValue;
108     }
109
110     public BasidBinder(int codingtype, long nullValue) {
111         this();
112         codingType = codingtype;
113         this.nullValue = nullValue;
114     }
115
116     public int getCodingType() {
117         return codingType;
118     }
119
120     public void setCodingType(int codingType) {
121         this.codingType = codingType;
122     }
123
124     public void setNulOValue(Object JavaDoc nullvalue) {
125         this.nullOValue = nullvalue;
126     }
127
128     public void setNulValue(long nullvalue) {
129         this.nullValue = nullvalue;
130     }
131     //IMPLEMENTATION OF THE PNamingContext INTERFACE //
132
//-----------------------------------------------//
133

134     public boolean codingSupported(int codingtype) {
135         return codingtype == codingType;
136     }
137
138     public PName decode(byte[] en) throws PExceptionNaming {
139         return new BasidName(en, this);
140     }
141
142     public PName decodeAbstract(Object JavaDoc en, Object JavaDoc context) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
143         return new BasidName(en, this);
144     }
145
146     public PName decodeByte(byte en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
147         return new BasidName(en, this);
148     }
149
150     public PName decodeObyte(Byte JavaDoc en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
151         return new BasidName(en, this);
152     }
153
154     public PName decodeChar(char en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
155         return new BasidName(en, this);
156     }
157
158     public PName decodeOchar(Character JavaDoc en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
159         return new BasidName(en, this);
160     }
161
162     public PName decodeInt(int en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
163         return new BasidName(en, this);
164     }
165
166     public PName decodeOint(Integer JavaDoc en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
167         return new BasidName(en, this);
168     }
169
170     public PName decodeLong(long en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
171         return new BasidName(en, this);
172     }
173
174     public PName decodeOlong(Long JavaDoc en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
175         return new BasidName(en, this);
176     }
177
178     public PName decodeShort(short en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
179         return new BasidName(en, this);
180     }
181
182     public PName decodeOshort(Short JavaDoc en) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
183         return new BasidName(en, this);
184     }
185
186     public PName decodeString(String JavaDoc en) throws PExceptionNaming {
187         switch (codingType) {
188         case PNamingContext.CTBYTE:
189         case PNamingContext.CTCHAR:
190         case PNamingContext.CTSHORT:
191         case PNamingContext.CTINT:
192         case PNamingContext.CTLONG:
193             return new BasidName(Long.parseLong(en), this);
194         }
195         return new BasidName(en, this);
196     }
197
198     public PName decodeCharArray(char[] en) throws PExceptionNaming {
199         return new BasidName(en, this);
200     }
201
202     public PName decodeDate(Date JavaDoc en) throws PExceptionNaming {
203         return new BasidName(en, this);
204     }
205
206     public PName decodeBigInteger(BigInteger JavaDoc en) throws PExceptionNaming {
207         return new BasidName(en, this);
208     }
209
210     public PName decodeBigDecimal(BigDecimal JavaDoc en) throws PExceptionNaming {
211         return new BasidName(en, this);
212     }
213
214     public byte[] encode(PName pn) throws PExceptionNaming {
215         if (pn.isNull())
216             return (byte[]) nullOValue;
217         if (codingType == PNamingContext.CTBYTEARRAY)
218             return (byte[]) ((BasidName) pn).o;
219         throw new PExceptionNaming("Unsupported coding type");
220     }
221
222     public Object JavaDoc encodeAbstract(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
223         return (BasidName) pn;
224     }
225
226     public byte encodeByte(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
227         if (pn.isNull())
228             return (byte) nullValue;
229         if (codingType == CTBYTE)
230             return (byte) ((BasidName) pn).p;
231         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
232     }
233
234     public Byte JavaDoc encodeObyte(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
235         if (pn.isNull())
236             return (Byte JavaDoc) nullOValue;
237         if (codingType == CTOBYTE)
238             return (Byte JavaDoc) ((BasidName) pn).o;
239         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
240     }
241
242     public char encodeChar(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
243         if (pn.isNull())
244             return (char) nullValue;
245         if (codingType == CTCHAR)
246             return (char) ((BasidName) pn).p;
247         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
248     }
249
250     public Character JavaDoc encodeOchar(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
251         if (pn.isNull())
252             return (Character JavaDoc) nullOValue;
253         if (codingType == CTOCHAR)
254             return (Character JavaDoc) ((BasidName) pn).o;
255         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
256     }
257
258     public int encodeInt(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
259         if (pn.isNull())
260             return (int) nullValue;
261         if (codingType == CTINT)
262             return (int) ((BasidName) pn).p;
263         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
264     }
265
266     public Integer JavaDoc encodeOint(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
267         if (pn.isNull())
268             return (Integer JavaDoc) nullOValue;
269         if (codingType == CTOINT)
270             return (Integer JavaDoc) ((BasidName) pn).o;
271         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
272     }
273
274     public long encodeLong(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
275         if (pn.isNull())
276             return nullValue;
277         if (codingType == CTLONG)
278             return ((BasidName) pn).p;
279         System.err.println("CT=" + codingType);
280         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
281     }
282
283     public Long JavaDoc encodeOlong(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
284         if (pn.isNull())
285             return (Long JavaDoc) nullOValue;
286         if (codingType == CTOLONG)
287             return (Long JavaDoc) ((BasidName) pn).o;
288         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
289     }
290
291     public short encodeShort(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
292         if (pn.isNull())
293             return (short) nullValue;
294         if (codingType == CTSHORT)
295             return (short) ((BasidName) pn).p;
296         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
297     }
298
299     public Short JavaDoc encodeOshort(PName pn) throws PExceptionNaming, UnsupportedOperationException JavaDoc {
300         if (pn.isNull())
301             return (Short JavaDoc) nullOValue;
302         if (codingType == CTOSHORT)
303             return (Short JavaDoc) ((BasidName) pn).o;
304         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
305     }
306
307     public String JavaDoc encodeString(PName pn) throws PExceptionNaming {
308         if (pn.isNull())
309             return null;
310         switch (codingType) {
311         case CTBYTE:
312         case CTCHAR:
313         case CTINT:
314         case CTLONG:
315         case CTSHORT:
316             return Long.toString(((BasidName) pn).p);
317         case CTOBYTE:
318         case CTOCHAR:
319         case CTOINT:
320         case CTOLONG:
321         case CTOSHORT:
322         case CTSTRING:
323         case CTBIGINTEGER:
324         case CTBIGDECIMAL:
325             return ((BasidName) pn).o.toString();
326         case CTDATE:
327             return "" + ((Date JavaDoc) ((BasidName) pn).o).getTime();
328         }
329         return "?";
330     }
331
332     public char[] encodeCharArray(PName pn) throws PExceptionNaming {
333         if (pn.isNull())
334             return (char[]) nullOValue;
335         if (codingType == CTCHARARRAY)
336             return (char[]) ((BasidName) pn).o;
337         throw new PExceptionNaming("Unsupported coding type, expected: " + codingType);
338     }
339
340     public Date JavaDoc encodeDate(PName pn) throws PExceptionNaming {
341         if (pn.isNull())
342             return (Date JavaDoc) nullOValue;
343         if (codingType == CTDATE)
344             return (Date JavaDoc) ((BasidName) pn).o;
345         throw new PExceptionNaming("[" + getClassName() + "]: unsupported coding type");
346     }
347
348     public BigInteger JavaDoc encodeBigInteger(PName pn) throws PExceptionNaming {
349         if (pn.isNull())
350             return (BigInteger JavaDoc) nullOValue;
351         if (codingType == CTBIGINTEGER)
352             return (BigInteger JavaDoc) ((BasidName) pn).o;
353         throw new PExceptionNaming("[" + getClassName() + "]: unsupported coding type");
354     }
355
356     public BigDecimal JavaDoc encodeBigDecimal(PName pn) throws PExceptionNaming {
357         if (pn.isNull())
358             return (BigDecimal JavaDoc) nullOValue;
359         if (codingType == CTBIGDECIMAL)
360             return (BigDecimal JavaDoc) ((BasidName) pn).o;
361         throw new PExceptionNaming("[" + getClassName() + "]: unsupported coding type");
362     }
363
364     public PName export(Object JavaDoc conn, Object JavaDoc en) throws PException {
365         PName pn = null;
366         if (en == null) {
367             throw new PExceptionNaming("[" + getClassName() + "]: cannot export null!");
368         }
369         if (en instanceof BasidName) {
370             if (((PName) en).getPNameManager() == this) {
371                 return (PName) en;
372             } else {
373                 return new BasidName(en, this);
374             }
375         }
376         PBindingCtrl pb = (PBindingCtrl) en;
377         byte nextstate = PStateGraph.nextStatePBinding(pb.getStatus(),
378                                                        PBinding.ACTION_EXPORT);
379         if (nextstate == PBinding.LIFECYCLE_ERROR)
380             throw new PExceptionProtocol("Export unauthorized operation, current status:" + pb.getStatus());
381         // Performs the transition
382
if (longGen == null) {
383             throw new PExceptionNaming("[" + getClassName() + "]: export not supported by this binder with no generator.");
384         }
385         pn = new BasidName(longGen.genId(conn), this);
386         if (bindingcache != null) {
387             synchronized (bindingcache) {
388                 if (bindingcache.lookup(pn) != null) {
389                     throw new PExceptionExistingName(
390                             "[" + getClassName() + "]: an object has been already export with the same identifier");
391                 }
392                 try {
393                     bindingcache.fix(bindingcache.bind(pn, en));
394                 } catch (CacheException e) {
395                     throw new PException(e, "[" + getClassName() + "]: problem with cache management");
396                 }
397             }
398         }
399         pb.setPName(pn);
400         pb.setStatus(nextstate);
401         return pn;
402     }
403
404     public PName export(Object JavaDoc conn, Object JavaDoc en, Object JavaDoc hints) throws PException {
405         PName pn = null;
406         if (en == null) {
407             throw new PExceptionNaming("[" + getClassName() + "]: cannot export null!");
408         }
409         if (en instanceof PName && ((PName) en).getPNameManager() == this)
410             return (PName) en;
411         PBindingCtrl pb = (PBindingCtrl) en;
412         byte nextstate = PStateGraph.nextStatePBinding(pb.getStatus(),
413                                                        PBinding.ACTION_EXPORT);
414         if (nextstate == PBinding.LIFECYCLE_ERROR)
415             throw new PExceptionProtocol("Export unauthorized operation, current status:" + pb.getStatus());
416         // Performs the transition
417
if (longGen != null) {
418             throw new PExceptionNaming("[" + getClassName() + "]: export with hints not support by this generator binder.");
419         }
420         if (en instanceof BasidName
421                 && ((PName) en).getPNameManager().equals(this)) {
422             return (PName) en;
423         }
424         if (!(en instanceof PBinding)) {
425             throw new PExceptionNaming("[" + getClassName() + "]: the item cannot be exported by this binder (PName or PBinding only): " + en);
426         }
427         if (hints != null) {
428             pn = new BasidName(hints, this);
429         } else {
430             throw new PExceptionNaming(
431                     "[" + getClassName() + "]: this item cannot be exported by this binder");
432         }
433         if (bindingcache != null) {
434             synchronized (bindingcache) {
435                 if (bindingcache.lookup(pn) != null) {
436                     throw new PExceptionExistingName(
437                             "[" + getClassName() + "]: an object has been already export with the same identifier");
438                 }
439                 try {
440                     bindingcache.fix(bindingcache.bind(pn, en));
441                 } catch (CacheException e) {
442                     throw new PException(e, "[" + getClassName() + "]: problem with cache management");
443                 }
444             }
445         }
446         pb.setPName(pn);
447         pb.setStatus(nextstate);
448         return pn;
449     }
450
451     public PName getNull() {
452         switch (codingType) {
453         case CTBYTE:
454         case CTINT:
455         case CTLONG:
456         case CTSHORT:
457             return PNNULL;
458         case CTOBYTE:
459         case CTOCHAR:
460         case CTOINT:
461         case CTOLONG:
462         case CTOSHORT:
463         case CTSTRING:
464         case CTDATE:
465             return PNONULL;
466         case CTCHAR:
467             return PNNULL;
468         default:
469             return PNONULL;
470         }
471     }
472
473     /**
474      * It defines the null PName since a BasidName or an object value
475      * If the encoding is an object format the given value will be the null
476      * encoded valued. Otherwise if the encoded format is a primitive value
477      * then a object value matching to the primitive type is expected:
478      * byte ==> a java.lang.Byte is expected
479      * short ==> a java.lang.Short is expected
480      * ...
481      * @param o
482      */

483     public void setNullPName(Object JavaDoc o) {
484         if (o == null) {
485             nullOValue = o;
486         } else if (o instanceof BasidName) {
487             nullOValue = ((BasidName) o).o;
488             nullValue = ((BasidName) o).p;
489         } else {
490             nullOValue = o;
491             if (o instanceof Byte JavaDoc) {
492                 nullValue = ((Byte JavaDoc) o).byteValue();
493             } else if (o instanceof Short JavaDoc) {
494                 nullValue = ((Short JavaDoc) o).shortValue();
495             } else if (o instanceof Integer JavaDoc) {
496                 nullValue = ((Integer JavaDoc) o).intValue();
497             } else if (o instanceof Long JavaDoc) {
498                 nullValue = ((Long JavaDoc) o).longValue();
499             } else if (o instanceof Character JavaDoc) {
500                 nullValue = ((Character JavaDoc) o).charValue();
501             }
502         }
503     }
504
505     public PType getPType() {
506         return ptype;
507     }
508
509     public String JavaDoc getClassName() {
510         return ptype.getJormName();
511     }
512
513     public PName resolve(Object JavaDoc conn, PName pn) throws PException {
514         if (pn == null) {
515             throw new PExceptionNaming("[" + getClassName() + "]: this pname is null");
516         }
517         if (!pn.getPNameManager().equals(this))
518             throw new PExceptionNaming("[" + getClassName() + "]: this pname is not valid in this binder");
519         return pn;
520     }
521
522     public void setPType(PType pt) {
523         ptype = pt;
524     }
525
526     public boolean supportDynamicComposite() {
527         return false;
528     }
529
530     public boolean supportCompositeField(String JavaDoc fn, PType ft) {
531         return false;
532     }
533
534     public boolean supportStaticComposite() {
535         return false;
536     }
537
538     public void unexport(Object JavaDoc conn, PName pn) throws PException {
539         if (pn.isNull()) {
540             throw new PExceptionProtocol("[" + getClassName() + "]: cannot unexport with a null pname.");
541         }
542         if (bindingcache != null) {
543             PBindingCtrl pb = null;
544             CacheEntry ce = bindingcache.lookup(pn);
545             if (ce != null) {
546                 pb = (PBindingCtrl) ce.getCeObject();
547             }
548             if (pb == null) {
549                 throw new PExceptionProtocol("Unauthorized operation: No Pbinding found");
550             }
551             byte nextstate = PStateGraph.nextStatePBinding(
552                     pb.getStatus(), PBinding.ACTION_UNEXPORT);
553             if (nextstate == PBinding.LIFECYCLE_ERROR) {
554                 throw new PExceptionProtocol("Unauthorized operation: status =" + pb.getStatus());
555             }
556             pb.setStatus(nextstate);
557         } else {
558             throw new PExceptionProtocol("Unauthorized operation: No Pbinding can be found without a CacheManager");
559         }
560     }
561
562     public void unexport(Object JavaDoc conn, PName pn, Object JavaDoc hints) throws PException {
563         if (pn.isNull()) {
564             throw new PExceptionProtocol("[" + getClassName() + "]: cannot unexport with a null pname.");
565         }
566         PBindingCtrl pb = null;
567         if (hints instanceof PBindingCtrl) {
568             pb = (PBindingCtrl) hints;
569         } else if (bindingcache != null) {
570             CacheEntry ce = bindingcache.lookup(pn);
571             if (ce != null) {
572                 pb = (PBindingCtrl) ce.getCeObject();
573             }
574         }
575         if (pb == null) {
576             throw new PExceptionProtocol("Unauthorized operation: No Pbinding found");
577         }
578         byte nextstate = PStateGraph.nextStatePBinding(
579                 pb.getStatus(), PBinding.ACTION_UNEXPORT);
580         if (nextstate == PBinding.LIFECYCLE_ERROR) {
581             throw new PExceptionProtocol("Unauthorized operation: status =" + pb.getStatus());
582         }
583         pb.setStatus(nextstate);
584     }
585
586     // IMPLEMENTATION OF METHODS FROM THE PBinder INTERFACE
587

588     public PBinding lookup(PName pn) throws PException {
589         if (pn == null) {
590             throw new PExceptionNaming("[" + getClassName() + "]: this pname is null");
591         }
592         if (pn.isNull()) {
593             return null;
594         }
595         if (bindingcache == null) {
596             throw new PExceptionProtocol("No internal cache: should be managed externally!");
597         }
598         CacheEntry ce = bindingcache.lookup(pn);
599         if (ce != null) {
600             return (PBinding) ce.getCeObject();
601         }
602         return null;
603     }
604
605     public void bind(PName pn, PBindingCtrl pb) throws PException {
606         if (pn == null)
607             throw new PExceptionNaming("[" + getClassName() + "]: this pname is null");
608         if (pb == null)
609             throw new PExceptionNaming("[" + getClassName() + "]: this pbinding is null");
610         if (!(pn instanceof BasidName))
611             throw new PExceptionNaming("Can only bind CustomerPkPName");
612         if (!pn.getPNameManager().equals(this))
613             throw new PExceptionNaming("[" + getClassName() + "]: this pname is not valid in this binder ("
614                                        + ", \nthis:" + this
615                                        + ", \nthis.type:" + this.getPType().getJormName()
616                                        + ", \nthis.pcm:" + this.getBinderClassMapping()
617                                        + ", \npn.pnc: " + pn.getPNameManager()
618                                        + ", \npn.pnc.type: " + pn.getPNameManager().getPType().getJormName()
619                                        + ", \npn.pnc.pcm: " + ((PBinder) pn.getPNameManager()).getBinderClassMapping()
620                                        + ", \npn:" + pn + ")");
621         if (!pb.getPClassMapping().equals(pcm))
622             throw new PExceptionNaming("[" + getClassName() + "]: this pbinding is not valid in this binder");
623         if (pn.isNull())
624             throw new PExceptionNaming("[" + getClassName() + "]: this PName represent the null value");
625         byte nextstate = PStateGraph.nextStatePBinding(pb.getStatus(),
626                                                        PBinding.ACTION_BIND);
627         // Performs the transition
628
if (bindingcache != null) {
629             synchronized (bindingcache) {
630                 try {
631                     bindingcache.fix(bindingcache.bind(pn, pb));
632                 } catch (CacheException e) {
633                     throw new PException(e, "[" + getClassName() + "]: problem with cache management");
634                 }
635             }
636         }
637         pb.setPName(pn);
638         pb.setStatus(nextstate);
639     }
640
641     public PClassMapping getBinderClassMapping() {
642         return pcm;
643     }
644
645     public void unbind(PBindingCtrl pb) throws PException {
646         byte nextstate = PStateGraph.nextStatePBinding(pb.getStatus(),
647                                                        PBinding.ACTION_UNBIND);
648         // If the state does not change, do nothing
649
if (nextstate == pb.getStatus())
650             return;
651         // Perform the transition
652
if (pb == null)
653             throw new PExceptionNaming("[" + getClassName() + "]: this pbinding is null");
654         PName pn = pb.getPName();
655         if (pn == null)
656             throw new PExceptionNaming("[" + getClassName() + "]: this PBinding is not bounded with a pname");
657         if (!pb.getPClassMapping().equals(pcm))
658             throw new PExceptionNaming("[" + getClassName() + "]: this pbinding is not valid in this binder");
659         if (bindingcache != null) {
660             synchronized (bindingcache) {
661                 try {
662                     if (((FixableCacheEntry) bindingcache).getCeFixCount() == 0) {
663                         // the cache replacement has decided to remove this entry
664
pb.setPName(null);
665                         pb.setStatus(nextstate);
666                     } else {
667                         // this entry becomes eligeable for replacement
668
CacheEntry ce = bindingcache.lookup(pn);
669                         if (ce != null) {
670                             bindingcache.unfix(ce);
671                         }
672                     }
673                 } catch (CacheException e) {
674                     throw new PException(e, "[" + getClassName() + "]: problem with cache management");
675                 }
676             }
677         } else {
678             pb.setPName(null);
679             pb.setStatus(nextstate);
680         }
681     }
682
683     /**
684      * Returns the cache manager associated with this binder.
685      * @return The cache manager.
686      */

687     public CacheManager getCacheManager() {
688         return bindingcache;
689     }
690
691     /**
692      * Assigns the cache manager associated with this binder.
693      * @param cm The cache manager.
694      * @throws PException
695      */

696     public void setCacheManager(CacheManager cm) throws PException {
697         bindingcache = cm;
698     }
699
700     // IMPLEMENTATION OF METHODS FROM THE PBinder INTERFACE
701

702     public void setPClassMapping(PClassMapping pcm) {
703         this.pcm = pcm;
704         try {
705             switch (codingType) {
706             case CTBYTE:
707             case CTCHAR:
708             case CTINT:
709             case CTLONG:
710             case CTSHORT:
711                 PNNULL = new BasidName(nullValue, this);
712                 break;
713             default:
714                 PNONULL = new BasidName(nullOValue, this);
715             }
716         } catch (PExceptionNaming pn) {
717             // There is no chance having this exception when creation NULL PName
718
System.out.println("Very strange problem: this exception should really never happen!!");
719             pn.printStackTrace();
720         }
721     }
722 }
723
Popular Tags