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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
/*******************************************************************************
* Copyright (c) 2010, 2011 Oracle. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0, which accompanies this distribution
* and is available at http://www.eclipse.org/legal/epl-v10.html.
*
* Contributors:
* Oracle - initial API and implementation
******************************************************************************/
package org.eclipse.jpt.jpa.core.context;
import java.util.Iterator;
import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
import org.eclipse.jpt.jpa.db.Table;
/**
* attribute or association override container
* <p>
* Provisional API: This interface is part of an interim API that is still
* under development and expected to change significantly before reaching
* stability. It is available at this early stage to solicit feedback from
* pioneering adopters on the understanding that any code that uses this API
* will almost certainly be broken (repeatedly) as the API evolves.
*
* @version 3.0
* @since 2.3
*/
public interface OverrideContainer
extends JpaContextNode
{
/**
* Return the type mapping that contains the override container.
* For example:<ul>
* <li>for an entity, this would be the entity itself
* <li>for an embedded, this would be type mapping where the embedded is
* declared, as opposed to the type mapping the embedded references
* </ul>
*/
TypeMapping getTypeMapping();
/**
* Return the type mapping that contains the attributes/associations to
* be overridden; though the type mapping may not <em>directly</em>
* own them (e.g. they may be owned by a supertype mapping).
* For example:<ul>
* <li>for an entity, this would be the entity's supertype mapping
* <li>for an embedded, this would be the embedded's target type mapping
* </ul>
*/
TypeMapping getOverridableTypeMapping();
/**
* Return the names of all the attributes that can be overridden
* (i.e. an override must have a name from this list).
* This is usually just all of the overridable names of the overridable
* type mapping.
* @see #getOverridableTypeMapping()
*/
Iterator<String> allOverridableNames();
/**
* Return whether the specified table cannot be explicitly specified
* as the table for an override's column or join column.
*/
boolean tableNameIsInvalid(String tableName);
/**
* Return the names of tables that are valid for an override's
* column or join column.
*/
Iterator<String> candidateTableNames();
/**
* Return the database table for the specified table name.
*/
Table resolveDbTable(String tableName);
/**
* Return the name of the default table for an override's column or join column.
*/
String getDefaultTableName();
JptValidator buildOverrideValidator(ReadOnlyOverride override, OverrideTextRangeResolver textRangeResolver);
JptValidator buildColumnValidator(ReadOnlyOverride override, ReadOnlyBaseColumn column, ReadOnlyBaseColumn.Owner owner, BaseColumnTextRangeResolver textRangeResolver);
// ********** overrides **********
/**
* Return the overrides, both <em>specified</em> and <em>virtual</em>.
*/
ListIterable<? extends ReadOnlyOverride> getOverrides();
/**
* Return the number of overrides, both <em>specified</em> and <em>virtual</em>.
*/
int getOverridesSize();
/**
* Return the override with the specified name,
* whether <em>specified</em> or <em>virtual</em>.
*/
// TODO look into getting rid of this;
// we should probably use #getSpecifiedOverrideNamed(String)
ReadOnlyOverride getOverrideNamed(String name);
// ********** specified overrides **********
/**
* Return the <em>specified</em> overrides. The container has no API for
* adding or removing <em>specified</em> overrides. The container's
* <em>virtual</em> overrides are built according to the list of overridable
* attribute names returned by the container's parent. <em>Specified</em>
* overrides can be created via {@link VirtualOverride#convertToSpecified()}.
* <em>Specified</em> overrides can be remvoed via
* {@link Override_#convertToVirtual()}.
*/
ListIterable<? extends Override_> getSpecifiedOverrides();
String SPECIFIED_OVERRIDES_LIST = "specifiedOverrides"; //$NON-NLS-1$
/**
* Return the number of <em>specified</em> overrides.
*/
int getSpecifiedOverridesSize();
/**
* Return the <em>specified</em> override at the specified index.
*/
Override_ getSpecifiedOverride(int index);
/**
* Move the <em>specified</em> override from the source index to the
* target index.
*/
void moveSpecifiedOverride(int targetIndex, int sourceIndex);
/**
* Return the <em>specified</em> override at the specified index.
*/
Override_ getSpecifiedOverrideNamed(String name);
/**
* Convert the specified <em>specified</em> override to <em>virtual</em>.
* Return the new override.
*/
VirtualOverride convertOverrideToVirtual(Override_ specifiedOverride);
// ********** virtual overrides **********
/**
* Return the <em>virtual</em> overrides (i.e. those not <em>specified</em>).
*/
// TODO change to a Iterable instead of ListIterable?
ListIterable<? extends VirtualOverride> getVirtualOverrides();
String VIRTUAL_OVERRIDES_LIST = "virtualOverrides"; //$NON-NLS-1$
/**
* Return the number of <em>virtual</em> overrides.
*/
int getVirtualOverridesSize();
/**
* Convert the specified <em>virtual</em> override to <em>specified</em>.
* Return the new override.
*/
Override_ convertOverrideToSpecified(VirtualOverride virtualOverride);
// ********** container owner **********
interface Owner
{
/**
* @see OverrideContainer#getTypeMapping()
*/
TypeMapping getTypeMapping();
/**
* @see OverrideContainer#getOverridableTypeMapping()
*/
TypeMapping getOverridableTypeMapping();
/**
* @see OverrideContainer#allOverridableNames()
*/
Iterator<String> allOverridableNames();
/**
* @see OverrideContainer#getDefaultTableName()
*/
String getDefaultTableName();
/**
* @see OverrideContainer#tableNameIsInvalid(String)
*/
boolean tableNameIsInvalid(String tableName);
/**
* @see OverrideContainer#resolveDbTable(String)
*/
org.eclipse.jpt.jpa.db.Table resolveDbTable(String tableName);
/**
* @see OverrideContainer#candidateTableNames()
*/
Iterator<String> candidateTableNames();
JptValidator buildOverrideValidator(ReadOnlyOverride override, OverrideContainer container, OverrideTextRangeResolver textRangeResolver);
JptValidator buildColumnValidator(ReadOnlyOverride override, ReadOnlyBaseColumn column, ReadOnlyBaseColumn.Owner columnOwner, BaseColumnTextRangeResolver textRangeResolver);
}
}
|
