001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: */
019: package org.apache.openjpa.kernel;
020:
021: import java.io.IOException;
022: import java.io.ObjectOutput;
023: import java.io.Serializable;
024: import java.util.BitSet;
025: import java.util.Collection;
026: import java.util.Map;
027:
028: import org.apache.openjpa.enhance.PersistenceCapable;
029: import org.apache.openjpa.enhance.StateManager;
030: import org.apache.openjpa.lib.util.Localizer;
031: import org.apache.openjpa.lib.util.concurrent.ReentrantLock;
032: import org.apache.openjpa.meta.ClassMetaData;
033: import org.apache.openjpa.meta.FieldMetaData;
034: import org.apache.openjpa.meta.JavaTypes;
035: import org.apache.openjpa.meta.ValueMetaData;
036: import org.apache.openjpa.util.Exceptions;
037: import org.apache.openjpa.util.Proxy;
038: import org.apache.openjpa.util.UnsupportedException;
039: import org.apache.openjpa.util.ImplHelper;
040:
041: /**
042: * Internal state manager for detached instances. Does not fully
043: * implement {@link OpenJPAStateManager} contract to allow for serialization.
044: *
045: * @author Steve Kim
046: * @nojavadoc
047: */
048: public class DetachedStateManager extends AttachStrategy implements
049: OpenJPAStateManager, Serializable {
050:
051: private static final Localizer _loc = Localizer
052: .forPackage(DetachedStateManager.class);
053:
054: private final PersistenceCapable _pc;
055: private final boolean _embedded;
056: private final boolean _access;
057: private final BitSet _loaded;
058: private final BitSet _dirty;
059: private final Object _oid;
060: private final Object _version;
061: private final ReentrantLock _lock;
062:
063: /**
064: * Constructor.
065: *
066: * @param pc the managed instance
067: * @param sm the instance's state manager
068: * @param load the set of detached field indexes
069: * @param access whether to allow access to unloaded fields
070: * @param multithreaded whether the instance will be used concurrently
071: * by multiple threads
072: */
073: public DetachedStateManager(PersistenceCapable pc,
074: OpenJPAStateManager sm, BitSet load, boolean access,
075: boolean multithreaded) {
076: _pc = pc;
077: _embedded = sm.isEmbedded();
078: _loaded = load;
079: _access = access;
080: _dirty = new BitSet(_loaded.length());
081: _oid = sm.fetchObjectId();
082: _version = sm.getVersion();
083: if (multithreaded)
084: _lock = new ReentrantLock();
085: else
086: _lock = null;
087: }
088:
089: /////////////////////////////////
090: // AttachStrategy implementation
091: /////////////////////////////////
092:
093: public Object attach(AttachManager manager, Object toAttach,
094: ClassMetaData meta, PersistenceCapable into,
095: OpenJPAStateManager owner, ValueMetaData ownerMeta,
096: boolean explicit) {
097: BrokerImpl broker = manager.getBroker();
098: StateManagerImpl sm;
099: if (_embedded) {
100: if (_dirty.length() > 0)
101: owner.dirty(ownerMeta.getFieldMetaData().getIndex());
102: sm = (StateManagerImpl) broker.embed(_pc, _oid, owner,
103: ownerMeta);
104: ImplHelper.toPersistenceCapable(toAttach,
105: broker.getConfiguration()).pcReplaceStateManager(
106: this );
107: } else {
108: PCState state = (_dirty.length() > 0) ? PCState.PDIRTY
109: : PCState.PCLEAN;
110: sm = (StateManagerImpl) broker.copy(this , state);
111: }
112: PersistenceCapable pc = sm.getPersistenceCapable();
113: manager.setAttachedCopy(toAttach, pc);
114:
115: manager.fireBeforeAttach(toAttach, meta);
116:
117: // pre-load for efficiency: current field values for restore, dependent
118: // for delete
119: FieldMetaData[] fields = meta.getFields();
120: int restore = broker.getRestoreState();
121: if (_dirty.length() > 0) {
122: BitSet load = new BitSet(fields.length);
123: for (int i = 0; i < fields.length; i++) {
124: if (!_dirty.get(i))
125: continue;
126:
127: switch (fields[i].getDeclaredTypeCode()) {
128: case JavaTypes.ARRAY:
129: case JavaTypes.COLLECTION:
130: if (restore == RestoreState.RESTORE_ALL
131: || fields[i].getElement()
132: .getCascadeDelete() == ValueMetaData.CASCADE_AUTO)
133: load.set(i);
134: break;
135: case JavaTypes.MAP:
136: if (restore == RestoreState.RESTORE_ALL
137: || fields[i].getElement()
138: .getCascadeDelete() == ValueMetaData.CASCADE_AUTO
139: || fields[i].getKey().getCascadeDelete() == ValueMetaData.CASCADE_AUTO)
140: load.set(i);
141: break;
142: default:
143: if (restore != RestoreState.RESTORE_NONE
144: || fields[i].getCascadeDelete() == ValueMetaData.CASCADE_AUTO)
145: load.set(i);
146: }
147: }
148: FetchConfiguration fc = broker.getFetchConfiguration();
149: sm.loadFields(load, fc, fc.getWriteLockLevel(), null);
150: }
151: Object origVersion = sm.getVersion();
152: sm.setVersion(_version);
153:
154: BitSet loaded = sm.getLoaded();
155: int set = StateManager.SET_ATTACH;
156: for (int i = 0; i < fields.length; i++) {
157: if (!_loaded.get(i))
158: continue;
159: // don't reload already loaded non-mutable objects
160: if (!_dirty.get(i) && loaded.get(i)
161: && ignoreLoaded(fields[i]))
162: continue;
163:
164: provideField(i);
165: switch (fields[i].getDeclaredTypeCode()) {
166: case JavaTypes.BOOLEAN:
167: if (_dirty.get(i))
168: sm.settingBooleanField(pc, i, (loaded.get(i))
169: && sm.fetchBooleanField(i), longval == 1,
170: set);
171: else
172: sm.storeBooleanField(i, longval == 1);
173: break;
174: case JavaTypes.BYTE:
175: if (_dirty.get(i))
176: sm.settingByteField(pc, i,
177: (!loaded.get(i)) ? (byte) 0 : sm
178: .fetchByteField(i), (byte) longval,
179: set);
180: else
181: sm.storeByteField(i, (byte) longval);
182: break;
183: case JavaTypes.CHAR:
184: if (_dirty.get(i))
185: sm.settingCharField(pc, i,
186: (!loaded.get(i)) ? (char) 0 : sm
187: .fetchCharField(i), (char) longval,
188: set);
189: else
190: sm.storeCharField(i, (char) longval);
191: break;
192: case JavaTypes.INT:
193: if (_dirty.get(i))
194: sm.settingIntField(pc, i, (!loaded.get(i)) ? 0 : sm
195: .fetchIntField(i), (int) longval, set);
196: else
197: sm.storeIntField(i, (int) longval);
198: break;
199: case JavaTypes.LONG:
200: if (_dirty.get(i))
201: sm.settingLongField(pc, i, (!loaded.get(i)) ? 0L
202: : sm.fetchLongField(i), longval, set);
203: else
204: sm.storeLongField(i, longval);
205: break;
206: case JavaTypes.SHORT:
207: if (_dirty.get(i))
208: sm.settingShortField(pc, i,
209: (!loaded.get(i)) ? (short) 0 : sm
210: .fetchShortField(i),
211: (short) longval, set);
212: else
213: sm.storeShortField(i, (short) longval);
214: break;
215: case JavaTypes.FLOAT:
216: if (_dirty.get(i))
217: sm.settingFloatField(pc, i, (!loaded.get(i)) ? 0F
218: : sm.fetchFloatField(i), (float) dblval,
219: set);
220: else
221: sm.storeFloatField(i, (float) dblval);
222: break;
223: case JavaTypes.DOUBLE:
224: if (_dirty.get(i))
225: sm.settingDoubleField(pc, i, (!loaded.get(i)) ? 0D
226: : sm.fetchDoubleField(i), dblval, set);
227: else
228: sm.storeDoubleField(i, dblval);
229: break;
230: case JavaTypes.STRING:
231: if (_dirty.get(i))
232: sm.settingStringField(pc, i,
233: (!loaded.get(i)) ? null : sm
234: .fetchStringField(i),
235: (String) objval, set);
236: else
237: sm.storeStringField(i, (String) objval);
238: objval = null;
239: break;
240: case JavaTypes.PC:
241: case JavaTypes.PC_UNTYPED:
242: if (fields[i].getCascadeAttach() == ValueMetaData.CASCADE_NONE)
243: objval = getReference(manager, objval, sm,
244: fields[i]);
245: else {
246: PersistenceCapable toPC = null;
247: if (objval != null && fields[i].isEmbeddedPC())
248: toPC = ImplHelper.toPersistenceCapable(objval,
249: broker.getConfiguration());
250: objval = manager.attach(objval, toPC, sm,
251: fields[i], false);
252: }
253: if (_dirty.get(i))
254: sm.settingObjectField(pc, i,
255: (!loaded.get(i)) ? null : sm
256: .fetchObjectField(i), objval, set);
257: else
258: sm.storeObjectField(i, objval);
259: objval = null;
260: break;
261: case JavaTypes.COLLECTION:
262: Collection coll = (Collection) objval;
263: objval = null;
264: if (coll != null)
265: coll = attachCollection(manager, coll, sm,
266: fields[i]);
267: if (_dirty.get(i))
268: sm.settingObjectField(pc, i,
269: (!loaded.get(i)) ? null : sm
270: .fetchObjectField(i), coll, set);
271: else
272: sm.storeObjectField(i, coll);
273: break;
274: case JavaTypes.MAP:
275: Map map = (Map) objval;
276: objval = null;
277: if (map != null)
278: map = attachMap(manager, map, sm, fields[i]);
279: if (_dirty.get(i))
280: sm.settingObjectField(pc, i,
281: (!loaded.get(i)) ? null : sm
282: .fetchObjectField(i), map, set);
283: else
284: sm.storeObjectField(i, map);
285: break;
286: default:
287: if (_dirty.get(i))
288: sm.settingObjectField(pc, i,
289: (!loaded.get(i)) ? null : sm
290: .fetchObjectField(i), objval, set);
291: else
292: sm.storeObjectField(i, objval);
293: objval = null;
294: }
295: }
296: pc.pcReplaceStateManager(sm);
297:
298: // if we were clean at least make sure a version check is done to
299: // prevent using old state
300: if (!sm.isVersionCheckRequired()
301: && broker.isActive()
302: && _version != origVersion
303: && (origVersion == null || broker.getStoreManager()
304: .compareVersion(sm, _version, origVersion) != StoreManager.VERSION_SAME)) {
305: broker.transactional(sm.getManagedInstance(), false,
306: manager.getBehavior());
307: }
308:
309: return sm.getManagedInstance();
310: }
311:
312: protected Object getDetachedObjectId(AttachManager manager,
313: Object toAttach) {
314: return _oid;
315: }
316:
317: void provideField(int field) {
318: _pc.pcProvideField(field);
319: }
320:
321: protected void provideField(Object toAttach, StateManagerImpl sm,
322: int field) {
323: provideField(field);
324: }
325:
326: /**
327: * Ignore if the field is not dirty but loaded
328: */
329: protected static boolean ignoreLoaded(FieldMetaData fmd) {
330: switch (fmd.getTypeCode()) {
331: case JavaTypes.BOOLEAN:
332: case JavaTypes.BOOLEAN_OBJ:
333: case JavaTypes.BYTE:
334: case JavaTypes.BYTE_OBJ:
335: case JavaTypes.INT:
336: case JavaTypes.INT_OBJ:
337: case JavaTypes.LONG:
338: case JavaTypes.LONG_OBJ:
339: case JavaTypes.SHORT:
340: case JavaTypes.SHORT_OBJ:
341: case JavaTypes.DOUBLE:
342: case JavaTypes.DOUBLE_OBJ:
343: case JavaTypes.FLOAT:
344: case JavaTypes.FLOAT_OBJ:
345: case JavaTypes.CHAR:
346: case JavaTypes.CHAR_OBJ:
347: case JavaTypes.STRING:
348: return true;
349: }
350: return false;
351: }
352:
353: ///////////////////////////////
354: // StateManager implementation
355: ///////////////////////////////
356:
357: public Object getGenericContext() {
358: return null;
359: }
360:
361: public Object getPCPrimaryKey(Object oid, int field) {
362: throw new UnsupportedOperationException();
363: }
364:
365: public StateManager replaceStateManager(StateManager sm) {
366: return sm;
367: }
368:
369: public Object getVersion() {
370: return _version;
371: }
372:
373: public void setVersion(Object version) {
374: throw new UnsupportedException();
375: }
376:
377: public boolean isDirty() {
378: return _dirty.length() != 0;
379: }
380:
381: public boolean isTransactional() {
382: return false;
383: }
384:
385: public boolean isPersistent() {
386: return false;
387: }
388:
389: public boolean isNew() {
390: return false;
391: }
392:
393: public boolean isDeleted() {
394: return false;
395: }
396:
397: public boolean isDetached() {
398: return true;
399: }
400:
401: public boolean isVersionUpdateRequired() {
402: return false;
403: }
404:
405: public boolean isVersionCheckRequired() {
406: return false;
407: }
408:
409: public void dirty(String field) {
410: // should we store ClassMetaData?
411: throw new UnsupportedException();
412: }
413:
414: public Object fetchObjectId() {
415: return _oid;
416: }
417:
418: public void accessingField(int idx) {
419: if (!_access && !_loaded.get(idx))
420: // do not access the pc fields by implictly invoking _pc.toString()
421: // may cause infinite loop if again tries to access unloaded field
422: throw new IllegalStateException(_loc.get(
423: "unloaded-detached", Exceptions.toString(_pc))
424: .getMessage());
425: }
426:
427: public boolean serializing() {
428: return false;
429: }
430:
431: public boolean writeDetached(ObjectOutput out) throws IOException {
432: out.writeObject(_pc.pcGetDetachedState());
433: out.writeObject(this );
434: return false;
435: }
436:
437: public void proxyDetachedDeserialized(int idx) {
438: lock();
439: try {
440: _pc.pcProvideField(idx);
441: if (objval instanceof Proxy)
442: ((Proxy) objval).setOwner(this , idx);
443: objval = null;
444: } finally {
445: unlock();
446: }
447: }
448:
449: public void settingBooleanField(PersistenceCapable pc, int idx,
450: boolean cur, boolean next, int set) {
451: accessingField(idx);
452: if (cur == next || !_loaded.get(idx))
453: return;
454: lock();
455: try {
456: _dirty.set(idx);
457: longval = next ? 1 : 0;
458: pc.pcReplaceField(idx);
459: } finally {
460: unlock();
461: }
462: }
463:
464: public void settingCharField(PersistenceCapable pc, int idx,
465: char cur, char next, int set) {
466: accessingField(idx);
467: if (cur == next || !_loaded.get(idx))
468: return;
469: lock();
470: try {
471: _dirty.set(idx);
472: longval = next;
473: pc.pcReplaceField(idx);
474: } finally {
475: unlock();
476: }
477: }
478:
479: public void settingByteField(PersistenceCapable pc, int idx,
480: byte cur, byte next, int set) {
481: accessingField(idx);
482: if (cur == next || !_loaded.get(idx))
483: return;
484: lock();
485: try {
486: _dirty.set(idx);
487: longval = next;
488: pc.pcReplaceField(idx);
489: } finally {
490: unlock();
491: }
492: }
493:
494: public void settingShortField(PersistenceCapable pc, int idx,
495: short cur, short next, int set) {
496: accessingField(idx);
497: if (cur == next || !_loaded.get(idx))
498: return;
499: lock();
500: try {
501: _dirty.set(idx);
502: longval = next;
503: pc.pcReplaceField(idx);
504: } finally {
505: unlock();
506: }
507: }
508:
509: public void settingIntField(PersistenceCapable pc, int idx,
510: int cur, int next, int set) {
511: accessingField(idx);
512: if (cur == next || !_loaded.get(idx))
513: return;
514: lock();
515: try {
516: _dirty.set(idx);
517: longval = next;
518: pc.pcReplaceField(idx);
519: } finally {
520: unlock();
521: }
522: }
523:
524: public void settingLongField(PersistenceCapable pc, int idx,
525: long cur, long next, int set) {
526: accessingField(idx);
527: if (cur == next || !_loaded.get(idx))
528: return;
529: lock();
530: try {
531: _dirty.set(idx);
532: longval = next;
533: pc.pcReplaceField(idx);
534: } finally {
535: unlock();
536: }
537: }
538:
539: public void settingFloatField(PersistenceCapable pc, int idx,
540: float cur, float next, int set) {
541: accessingField(idx);
542: if (cur == next || !_loaded.get(idx))
543: return;
544: lock();
545: try {
546: _dirty.set(idx);
547: dblval = next;
548: pc.pcReplaceField(idx);
549: } finally {
550: unlock();
551: }
552: }
553:
554: public void settingDoubleField(PersistenceCapable pc, int idx,
555: double cur, double next, int set) {
556: accessingField(idx);
557: if (cur == next || !_loaded.get(idx))
558: return;
559: lock();
560: try {
561: _dirty.set(idx);
562: dblval = next;
563: pc.pcReplaceField(idx);
564: } finally {
565: unlock();
566: }
567: }
568:
569: public void settingStringField(PersistenceCapable pc, int idx,
570: String cur, String next, int set) {
571: accessingField(idx);
572: if (cur == next || (cur != null && cur.equals(next))
573: || !_loaded.get(idx))
574: return;
575: lock();
576: try {
577: _dirty.set(idx);
578: objval = next;
579: pc.pcReplaceField(idx);
580: } finally {
581: unlock();
582: objval = null;
583: }
584: }
585:
586: public void settingObjectField(PersistenceCapable pc, int idx,
587: Object cur, Object next, int set) {
588: accessingField(idx);
589: if (cur == next || !_loaded.get(idx))
590: return;
591: lock();
592: try {
593: _dirty.set(idx);
594: objval = next;
595: pc.pcReplaceField(idx);
596: } finally {
597: unlock();
598: objval = null;
599: }
600: }
601:
602: public void providedBooleanField(PersistenceCapable pc, int idx,
603: boolean cur) {
604: longval = cur ? 1 : 0;
605: }
606:
607: public void providedCharField(PersistenceCapable pc, int idx,
608: char cur) {
609: longval = cur;
610: }
611:
612: public void providedByteField(PersistenceCapable pc, int idx,
613: byte cur) {
614: longval = cur;
615: }
616:
617: public void providedShortField(PersistenceCapable pc, int idx,
618: short cur) {
619: longval = cur;
620: }
621:
622: public void providedIntField(PersistenceCapable pc, int idx, int cur) {
623: longval = cur;
624: }
625:
626: public void providedLongField(PersistenceCapable pc, int idx,
627: long cur) {
628: longval = cur;
629: }
630:
631: public void providedFloatField(PersistenceCapable pc, int idx,
632: float cur) {
633: dblval = cur;
634: }
635:
636: public void providedDoubleField(PersistenceCapable pc, int idx,
637: double cur) {
638: dblval = cur;
639: }
640:
641: public void providedStringField(PersistenceCapable pc, int idx,
642: String cur) {
643: objval = cur;
644: }
645:
646: public void providedObjectField(PersistenceCapable pc, int idx,
647: Object cur) {
648: objval = cur;
649: }
650:
651: public boolean replaceBooleanField(PersistenceCapable pc, int idx) {
652: return longval == 1;
653: }
654:
655: public char replaceCharField(PersistenceCapable pc, int idx) {
656: return (char) longval;
657: }
658:
659: public byte replaceByteField(PersistenceCapable pc, int idx) {
660: return (byte) longval;
661: }
662:
663: public short replaceShortField(PersistenceCapable pc, int idx) {
664: return (short) longval;
665: }
666:
667: public int replaceIntField(PersistenceCapable pc, int idx) {
668: return (int) longval;
669: }
670:
671: public long replaceLongField(PersistenceCapable pc, int idx) {
672: return longval;
673: }
674:
675: public float replaceFloatField(PersistenceCapable pc, int idx) {
676: return (float) dblval;
677: }
678:
679: public double replaceDoubleField(PersistenceCapable pc, int idx) {
680: return dblval;
681: }
682:
683: public String replaceStringField(PersistenceCapable pc, int idx) {
684: String str = (String) objval;
685: objval = null;
686: return str;
687: }
688:
689: public Object replaceObjectField(PersistenceCapable pc, int idx) {
690: Object ret = objval;
691: objval = null;
692: return ret;
693: }
694:
695: //////////////////////////////////////
696: // OpenJPAStateManager implementation
697: //////////////////////////////////////
698:
699: public void initialize(Class forType, PCState state) {
700: throw new UnsupportedOperationException();
701: }
702:
703: public void load(FetchConfiguration fetch) {
704: throw new UnsupportedOperationException();
705: }
706:
707: public Object getManagedInstance() {
708: return _pc;
709: }
710:
711: public PersistenceCapable getPersistenceCapable() {
712: return _pc;
713: }
714:
715: public ClassMetaData getMetaData() {
716: throw new UnsupportedOperationException();
717: }
718:
719: public OpenJPAStateManager getOwner() {
720: throw new UnsupportedOperationException();
721: }
722:
723: public int getOwnerIndex() {
724: throw new UnsupportedOperationException();
725: }
726:
727: public boolean isEmbedded() {
728: return _embedded;
729: }
730:
731: public boolean isFlushed() {
732: throw new UnsupportedOperationException();
733: }
734:
735: public boolean isFlushedDirty() {
736: throw new UnsupportedOperationException();
737: }
738:
739: public boolean isProvisional() {
740: throw new UnsupportedOperationException();
741: }
742:
743: public BitSet getLoaded() {
744: return _loaded;
745: }
746:
747: public BitSet getDirty() {
748: return _dirty;
749: }
750:
751: public BitSet getFlushed() {
752: throw new UnsupportedOperationException();
753: }
754:
755: public BitSet getUnloaded(FetchConfiguration fetch) {
756: throw new UnsupportedOperationException();
757: }
758:
759: public Object newProxy(int field) {
760: throw new UnsupportedOperationException();
761: }
762:
763: public Object newFieldProxy(int field) {
764: throw new UnsupportedOperationException();
765: }
766:
767: public boolean isDefaultValue(int field) {
768: throw new UnsupportedOperationException();
769: }
770:
771: public StoreContext getContext() {
772: return null;
773: }
774:
775: public PCState getPCState() {
776: throw new UnsupportedOperationException();
777: }
778:
779: public Object getObjectId() {
780: return _oid;
781: }
782:
783: public void setObjectId(Object oid) {
784: throw new UnsupportedOperationException();
785: }
786:
787: public boolean assignObjectId(boolean flush) {
788: return true;
789: }
790:
791: public Object getId() {
792: return getObjectId();
793: }
794:
795: public Object getLock() {
796: throw new UnsupportedOperationException();
797: }
798:
799: public void setLock(Object lock) {
800: throw new UnsupportedOperationException();
801: }
802:
803: public void setNextVersion(Object version) {
804: throw new UnsupportedOperationException();
805: }
806:
807: public Object getImplData() {
808: throw new UnsupportedOperationException();
809: }
810:
811: public Object setImplData(Object data, boolean cacheable) {
812: throw new UnsupportedOperationException();
813: }
814:
815: public boolean isImplDataCacheable() {
816: return false;
817: }
818:
819: public Object getImplData(int field) {
820: throw new UnsupportedOperationException();
821: }
822:
823: public Object setImplData(int field, Object data) {
824: throw new UnsupportedOperationException();
825: }
826:
827: public boolean isImplDataCacheable(int field) {
828: throw new UnsupportedOperationException();
829: }
830:
831: public Object getIntermediate(int field) {
832: throw new UnsupportedOperationException();
833: }
834:
835: public void setIntermediate(int field, Object data) {
836: throw new UnsupportedOperationException();
837: }
838:
839: public void removed(int field, Object removed, boolean key) {
840: dirty(field);
841: }
842:
843: public boolean beforeRefresh(boolean all) {
844: throw new UnsupportedOperationException();
845: }
846:
847: public void dirty(int field) {
848: lock();
849: try {
850: _dirty.set(field);
851: } finally {
852: unlock();
853: }
854: }
855:
856: public void storeBoolean(int field, boolean extVal) {
857: throw new UnsupportedOperationException();
858: }
859:
860: public void storeByte(int field, byte extVal) {
861: throw new UnsupportedOperationException();
862: }
863:
864: public void storeChar(int field, char extVal) {
865: throw new UnsupportedOperationException();
866: }
867:
868: public void storeInt(int field, int extVal) {
869: throw new UnsupportedOperationException();
870: }
871:
872: public void storeShort(int field, short extVal) {
873: throw new UnsupportedOperationException();
874: }
875:
876: public void storeLong(int field, long extVal) {
877: throw new UnsupportedOperationException();
878: }
879:
880: public void storeFloat(int field, float extVal) {
881: throw new UnsupportedOperationException();
882: }
883:
884: public void storeDouble(int field, double extVal) {
885: throw new UnsupportedOperationException();
886: }
887:
888: public void storeString(int field, String extVal) {
889: throw new UnsupportedOperationException();
890: }
891:
892: public void storeObject(int field, Object extVal) {
893: throw new UnsupportedOperationException();
894: }
895:
896: public void store(int field, Object extVal) {
897: throw new UnsupportedOperationException();
898: }
899:
900: public void storeField(int field, Object value) {
901: throw new UnsupportedOperationException();
902: }
903:
904: public boolean fetchBoolean(int field) {
905: throw new UnsupportedOperationException();
906: }
907:
908: public byte fetchByte(int field) {
909: throw new UnsupportedOperationException();
910: }
911:
912: public char fetchChar(int field) {
913: throw new UnsupportedOperationException();
914: }
915:
916: public short fetchShort(int field) {
917: throw new UnsupportedOperationException();
918: }
919:
920: public int fetchInt(int field) {
921: throw new UnsupportedOperationException();
922: }
923:
924: public long fetchLong(int field) {
925: throw new UnsupportedOperationException();
926: }
927:
928: public float fetchFloat(int field) {
929: throw new UnsupportedOperationException();
930: }
931:
932: public double fetchDouble(int field) {
933: throw new UnsupportedOperationException();
934: }
935:
936: public String fetchString(int field) {
937: throw new UnsupportedOperationException();
938: }
939:
940: public Object fetchObject(int field) {
941: throw new UnsupportedOperationException();
942: }
943:
944: public Object fetch(int field) {
945: throw new UnsupportedOperationException();
946: }
947:
948: public Object fetchField(int field, boolean transitions) {
949: throw new UnsupportedOperationException();
950: }
951:
952: public Object fetchInitialField(int field) {
953: throw new UnsupportedOperationException();
954: }
955:
956: public void setRemote(int field, Object value) {
957: throw new UnsupportedOperationException();
958: }
959:
960: public void lock() {
961: if (_lock != null)
962: _lock.lock();
963: }
964:
965: public void unlock() {
966: if (_lock != null)
967: _lock.unlock();
968: }
969: }
|