001: /*
002:
003: Derby - Class org.apache.derby.iapi.store.raw.ContainerKey
004:
005: Licensed to the Apache Software Foundation (ASF) under one or more
006: contributor license agreements. See the NOTICE file distributed with
007: this work for additional information regarding copyright ownership.
008: The ASF licenses this file to you under the Apache License, Version 2.0
009: (the "License"); you may not use this file except in compliance with
010: the License. You may obtain a copy of the License at
011:
012: http://www.apache.org/licenses/LICENSE-2.0
013:
014: Unless required by applicable law or agreed to in writing, software
015: distributed under the License is distributed on an "AS IS" BASIS,
016: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: See the License for the specific language governing permissions and
018: limitations under the License.
019:
020: */
021:
022: package org.apache.derby.iapi.store.raw;
023:
024: import org.apache.derby.iapi.util.Matchable;
025: import org.apache.derby.iapi.services.io.CompressedNumber;
026:
027: import java.io.ObjectOutput;
028: import java.io.ObjectInput;
029: import java.io.IOException;
030:
031: import org.apache.derby.iapi.services.sanity.SanityManager;
032: import org.apache.derby.iapi.services.locks.Lockable;
033: import org.apache.derby.iapi.services.locks.Latch;
034: import org.apache.derby.iapi.services.locks.VirtualLockTable;
035:
036: import java.util.Hashtable;
037:
038: /**
039: A key that identifies a Container within the RawStore.
040: <BR> MT - Immutable
041: */
042: public final class ContainerKey implements Matchable, Lockable {
043: private final long segmentId; // segment identifier
044: private final long containerId; // container identifier
045:
046: /**
047: Create a new ContainerKey
048: */
049: public ContainerKey(long segmentId, long containerId) {
050: this .segmentId = segmentId;
051: this .containerId = containerId;
052: }
053:
054: /**
055: Return my identifier within the segment
056: */
057: public long getContainerId() {
058: return containerId;
059: }
060:
061: /**
062: Return my segment identifier
063: */
064: public long getSegmentId() {
065: return segmentId;
066: }
067:
068: /*
069: ** Methods to read and write ContainerKeys.
070: */
071:
072: public void writeExternal(ObjectOutput out) throws IOException {
073: CompressedNumber.writeLong(out, segmentId);
074: CompressedNumber.writeLong(out, containerId);
075: }
076:
077: public static ContainerKey read(ObjectInput in) throws IOException {
078: long sid = CompressedNumber.readLong(in);
079: long cid = CompressedNumber.readLong(in);
080:
081: return new ContainerKey(sid, cid);
082: }
083:
084: /*
085: ** Methods of Object
086: */
087:
088: public boolean equals(Object other) {
089: if (other == this )
090: return true;
091:
092: if (other instanceof ContainerKey) {
093: ContainerKey otherKey = (ContainerKey) other;
094:
095: return (containerId == otherKey.containerId)
096: && (segmentId == otherKey.segmentId);
097: } else {
098: return false;
099: }
100: }
101:
102: public int hashCode() {
103:
104: return (int) (segmentId ^ containerId);
105: }
106:
107: public String toString() {
108:
109: return "Container(" + segmentId + ", " + containerId + ")";
110: }
111:
112: /*
113: ** methods of Matchable
114: */
115:
116: public boolean match(Object key) {
117: // instance of ContainerKey?
118: if (equals(key))
119: return true;
120:
121: if (key instanceof PageKey)
122: return equals(((PageKey) key).getContainerId());
123:
124: if (key instanceof RecordHandle) {
125: return equals(((RecordHandle) key).getContainerId());
126: }
127: return false;
128: }
129:
130: /*
131: ** Methods of Lockable
132: */
133:
134: public void lockEvent(Latch lockInfo) {
135: }
136:
137: public boolean requestCompatible(Object requestedQualifier,
138: Object grantedQualifier) {
139: if (SanityManager.DEBUG) {
140: SanityManager
141: .ASSERT(requestedQualifier instanceof ContainerLock);
142: SanityManager
143: .ASSERT(grantedQualifier instanceof ContainerLock);
144: }
145:
146: ContainerLock clRequested = (ContainerLock) requestedQualifier;
147: ContainerLock clGranted = (ContainerLock) grantedQualifier;
148:
149: return clRequested.isCompatible(clGranted);
150: }
151:
152: /**
153: This method will only be called if requestCompatible returned false.
154: This results from two cases, some other compatabilty space has some
155: lock that would conflict with the request, or this compatability space
156: has a lock tha
157: */
158: public boolean lockerAlwaysCompatible() {
159: return true;
160: }
161:
162: public void unlockEvent(Latch lockInfo) {
163: }
164:
165: /**
166: This lockable wants to participate in the Virtual Lock table.
167: */
168: public boolean lockAttributes(int flag, Hashtable attributes) {
169: if (SanityManager.DEBUG) {
170: SanityManager
171: .ASSERT(attributes != null,
172: "cannot call lockProperties with null attribute list");
173: }
174:
175: if ((flag & VirtualLockTable.TABLE_AND_ROWLOCK) == 0)
176: return false;
177:
178: attributes.put(VirtualLockTable.CONTAINERID, new Long(
179: getContainerId()));
180: attributes.put(VirtualLockTable.LOCKNAME, "Tablelock");
181: attributes.put(VirtualLockTable.LOCKTYPE, "TABLE");
182:
183: // attributes.put(VirtualLockTable.SEGMENTID, new Long(identity.getSegmentId()));
184:
185: return true;
186: }
187: }
|