1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/*
* Copyright (C) 2002-2016 Sebastiano Vigna
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package PACKAGE;
/** An abstract class providing basic methods for functions implementing a type-specific interface.
*
* <P>Optional operations just throw an {@link
* UnsupportedOperationException}. Generic versions of accessors delegate to
* the corresponding type-specific counterparts following the interface rules
* (they take care of returning <code>null</code> on a missing key).
*
* <P>This class handles directly a default return
* value (including {@linkplain #defaultReturnValue() methods to access
* it}). Instances of classes inheriting from this class have just to return
* <code>defRetValue</code> to denote lack of a key in type-specific methods. The value
* is serialized.
*
* <P>Implementing subclasses have just to provide type-specific <code>get()</code>,
* type-specific <code>containsKey()</code>, and <code>size()</code> methods.
*
*/
public abstract class ABSTRACT_FUNCTION KEY_VALUE_GENERIC implements FUNCTION KEY_VALUE_GENERIC, java.io.Serializable {
private static final long serialVersionUID = -4940583368468432370L;
protected ABSTRACT_FUNCTION() {}
/**
* The default return value for <code>get()</code>, <code>put()</code> and
* <code>remove()</code>.
*/
protected VALUE_GENERIC_TYPE defRetValue;
public void defaultReturnValue( final VALUE_GENERIC_TYPE rv ) {
defRetValue = rv;
}
public VALUE_GENERIC_TYPE defaultReturnValue() {
return defRetValue;
}
public VALUE_GENERIC_TYPE put( KEY_GENERIC_TYPE key, VALUE_GENERIC_TYPE value ) {
throw new UnsupportedOperationException();
}
public VALUE_GENERIC_TYPE REMOVE_VALUE( KEY_TYPE key ) {
throw new UnsupportedOperationException();
}
public void clear() {
throw new UnsupportedOperationException();
}
#if KEYS_PRIMITIVE
public boolean containsKey( final Object ok ) {
if ( ok == null ) return false;
return containsKey( KEY_OBJ2TYPE( ok ) );
}
#endif
#if KEYS_PRIMITIVE || VALUES_PRIMITIVE
#if VALUES_PRIMITIVE
/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key.
*
* <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
* it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
*
* @deprecated Please use the corresponding type-specific method instead. */
@Deprecated
#else
/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key.
*
* <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
* it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
*/
#endif
public VALUE_GENERIC_CLASS get( final Object ok ) {
#if KEYS_PRIMITIVE
if ( ok == null ) return null;
#endif
final KEY_TYPE k = KEY_OBJ2TYPE( ok );
return containsKey( k ) ? VALUE2OBJ( GET_VALUE( k ) ) : null;
}
#if KEYS_PRIMITIVE || VALUES_PRIMITIVE
/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key.
*
* <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
* it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
*
* @deprecated Please use the corresponding type-specific method instead. */
@Deprecated
#else
/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key.
*
* <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
* it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
*/
#endif
public VALUE_GENERIC_CLASS put( final KEY_GENERIC_CLASS ok, final VALUE_GENERIC_CLASS ov ) {
final KEY_GENERIC_TYPE k = KEY_CLASS2TYPE( ok );
final boolean containsKey = containsKey( k );
final VALUE_GENERIC_TYPE v = put( k, VALUE_CLASS2TYPE( ov ) );
return containsKey ? VALUE2OBJ( v ) : null;
}
#if VALUES_PRIMITIVE
/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key.
*
* <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
* it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
*
* @deprecated Please use the corresponding type-specific method instead. */
@Deprecated
#else
/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key.
*
* <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
* it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
*/
#endif
public VALUE_GENERIC_CLASS remove( final Object ok ) {
#if KEYS_PRIMITIVE
if ( ok == null ) return null;
#endif
final KEY_TYPE k = KEY_OBJ2TYPE( ok );
final boolean containsKey = containsKey( k );
final VALUE_GENERIC_TYPE v = REMOVE_VALUE( k );
return containsKey ? VALUE2OBJ( v ) : null;
}
#endif
}
|
