litesoft
Subversion Repository Public Repository

litesoft

URLs

Copy to Clipboard
Explore
Commits

Diff Revisions 947 vs 948 for /trunk/GWT_Sandbox/Prioritizer/src/org/litesoft/prioritizer/server/pos/RestrictedResourceGO.java

Diff revisions: vs.
  @@ -9,25 +9,21 @@
9 9
10 10 public abstract class RestrictedResourceGO
11 11 extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<RestrictedResource>
12 - implements HasAttributes
13 - {
12 + implements HasAttributes {
14 13 private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();
15 14
16 - public static SimpleFromIdentifier from()
17 - {
15 + public static SimpleFromIdentifier from() {
18 16 return RestrictedResourceMetaData.INSTANCE;
19 17 }
20 18
21 - protected RestrictedResourceGO( Transaction pTransaction )
22 - {
19 + protected RestrictedResourceGO( Transaction pTransaction ) {
23 20 super( RestrictedResourceMetaData.INSTANCE, pTransaction );
24 21 mID = getNextSequenceNumber( getClass() );
25 22 registerWithTransaction();
26 23 setDefaults();
27 24 }
28 25
29 - protected RestrictedResourceGO( ConstructionControl pConstructionControl )
30 - {
26 + protected RestrictedResourceGO( ConstructionControl pConstructionControl ) {
31 27 super( RestrictedResourceMetaData.INSTANCE, CONSTRUCTION_CONTROL, pConstructionControl );
32 28 }
33 29
  @@ -35,22 +31,18 @@
35 31
36 32 protected final RecordVersionHelper mRecordVersion = new RecordVersionHelper();
37 33
38 - public Long getRecordVersion()
39 - {
34 + public Long getRecordVersion() {
40 35 return mRecordVersion.getRecordVersion();
41 36 }
42 37
43 38 private static class AttributeAccessor_RecordVersion
44 - extends AttributeAccessorSCD_RecordVersion<RestrictedResource>
45 - {
46 - public AttributeAccessor_RecordVersion()
47 - {
39 + extends AttributeAccessorSCD_RecordVersion<RestrictedResource> {
40 + public AttributeAccessor_RecordVersion() {
48 41 super( "RecordVersion", "RecordVersion" );
49 42 }
50 43
51 44 @Override
52 - protected RecordVersionHelper getRecordVersionHelper( RestrictedResource pPO )
53 - {
45 + protected RecordVersionHelper getRecordVersionHelper( RestrictedResource pPO ) {
54 46 return pPO.mRecordVersion;
55 47 }
56 48 }
  @@ -59,35 +51,29 @@
59 51
60 52 private Long mID;
61 53
62 - public Long getID()
63 - {
54 + public Long getID() {
64 55 return mID;
65 56 }
66 57
67 - protected void LLsetID( Long pID )
68 - {
58 + protected void LLsetID( Long pID ) {
69 59 verifyMutability( CD_ID, mID, pID );
70 60 mID = pID;
71 61 }
72 62
73 63 private static class AttributeAccessor_ID
74 64 extends AttributeAccessorSCDsimplePersistedSysSetOnly<RestrictedResource>
75 - implements NonImportableFeature
76 - {
77 - public AttributeAccessor_ID()
78 - {
65 + implements NonImportableFeature {
66 + public AttributeAccessor_ID() {
79 67 super( "ID", "ID", false, _Long.AddOnly() );
80 68 }
81 69
82 70 @Override
83 - public Object getValueOnPO( RestrictedResource pPO )
84 - {
71 + public Object getValueOnPO( RestrictedResource pPO ) {
85 72 return pPO.getID();
86 73 }
87 74
88 75 @Override
89 - public void db_setValueOnPO( RestrictedResource pPO, Object pValue )
90 - {
76 + public void db_setValueOnPO( RestrictedResource pPO, Object pValue ) {
91 77 pPO.LLsetID( to_Long( pValue ) );
92 78 }
93 79 }
  @@ -96,40 +82,33 @@
96 82
97 83 private Boolean mActive;
98 84
99 - public Boolean getActive()
100 - {
85 + public Boolean getActive() {
101 86 return mActive;
102 87 }
103 88
104 - public void setActive( Boolean pActive )
105 - {
89 + public void setActive( Boolean pActive ) {
106 90 verifyMutability( CD_Active, mActive, pActive );
107 91 mActive = pActive;
108 92 }
109 93
110 94 private static class AttributeAccessor_Active
111 - extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource>
112 - {
113 - public AttributeAccessor_Active()
114 - {
95 + extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource> {
96 + public AttributeAccessor_Active() {
115 97 super( "Active", "Active", true, _Boolean );
116 98 }
117 99
118 100 @Override
119 - public Object getDefault()
120 - {
101 + public Object getDefault() {
121 102 return true;
122 103 }
123 104
124 105 @Override
125 - public Object getValueOnPO( RestrictedResource pPO )
126 - {
106 + public Object getValueOnPO( RestrictedResource pPO ) {
127 107 return pPO.getActive();
128 108 }
129 109
130 110 @Override
131 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
132 - {
111 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
133 112 pPO.setActive( to_Boolean( pValue ) );
134 113 }
135 114 }
  @@ -138,35 +117,29 @@
138 117
139 118 private String mDescription;
140 119
141 - public String getDescription()
142 - {
120 + public String getDescription() {
143 121 return mDescription;
144 122 }
145 123
146 - public void setDescription( String pDescription )
147 - {
124 + public void setDescription( String pDescription ) {
148 125 verifyMutability( CD_Description, mDescription, pDescription );
149 126 mDescription = pDescription;
150 127 }
151 128
152 129 private static class AttributeAccessor_Description
153 - extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource>
154 - {
155 - public AttributeAccessor_Description()
156 - {
130 + extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource> {
131 + public AttributeAccessor_Description() {
157 132 super( "Description", "Description", false, _Text.with( DisplayWidthInitial.of( 40 ), //
158 133 DisplayHeightInitial.of( 4 ) ) );
159 134 }
160 135
161 136 @Override
162 - public Object getValueOnPO( RestrictedResource pPO )
163 - {
137 + public Object getValueOnPO( RestrictedResource pPO ) {
164 138 return pPO.getDescription();
165 139 }
166 140
167 141 @Override
168 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
169 - {
142 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
170 143 pPO.setDescription( to_String( pValue ) );
171 144 }
172 145 }
  @@ -178,305 +151,253 @@
178 151 /**
179 152 * What the owner wants to call this propety. The public name - Must be Globally Unique.
180 153 */
181 - public String getName()
182 - {
154 + public String getName() {
183 155 return mName;
184 156 }
185 157
186 - public void setName( String pName )
187 - {
158 + public void setName( String pName ) {
188 159 verifyMutability( CD_Name, mName, pName );
189 160 mName = pName;
190 161 }
191 162
192 163 private static class AttributeAccessor_Name
193 164 extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource>
194 - implements CharacterCaseIgnored
195 - {
196 - public AttributeAccessor_Name()
197 - {
165 + implements CharacterCaseIgnored {
166 + public AttributeAccessor_Name() {
198 167 super( "Name", "Name", true, _String.with( MaxLength.of( 40 ), //
199 168 DisplayLength.of( 20 ), //
200 169 Case.Ignored ) );
201 170 }
202 171
203 172 @Override
204 - public Object getValueOnPO( RestrictedResource pPO )
205 - {
173 + public Object getValueOnPO( RestrictedResource pPO ) {
206 174 return pPO.getName();
207 175 }
208 176
209 177 @Override
210 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
211 - {
178 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
212 179 pPO.setName( to_String( pValue ) );
213 180 }
214 181 }
215 182
216 - public static final AttributeAccessorSCDtoManyRegular<RestrictedResource,User> CD_LastUsers = new AttributeAccessor_LastUsers();
183 + public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, User> CD_LastUsers = new AttributeAccessor_LastUsers();
217 184
218 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,User> mLastUsers = //
219 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,User>( (RestrictedResource) this, CD_LastUsers );
185 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User> mLastUsers = //
186 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User>( (RestrictedResource) this, CD_LastUsers );
220 187
221 - public java.util.List<User> getLastUsers()
222 - {
188 + public java.util.List<User> getLastUsers() {
223 189 return processLazyLoadAccess( mLastUsers );
224 190 }
225 191
226 - public void setLastUsers( java.util.List<User> pLastUsers )
227 - {
192 + public void setLastUsers( java.util.List<User> pLastUsers ) {
228 193 processLazyLoadMutation( mLastUsers, pLastUsers );
229 194 }
230 195
231 - public void addLastUsers( User pLastUsers )
232 - {
196 + public void addLastUsers( User pLastUsers ) {
233 197 processLazyLoadMutationAdd( mLastUsers, pLastUsers );
234 198 }
235 199
236 - public void removeLastUsers( User pLastUsers )
237 - {
200 + public void removeLastUsers( User pLastUsers ) {
238 201 processLazyLoadMutationRemove( mLastUsers, pLastUsers );
239 202 }
240 203
241 204 private static class AttributeAccessor_LastUsers
242 - extends AttributeAccessorSCDtoManyRegular<RestrictedResource,User>
243 - {
244 - public AttributeAccessor_LastUsers()
245 - {
205 + extends AttributeAccessorSCDtoManyRegular<RestrictedResource, User> {
206 + public AttributeAccessor_LastUsers() {
246 207 super( "LastUsers", "ID", User.class, "LastRestrictedResource", null, Mutability.RW, false, false );
247 208 }
248 209
249 210 @Override
250 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,User> getValueHolder( RestrictedResource pPO )
251 - {
211 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User> getValueHolder( RestrictedResource pPO ) {
252 212 return pPO.mLastUsers;
253 213 }
254 214
255 215 @Override
256 - public Object getValueOnPO( RestrictedResource pPO )
257 - {
216 + public Object getValueOnPO( RestrictedResource pPO ) {
258 217 return pPO.getLastUsers();
259 218 }
260 219
261 220 @Override
262 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
263 - {
221 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
264 222 pPO.setLastUsers( to_POs( pPO, User.class, pValue ) );
265 223 }
266 224
267 225 @Override
268 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
269 - {
226 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
270 227 pPO.addLastUsers( to_PO( pPO, User.class, pValue ) );
271 228 }
272 229
273 230 @Override
274 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
275 - {
231 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
276 232 pPO.removeLastUsers( to_PO( pPO, User.class, pValue ) );
277 233 }
278 234 }
279 235
280 - public static final AttributeAccessorSCDtoManyRegular<RestrictedResource,ReportRestrictedResourceCommon> CD_Reports = new AttributeAccessor_Reports();
236 + public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, ReportRestrictedResourceCommon> CD_Reports = new AttributeAccessor_Reports();
281 237
282 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,ReportRestrictedResourceCommon> mReports = //
283 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,ReportRestrictedResourceCommon>( (RestrictedResource) this, CD_Reports );
238 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon> mReports = //
239 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon>( (RestrictedResource) this, CD_Reports );
284 240
285 - public java.util.List<ReportRestrictedResourceCommon> getReports()
286 - {
241 + public java.util.List<ReportRestrictedResourceCommon> getReports() {
287 242 return processLazyLoadAccess( mReports );
288 243 }
289 244
290 - public void setReports( java.util.List<ReportRestrictedResourceCommon> pReports )
291 - {
245 + public void setReports( java.util.List<ReportRestrictedResourceCommon> pReports ) {
292 246 processLazyLoadMutation( mReports, pReports );
293 247 }
294 248
295 - public void addReports( ReportRestrictedResourceCommon pReports )
296 - {
249 + public void addReports( ReportRestrictedResourceCommon pReports ) {
297 250 processLazyLoadMutationAdd( mReports, pReports );
298 251 }
299 252
300 - public void removeReports( ReportRestrictedResourceCommon pReports )
301 - {
253 + public void removeReports( ReportRestrictedResourceCommon pReports ) {
302 254 processLazyLoadMutationRemove( mReports, pReports );
303 255 }
304 256
305 257 private static class AttributeAccessor_Reports
306 - extends AttributeAccessorSCDtoManyRegular<RestrictedResource,ReportRestrictedResourceCommon>
307 - {
308 - public AttributeAccessor_Reports()
309 - {
258 + extends AttributeAccessorSCDtoManyRegular<RestrictedResource, ReportRestrictedResourceCommon> {
259 + public AttributeAccessor_Reports() {
310 260 super( "Reports", "ID", ReportRestrictedResourceCommon.class, "RestrictedResource", null, Mutability.RW, false, true );
311 261 }
312 262
313 263 @Override
314 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,ReportRestrictedResourceCommon> getValueHolder( RestrictedResource pPO )
315 - {
264 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon> getValueHolder( RestrictedResource pPO ) {
316 265 return pPO.mReports;
317 266 }
318 267
319 268 @Override
320 - public Object getValueOnPO( RestrictedResource pPO )
321 - {
269 + public Object getValueOnPO( RestrictedResource pPO ) {
322 270 return pPO.getReports();
323 271 }
324 272
325 273 @Override
326 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
327 - {
274 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
328 275 pPO.setReports( to_POs( pPO, ReportRestrictedResourceCommon.class, pValue ) );
329 276 }
330 277
331 278 @Override
332 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
333 - {
279 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
334 280 pPO.addReports( to_PO( pPO, ReportRestrictedResourceCommon.class, pValue ) );
335 281 }
336 282
337 283 @Override
338 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
339 - {
284 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
340 285 pPO.removeReports( to_PO( pPO, ReportRestrictedResourceCommon.class, pValue ) );
341 286 }
342 287 }
343 288
344 - public static final AttributeAccessorSCDtoManyRegular<RestrictedResource,Story> CD_Stories = new AttributeAccessor_Stories();
289 + public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, Story> CD_Stories = new AttributeAccessor_Stories();
345 290
346 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,Story> mStories = //
347 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,Story>( (RestrictedResource) this, CD_Stories );
291 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story> mStories = //
292 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story>( (RestrictedResource) this, CD_Stories );
348 293
349 - public java.util.List<Story> getStories()
350 - {
294 + public java.util.List<Story> getStories() {
351 295 return processLazyLoadAccess( mStories );
352 296 }
353 297
354 - public void setStories( java.util.List<Story> pStories )
355 - {
298 + public void setStories( java.util.List<Story> pStories ) {
356 299 processLazyLoadMutation( mStories, pStories );
357 300 }
358 301
359 - public void addStories( Story pStories )
360 - {
302 + public void addStories( Story pStories ) {
361 303 processLazyLoadMutationAdd( mStories, pStories );
362 304 }
363 305
364 - public void removeStories( Story pStories )
365 - {
306 + public void removeStories( Story pStories ) {
366 307 processLazyLoadMutationRemove( mStories, pStories );
367 308 }
368 309
369 310 private static class AttributeAccessor_Stories
370 - extends AttributeAccessorSCDtoManyRegular<RestrictedResource,Story>
371 - {
372 - public AttributeAccessor_Stories()
373 - {
311 + extends AttributeAccessorSCDtoManyRegular<RestrictedResource, Story> {
312 + public AttributeAccessor_Stories() {
374 313 super( "Stories", "ID", Story.class, "RestrictedResource", null, Mutability.RW, false, true );
375 314 }
376 315
377 316 @Override
378 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,Story> getValueHolder( RestrictedResource pPO )
379 - {
317 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story> getValueHolder( RestrictedResource pPO ) {
380 318 return pPO.mStories;
381 319 }
382 320
383 321 @Override
384 - public Object getValueOnPO( RestrictedResource pPO )
385 - {
322 + public Object getValueOnPO( RestrictedResource pPO ) {
386 323 return pPO.getStories();
387 324 }
388 325
389 326 @Override
390 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
391 - {
327 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
392 328 pPO.setStories( to_POs( pPO, Story.class, pValue ) );
393 329 }
394 330
395 331 @Override
396 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
397 - {
332 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
398 333 pPO.addStories( to_PO( pPO, Story.class, pValue ) );
399 334 }
400 335
401 336 @Override
402 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
403 - {
337 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
404 338 pPO.removeStories( to_PO( pPO, Story.class, pValue ) );
405 339 }
406 340 }
407 341
408 - public static final AttributeAccessorSCDtoManyRegular<RestrictedResource,UserXrefRestrictedResource> CD_Users = new AttributeAccessor_Users();
342 + public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, UserXrefRestrictedResource> CD_Users = new AttributeAccessor_Users();
409 343
410 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,UserXrefRestrictedResource> mUsers = //
411 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,UserXrefRestrictedResource>( (RestrictedResource) this, CD_Users );
344 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource> mUsers = //
345 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource>( (RestrictedResource) this, CD_Users );
412 346
413 - public java.util.List<UserXrefRestrictedResource> getUsers()
414 - {
347 + public java.util.List<UserXrefRestrictedResource> getUsers() {
415 348 return processLazyLoadAccess( mUsers );
416 349 }
417 350
418 - public void setUsers( java.util.List<UserXrefRestrictedResource> pUsers )
419 - {
351 + public void setUsers( java.util.List<UserXrefRestrictedResource> pUsers ) {
420 352 processLazyLoadMutation( mUsers, pUsers );
421 353 }
422 354
423 - public void addUsers( UserXrefRestrictedResource pUsers )
424 - {
355 + public void addUsers( UserXrefRestrictedResource pUsers ) {
425 356 processLazyLoadMutationAdd( mUsers, pUsers );
426 357 }
427 358
428 - public void removeUsers( UserXrefRestrictedResource pUsers )
429 - {
359 + public void removeUsers( UserXrefRestrictedResource pUsers ) {
430 360 processLazyLoadMutationRemove( mUsers, pUsers );
431 361 }
432 362
433 363 private static class AttributeAccessor_Users
434 - extends AttributeAccessorSCDtoManyRegular<RestrictedResource,UserXrefRestrictedResource>
435 - {
436 - public AttributeAccessor_Users()
437 - {
364 + extends AttributeAccessorSCDtoManyRegular<RestrictedResource, UserXrefRestrictedResource> {
365 + public AttributeAccessor_Users() {
438 366 super( "Users", "ID", UserXrefRestrictedResource.class, "RestrictedResource", null, Mutability.RW, false, true );
439 367 }
440 368
441 369 @Override
442 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,UserXrefRestrictedResource> getValueHolder( RestrictedResource pPO )
443 - {
370 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource> getValueHolder( RestrictedResource pPO ) {
444 371 return pPO.mUsers;
445 372 }
446 373
447 374 @Override
448 - public Object getValueOnPO( RestrictedResource pPO )
449 - {
375 + public Object getValueOnPO( RestrictedResource pPO ) {
450 376 return pPO.getUsers();
451 377 }
452 378
453 379 @Override
454 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
455 - {
380 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
456 381 pPO.setUsers( to_POs( pPO, UserXrefRestrictedResource.class, pValue ) );
457 382 }
458 383
459 384 @Override
460 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
461 - {
385 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
462 386 pPO.addUsers( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
463 387 }
464 388
465 389 @Override
466 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
467 - {
390 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
468 391 pPO.removeUsers( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
469 392 }
470 393 }
471 394
472 395 static class MyMetaData
473 - extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<RestrictedResource>
474 - {
396 + extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<RestrictedResource> {
475 397 public static final String OBJECT_NAME = "RestrictedResource";
476 398 public static final String TABLE_NAME = "RestrictedResource";
477 399
478 - MyMetaData()
479 - {
400 + MyMetaData() {
480 401 super( OBJECT_NAME, TABLE_NAME, new AttributeAccessorKeySet( CD_ID ), //
481 402
482 403 CD_RecordVersion, /* .. */
  @@ -497,32 +418,27 @@
497 418 }
498 419
499 420 @Override
500 - public Class getPOclass()
501 - {
421 + public Class getPOclass() {
502 422 return RestrictedResource.class;
503 423 }
504 424
505 425 @Override
506 - public RestrictedResource createNew( Transaction pTransaction )
507 - {
426 + public RestrictedResource createNew( Transaction pTransaction ) {
508 427 return new RestrictedResource( pTransaction );
509 428 }
510 429
511 430 @Override
512 - public RestrictedResource createPOfromFinder()
513 - {
431 + public RestrictedResource createPOfromFinder() {
514 432 return new RestrictedResource( CONSTRUCTION_CONTROL );
515 433 }
516 434
517 435 @Override
518 - public String getDisplayValueFormat()
519 - {
436 + public String getDisplayValueFormat() {
520 437 return "${Name}";
521 438 }
522 439
523 440 @Override
524 - public String getRecordVersionAttributeName()
525 - {
441 + public String getRecordVersionAttributeName() {
526 442 return CD_RecordVersion.getName();
527 443 }
528 444 }

View View this file contents

History View the full history

Feeds

Commits for /trunk/GWT_Sandbox/Prioritizer/src/org/litesoft/prioritizer/server/pos/RestrictedResourceGO.java

Need assistance?   Get in touch, or head to our documentation site.