001: /**********************************************************************
002: Copyright (c) 2005 Erik Bengtson and others. All rights reserved.
003: Licensed under the Apache License, Version 2.0 (the "License");
004: you may not use this file except in compliance with the License.
005: You may obtain a copy of the License at
006:
007: http://www.apache.org/licenses/LICENSE-2.0
008:
009: Unless required by applicable law or agreed to in writing, software
010: distributed under the License is distributed on an "AS IS" BASIS,
011: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012: See the License for the specific language governing permissions and
013: limitations under the License.
014:
015:
016: Contributors:
017: ...
018: **********************************************************************/package org.jpox.sco;
019:
020: import java.io.ObjectStreamException;
021:
022: import org.jpox.StateManager;
023: import org.jpox.state.FetchPlanState;
024:
025: /**
026: * A mutable second-class BitSet object.
027: *
028: * @version $Revision: 1.22 $
029: */
030: public class BitSet extends java.util.BitSet implements SCO {
031: private transient StateManager ownerSM;
032: private transient Object owner;
033: private transient String fieldName;
034:
035: /**
036: * Creates a <tt>BitSet</tt> object. Assigns owning object and field name.
037: * @param ownerSM the owning object
038: * @param fieldName the owning field name
039: */
040: public BitSet(StateManager ownerSM, String fieldName) {
041: super ();
042:
043: if (ownerSM != null) {
044: this .ownerSM = ownerSM;
045: this .owner = ownerSM.getObject();
046: }
047: this .fieldName = fieldName;
048: }
049:
050: /**
051: * Method to initialise the SCO for use.
052: */
053: public void initialise() {
054: }
055:
056: /**
057: * Method to initialise the SCO from an existing value.
058: * @param o The Object
059: * @param forInsert Whether the object needs inserting in the datastore with this value
060: * @param forUpdate Whether to update the object in the datastore with this value
061: */
062: public void initialise(Object o, boolean forInsert,
063: boolean forUpdate) {
064: for (int i = 0; i < length(); i++) {
065: super .clear(i);
066: }
067: super .or((java.util.BitSet) o);
068: }
069:
070: /**
071: * Accessor for the unwrapped value that we are wrapping.
072: * @return The unwrapped value
073: */
074: public Object getValue() {
075: java.util.BitSet bits = new java.util.BitSet();
076: bits.or(this );
077: return bits;
078: }
079:
080: // ------------------------- SCO Methods -----------------------------
081:
082: /**
083: * Utility to unset the owner.
084: **/
085: public void unsetOwner() {
086: ownerSM = null;
087: fieldName = null;
088: }
089:
090: /**
091: * Accessor for the owner.
092: * @return The owner
093: **/
094: public Object getOwner() {
095: return owner;
096: }
097:
098: /**
099: * Accessor for the field name
100: * @return The field name
101: **/
102: public String getFieldName() {
103: return this .fieldName;
104: }
105:
106: /**
107: * Utility to mark the object as dirty
108: **/
109: public void makeDirty() {
110: if (ownerSM != null) {
111: ownerSM.getObjectManager().getApiAdapter().makeFieldDirty(
112: owner, fieldName);
113: }
114: }
115:
116: /**
117: * Method to detach a copy.
118: * @param state State for detachment process
119: * @return A copy of the object
120: */
121: public Object detachCopy(FetchPlanState state) {
122: java.util.BitSet detached = new java.util.BitSet();
123: detached.or(this );
124: return detached;
125: }
126:
127: /**
128: * Method to attached the passed value.
129: * @param value The new value
130: */
131: public void attachCopy(Object value) {
132: initialise(value, false, true);
133: makeDirty();
134: }
135:
136: /**
137: * Creates and returns a copy of this object.
138: *
139: * <p>Mutable second-class Objects are required to provide a public
140: * clone method in order to allow for copying PersistenceCapable
141: * objects. In contrast to Object.clone(), this method must not throw a
142: * CloneNotSupportedException.
143: * @return A clone of the object
144: */
145: public Object clone() {
146: Object obj = super .clone();
147:
148: ((BitSet) obj).unsetOwner();
149:
150: return obj;
151: }
152:
153: /**
154: * The writeReplace method is called when ObjectOutputStream is preparing to write the object to the stream. The
155: * ObjectOutputStream checks whether the class defines the writeReplace method. If the method is defined, the
156: * writeReplace method is called to allow the object to designate its replacement in the stream. The object returned
157: * should be either of the same type as the object passed in or an object that when read and resolved will result in
158: * an object of a type that is compatible with all references to the object.
159: *
160: * @return the replaced object
161: * @throws ObjectStreamException
162: */
163: protected Object writeReplace() throws ObjectStreamException {
164: java.util.BitSet copy = new java.util.BitSet();
165: copy.and(this );
166: return copy;
167: }
168:
169: // ------------------------- BitSet Methods -----------------------------
170:
171: /* (non-Javadoc)
172: * @see java.util.BitSet#and(java.util.BitSet)
173: */
174: public void and(java.util.BitSet set) {
175: super .and(set);
176: makeDirty();
177: }
178:
179: /* (non-Javadoc)
180: * @see java.util.BitSet#andNot(java.util.BitSet)
181: */
182: public void andNot(java.util.BitSet set) {
183: super .andNot(set);
184: makeDirty();
185: }
186:
187: /* (non-Javadoc)
188: * @see java.util.BitSet#clear(int)
189: */
190: public void clear(int bitIndex) {
191: super .clear(bitIndex);
192: makeDirty();
193: }
194:
195: /* (non-Javadoc)
196: * @see java.util.BitSet#or(java.util.BitSet)
197: */
198: public void or(java.util.BitSet set) {
199: super .or(set);
200: makeDirty();
201: }
202:
203: /* (non-Javadoc)
204: * @see java.util.BitSet#set(int)
205: */
206: public void set(int bitIndex) {
207: super .set(bitIndex);
208: makeDirty();
209: }
210:
211: /* (non-Javadoc)
212: * @see java.util.BitSet#xor(java.util.BitSet)
213: */
214: public void xor(java.util.BitSet set) {
215: super.xor(set);
216: makeDirty();
217: }
218: }
|