litesoft
Subversion Repository Public Repository

litesoft

URLs

Copy to Clipboard
Explore
Commits

Diff Revisions 947 vs 948 for /trunk/GWT_Sandbox/InitFrom/src/org/litesoft/initfrom/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,36 +117,30 @@
138 117
139 118 private String mCommonEmailDomain;
140 119
141 - public String getCommonEmailDomain()
142 - {
120 + public String getCommonEmailDomain() {
143 121 return mCommonEmailDomain;
144 122 }
145 123
146 - public void setCommonEmailDomain( String pCommonEmailDomain )
147 - {
124 + public void setCommonEmailDomain( String pCommonEmailDomain ) {
148 125 verifyMutability( CD_CommonEmailDomain, mCommonEmailDomain, pCommonEmailDomain );
149 126 mCommonEmailDomain = toLowerCase( pCommonEmailDomain );
150 127 }
151 128
152 129 private static class AttributeAccessor_CommonEmailDomain
153 - extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource>
154 - {
155 - public AttributeAccessor_CommonEmailDomain()
156 - {
130 + extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource> {
131 + public AttributeAccessor_CommonEmailDomain() {
157 132 super( "CommonEmailDomain", "CommonEmailDomain", false, _String.with( MaxLength.of( 40 ), //
158 133 DisplayLength.of( 20 ), //
159 134 Case.Lowered ) );
160 135 }
161 136
162 137 @Override
163 - public Object getValueOnPO( RestrictedResource pPO )
164 - {
138 + public Object getValueOnPO( RestrictedResource pPO ) {
165 139 return pPO.getCommonEmailDomain();
166 140 }
167 141
168 142 @Override
169 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
170 - {
143 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
171 144 pPO.setCommonEmailDomain( to_String( pValue ) );
172 145 }
173 146 }
  @@ -179,37 +152,31 @@
179 152 /**
180 153 * What the owner wants to call this propety. The public name - Must be Globally Unique.
181 154 */
182 - public String getName()
183 - {
155 + public String getName() {
184 156 return mName;
185 157 }
186 158
187 - public void setName( String pName )
188 - {
159 + public void setName( String pName ) {
189 160 verifyMutability( CD_Name, mName, pName );
190 161 mName = pName;
191 162 }
192 163
193 164 private static class AttributeAccessor_Name
194 165 extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource>
195 - implements CharacterCaseIgnored
196 - {
197 - public AttributeAccessor_Name()
198 - {
166 + implements CharacterCaseIgnored {
167 + public AttributeAccessor_Name() {
199 168 super( "Name", "Name", true, _String.with( MaxLength.of( 40 ), //
200 169 DisplayLength.of( 20 ), //
201 170 Case.Ignored ) );
202 171 }
203 172
204 173 @Override
205 - public Object getValueOnPO( RestrictedResource pPO )
206 - {
174 + public Object getValueOnPO( RestrictedResource pPO ) {
207 175 return pPO.getName();
208 176 }
209 177
210 178 @Override
211 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
212 - {
179 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
213 180 pPO.setName( to_String( pValue ) );
214 181 }
215 182 }
  @@ -222,38 +189,32 @@
222 189
223 190 abstract protected void LLsetPhone( String pPhone );
224 191
225 - public void setPhone( String pPhone )
226 - {
192 + public void setPhone( String pPhone ) {
227 193 verifyMutability( CD_Phone, getPhone(), pPhone );
228 - LLsetPhone( pPhone);
194 + LLsetPhone( pPhone );
229 195 }
230 196
231 197 private static class AttributeAccessor_Phone
232 198 extends AttributeAccessorSCDsimpleVirtualRegular<RestrictedResource>
233 - implements CharacterCaseIgnored
234 - {
235 - public AttributeAccessor_Phone()
236 - {
199 + implements CharacterCaseIgnored {
200 + public AttributeAccessor_Phone() {
237 201 super( "Phone", false, _String.with( MaxLength.of( 20 ), //
238 202 DisplayLength.of( 20 ), //
239 203 Case.Ignored ) );
240 204 }
241 205
242 206 @Override
243 - public Object getValueOnPO( RestrictedResource pPO )
244 - {
207 + public Object getValueOnPO( RestrictedResource pPO ) {
245 208 return pPO.getPhone();
246 209 }
247 210
248 211 @Override
249 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
250 - {
212 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
251 213 pPO.setPhone( to_String( pValue ) );
252 214 }
253 215
254 216 @Override
255 - protected void LL_clearVirtualValueOnPO( RestrictedResource pPO )
256 - {
217 + protected void LL_clearVirtualValueOnPO( RestrictedResource pPO ) {
257 218 pPO.LLclearPhone();
258 219 }
259 220 }
  @@ -262,431 +223,357 @@
262 223
263 224 private String mURL;
264 225
265 - public String getURL()
266 - {
226 + public String getURL() {
267 227 return mURL;
268 228 }
269 229
270 - public void setURL( String pURL )
271 - {
230 + public void setURL( String pURL ) {
272 231 verifyMutability( CD_URL, mURL, pURL );
273 232 mURL = pURL;
274 233 }
275 234
276 235 private static class AttributeAccessor_URL
277 - extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource>
278 - {
279 - public AttributeAccessor_URL()
280 - {
236 + extends AttributeAccessorSCDsimplePersistedRegular<RestrictedResource> {
237 + public AttributeAccessor_URL() {
281 238 super( "URL", "URL", false, _String.with( MaxLength.of( 100 ), //
282 239 DisplayLength.of( 40 ) ) );
283 240 }
284 241
285 242 @Override
286 - public Object getValueOnPO( RestrictedResource pPO )
287 - {
243 + public Object getValueOnPO( RestrictedResource pPO ) {
288 244 return pPO.getURL();
289 245 }
290 246
291 247 @Override
292 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
293 - {
248 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
294 249 pPO.setURL( to_String( pValue ) );
295 250 }
296 251 }
297 252
298 - public static final AttributeAccessorSCDtoManyVariable<RestrictedResource,Email> CD_Emails = new AttributeAccessor_Emails();
253 + public static final AttributeAccessorSCDtoManyVariable<RestrictedResource, Email> CD_Emails = new AttributeAccessor_Emails();
299 254
300 - protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource,Email> mEmails = //
301 - new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource,Email>( (RestrictedResource) this, CD_Emails );
255 + protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Email> mEmails = //
256 + new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Email>( (RestrictedResource) this, CD_Emails );
302 257
303 - public java.util.List<Email> getEmails()
304 - {
258 + public java.util.List<Email> getEmails() {
305 259 return processLazyLoadAccess( mEmails );
306 260 }
307 261
308 - public void setEmails( java.util.List<Email> pEmails )
309 - {
262 + public void setEmails( java.util.List<Email> pEmails ) {
310 263 processLazyLoadMutation( mEmails, pEmails );
311 264 }
312 265
313 - public void addEmails( Email pEmails )
314 - {
266 + public void addEmails( Email pEmails ) {
315 267 processLazyLoadMutationAdd( mEmails, pEmails );
316 268 }
317 269
318 - public void removeEmails( Email pEmails )
319 - {
270 + public void removeEmails( Email pEmails ) {
320 271 processLazyLoadMutationRemove( mEmails, pEmails );
321 272 }
322 273
323 274 private static class AttributeAccessor_Emails
324 - extends AttributeAccessorSCDtoManyVariable<RestrictedResource,Email>
325 - {
326 - public AttributeAccessor_Emails()
327 - {
275 + extends AttributeAccessorSCDtoManyVariable<RestrictedResource, Email> {
276 + public AttributeAccessor_Emails() {
328 277 super( "Emails", Email.class, "Owner", null, true, false, Mutability.RW );
329 278 }
330 279
331 280 @Override
332 - public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource,Email> getValueHolder( RestrictedResource pPO )
333 - {
281 + public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Email> getValueHolder( RestrictedResource pPO ) {
334 282 return pPO.mEmails;
335 283 }
336 284
337 285 @Override
338 - public Object getValueOnPO( RestrictedResource pPO )
339 - {
286 + public Object getValueOnPO( RestrictedResource pPO ) {
340 287 return pPO.getEmails();
341 288 }
342 289
343 290 @Override
344 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
345 - {
291 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
346 292 pPO.setEmails( to_POs( pPO, Email.class, pValue ) );
347 293 }
348 294
349 295 @Override
350 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
351 - {
296 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
352 297 pPO.addEmails( to_PO( pPO, Email.class, pValue ) );
353 298 }
354 299
355 300 @Override
356 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
357 - {
301 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
358 302 pPO.removeEmails( to_PO( pPO, Email.class, pValue ) );
359 303 }
360 304 }
361 305
362 - public static final AttributeAccessorSCDtoManyRegular<RestrictedResource,User> CD_LastUsers = new AttributeAccessor_LastUsers();
306 + public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, User> CD_LastUsers = new AttributeAccessor_LastUsers();
363 307
364 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,User> mLastUsers = //
365 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,User>( (RestrictedResource) this, CD_LastUsers );
308 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User> mLastUsers = //
309 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User>( (RestrictedResource) this, CD_LastUsers );
366 310
367 - public java.util.List<User> getLastUsers()
368 - {
311 + public java.util.List<User> getLastUsers() {
369 312 return processLazyLoadAccess( mLastUsers );
370 313 }
371 314
372 - public void setLastUsers( java.util.List<User> pLastUsers )
373 - {
315 + public void setLastUsers( java.util.List<User> pLastUsers ) {
374 316 processLazyLoadMutation( mLastUsers, pLastUsers );
375 317 }
376 318
377 - public void addLastUsers( User pLastUsers )
378 - {
319 + public void addLastUsers( User pLastUsers ) {
379 320 processLazyLoadMutationAdd( mLastUsers, pLastUsers );
380 321 }
381 322
382 - public void removeLastUsers( User pLastUsers )
383 - {
323 + public void removeLastUsers( User pLastUsers ) {
384 324 processLazyLoadMutationRemove( mLastUsers, pLastUsers );
385 325 }
386 326
387 327 private static class AttributeAccessor_LastUsers
388 - extends AttributeAccessorSCDtoManyRegular<RestrictedResource,User>
389 - {
390 - public AttributeAccessor_LastUsers()
391 - {
328 + extends AttributeAccessorSCDtoManyRegular<RestrictedResource, User> {
329 + public AttributeAccessor_LastUsers() {
392 330 super( "LastUsers", "ID", User.class, "LastRestrictedResource", null, Mutability.RW, false, false );
393 331 }
394 332
395 333 @Override
396 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,User> getValueHolder( RestrictedResource pPO )
397 - {
334 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, User> getValueHolder( RestrictedResource pPO ) {
398 335 return pPO.mLastUsers;
399 336 }
400 337
401 338 @Override
402 - public Object getValueOnPO( RestrictedResource pPO )
403 - {
339 + public Object getValueOnPO( RestrictedResource pPO ) {
404 340 return pPO.getLastUsers();
405 341 }
406 342
407 343 @Override
408 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
409 - {
344 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
410 345 pPO.setLastUsers( to_POs( pPO, User.class, pValue ) );
411 346 }
412 347
413 348 @Override
414 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
415 - {
349 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
416 350 pPO.addLastUsers( to_PO( pPO, User.class, pValue ) );
417 351 }
418 352
419 353 @Override
420 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
421 - {
354 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
422 355 pPO.removeLastUsers( to_PO( pPO, User.class, pValue ) );
423 356 }
424 357 }
425 358
426 - public static final AttributeAccessorSCDtoManyVariable<RestrictedResource,Phone> CD_Phones = new AttributeAccessor_Phones();
359 + public static final AttributeAccessorSCDtoManyVariable<RestrictedResource, Phone> CD_Phones = new AttributeAccessor_Phones();
427 360
428 - protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource,Phone> mPhones = //
429 - new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource,Phone>( (RestrictedResource) this, CD_Phones );
361 + protected org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Phone> mPhones = //
362 + new org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Phone>( (RestrictedResource) this, CD_Phones );
430 363
431 - public java.util.List<Phone> getPhones()
432 - {
364 + public java.util.List<Phone> getPhones() {
433 365 return processLazyLoadAccess( mPhones );
434 366 }
435 367
436 - public void setPhones( java.util.List<Phone> pPhones )
437 - {
368 + public void setPhones( java.util.List<Phone> pPhones ) {
438 369 processLazyLoadMutation( mPhones, pPhones );
439 370 }
440 371
441 - public void addPhones( Phone pPhones )
442 - {
372 + public void addPhones( Phone pPhones ) {
443 373 processLazyLoadMutationAdd( mPhones, pPhones );
444 374 }
445 375
446 - public void removePhones( Phone pPhones )
447 - {
376 + public void removePhones( Phone pPhones ) {
448 377 processLazyLoadMutationRemove( mPhones, pPhones );
449 378 }
450 379
451 380 private static class AttributeAccessor_Phones
452 - extends AttributeAccessorSCDtoManyVariable<RestrictedResource,Phone>
453 - {
454 - public AttributeAccessor_Phones()
455 - {
381 + extends AttributeAccessorSCDtoManyVariable<RestrictedResource, Phone> {
382 + public AttributeAccessor_Phones() {
456 383 super( "Phones", Phone.class, "Owner", null, true, false, Mutability.RW );
457 384 }
458 385
459 386 @Override
460 - public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource,Phone> getValueHolder( RestrictedResource pPO )
461 - {
387 + public org.litesoft.orsup.lazyload.LazyLoadToManyVariable<RestrictedResource, Phone> getValueHolder( RestrictedResource pPO ) {
462 388 return pPO.mPhones;
463 389 }
464 390
465 391 @Override
466 - public Object getValueOnPO( RestrictedResource pPO )
467 - {
392 + public Object getValueOnPO( RestrictedResource pPO ) {
468 393 return pPO.getPhones();
469 394 }
470 395
471 396 @Override
472 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
473 - {
397 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
474 398 pPO.setPhones( to_POs( pPO, Phone.class, pValue ) );
475 399 }
476 400
477 401 @Override
478 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
479 - {
402 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
480 403 pPO.addPhones( to_PO( pPO, Phone.class, pValue ) );
481 404 }
482 405
483 406 @Override
484 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
485 - {
407 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
486 408 pPO.removePhones( to_PO( pPO, Phone.class, pValue ) );
487 409 }
488 410 }
489 411
490 - public static final AttributeAccessorSCDtoManyRegular<RestrictedResource,ReportRestrictedResourceCommon> CD_Reports = new AttributeAccessor_Reports();
412 + public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, ReportRestrictedResourceCommon> CD_Reports = new AttributeAccessor_Reports();
491 413
492 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,ReportRestrictedResourceCommon> mReports = //
493 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,ReportRestrictedResourceCommon>( (RestrictedResource) this, CD_Reports );
414 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon> mReports = //
415 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon>( (RestrictedResource) this, CD_Reports );
494 416
495 - public java.util.List<ReportRestrictedResourceCommon> getReports()
496 - {
417 + public java.util.List<ReportRestrictedResourceCommon> getReports() {
497 418 return processLazyLoadAccess( mReports );
498 419 }
499 420
500 - public void setReports( java.util.List<ReportRestrictedResourceCommon> pReports )
501 - {
421 + public void setReports( java.util.List<ReportRestrictedResourceCommon> pReports ) {
502 422 processLazyLoadMutation( mReports, pReports );
503 423 }
504 424
505 - public void addReports( ReportRestrictedResourceCommon pReports )
506 - {
425 + public void addReports( ReportRestrictedResourceCommon pReports ) {
507 426 processLazyLoadMutationAdd( mReports, pReports );
508 427 }
509 428
510 - public void removeReports( ReportRestrictedResourceCommon pReports )
511 - {
429 + public void removeReports( ReportRestrictedResourceCommon pReports ) {
512 430 processLazyLoadMutationRemove( mReports, pReports );
513 431 }
514 432
515 433 private static class AttributeAccessor_Reports
516 - extends AttributeAccessorSCDtoManyRegular<RestrictedResource,ReportRestrictedResourceCommon>
517 - {
518 - public AttributeAccessor_Reports()
519 - {
434 + extends AttributeAccessorSCDtoManyRegular<RestrictedResource, ReportRestrictedResourceCommon> {
435 + public AttributeAccessor_Reports() {
520 436 super( "Reports", "ID", ReportRestrictedResourceCommon.class, "RestrictedResource", null, Mutability.RW, false, true );
521 437 }
522 438
523 439 @Override
524 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,ReportRestrictedResourceCommon> getValueHolder( RestrictedResource pPO )
525 - {
440 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, ReportRestrictedResourceCommon> getValueHolder( RestrictedResource pPO ) {
526 441 return pPO.mReports;
527 442 }
528 443
529 444 @Override
530 - public Object getValueOnPO( RestrictedResource pPO )
531 - {
445 + public Object getValueOnPO( RestrictedResource pPO ) {
532 446 return pPO.getReports();
533 447 }
534 448
535 449 @Override
536 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
537 - {
450 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
538 451 pPO.setReports( to_POs( pPO, ReportRestrictedResourceCommon.class, pValue ) );
539 452 }
540 453
541 454 @Override
542 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
543 - {
455 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
544 456 pPO.addReports( to_PO( pPO, ReportRestrictedResourceCommon.class, pValue ) );
545 457 }
546 458
547 459 @Override
548 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
549 - {
460 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
550 461 pPO.removeReports( to_PO( pPO, ReportRestrictedResourceCommon.class, pValue ) );
551 462 }
552 463 }
553 464
554 - public static final AttributeAccessorSCDtoManyRegular<RestrictedResource,Story> CD_Stories = new AttributeAccessor_Stories();
465 + public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, Story> CD_Stories = new AttributeAccessor_Stories();
555 466
556 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,Story> mStories = //
557 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,Story>( (RestrictedResource) this, CD_Stories );
467 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story> mStories = //
468 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story>( (RestrictedResource) this, CD_Stories );
558 469
559 - public java.util.List<Story> getStories()
560 - {
470 + public java.util.List<Story> getStories() {
561 471 return processLazyLoadAccess( mStories );
562 472 }
563 473
564 - public void setStories( java.util.List<Story> pStories )
565 - {
474 + public void setStories( java.util.List<Story> pStories ) {
566 475 processLazyLoadMutation( mStories, pStories );
567 476 }
568 477
569 - public void addStories( Story pStories )
570 - {
478 + public void addStories( Story pStories ) {
571 479 processLazyLoadMutationAdd( mStories, pStories );
572 480 }
573 481
574 - public void removeStories( Story pStories )
575 - {
482 + public void removeStories( Story pStories ) {
576 483 processLazyLoadMutationRemove( mStories, pStories );
577 484 }
578 485
579 486 private static class AttributeAccessor_Stories
580 - extends AttributeAccessorSCDtoManyRegular<RestrictedResource,Story>
581 - {
582 - public AttributeAccessor_Stories()
583 - {
487 + extends AttributeAccessorSCDtoManyRegular<RestrictedResource, Story> {
488 + public AttributeAccessor_Stories() {
584 489 super( "Stories", "ID", Story.class, "RestrictedResource", null, Mutability.RW, false, false );
585 490 }
586 491
587 492 @Override
588 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,Story> getValueHolder( RestrictedResource pPO )
589 - {
493 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, Story> getValueHolder( RestrictedResource pPO ) {
590 494 return pPO.mStories;
591 495 }
592 496
593 497 @Override
594 - public Object getValueOnPO( RestrictedResource pPO )
595 - {
498 + public Object getValueOnPO( RestrictedResource pPO ) {
596 499 return pPO.getStories();
597 500 }
598 501
599 502 @Override
600 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
601 - {
503 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
602 504 pPO.setStories( to_POs( pPO, Story.class, pValue ) );
603 505 }
604 506
605 507 @Override
606 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
607 - {
508 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
608 509 pPO.addStories( to_PO( pPO, Story.class, pValue ) );
609 510 }
610 511
611 512 @Override
612 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
613 - {
513 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
614 514 pPO.removeStories( to_PO( pPO, Story.class, pValue ) );
615 515 }
616 516 }
617 517
618 - public static final AttributeAccessorSCDtoManyRegular<RestrictedResource,UserXrefRestrictedResource> CD_Users = new AttributeAccessor_Users();
518 + public static final AttributeAccessorSCDtoManyRegular<RestrictedResource, UserXrefRestrictedResource> CD_Users = new AttributeAccessor_Users();
619 519
620 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,UserXrefRestrictedResource> mUsers = //
621 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,UserXrefRestrictedResource>( (RestrictedResource) this, CD_Users );
520 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource> mUsers = //
521 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource>( (RestrictedResource) this, CD_Users );
622 522
623 - public java.util.List<UserXrefRestrictedResource> getUsers()
624 - {
523 + public java.util.List<UserXrefRestrictedResource> getUsers() {
625 524 return processLazyLoadAccess( mUsers );
626 525 }
627 526
628 - public void setUsers( java.util.List<UserXrefRestrictedResource> pUsers )
629 - {
527 + public void setUsers( java.util.List<UserXrefRestrictedResource> pUsers ) {
630 528 processLazyLoadMutation( mUsers, pUsers );
631 529 }
632 530
633 - public void addUsers( UserXrefRestrictedResource pUsers )
634 - {
531 + public void addUsers( UserXrefRestrictedResource pUsers ) {
635 532 processLazyLoadMutationAdd( mUsers, pUsers );
636 533 }
637 534
638 - public void removeUsers( UserXrefRestrictedResource pUsers )
639 - {
535 + public void removeUsers( UserXrefRestrictedResource pUsers ) {
640 536 processLazyLoadMutationRemove( mUsers, pUsers );
641 537 }
642 538
643 539 private static class AttributeAccessor_Users
644 - extends AttributeAccessorSCDtoManyRegular<RestrictedResource,UserXrefRestrictedResource>
645 - {
646 - public AttributeAccessor_Users()
647 - {
540 + extends AttributeAccessorSCDtoManyRegular<RestrictedResource, UserXrefRestrictedResource> {
541 + public AttributeAccessor_Users() {
648 542 super( "Users", "ID", UserXrefRestrictedResource.class, "RestrictedResource", null, Mutability.RW, false, true );
649 543 }
650 544
651 545 @Override
652 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource,UserXrefRestrictedResource> getValueHolder( RestrictedResource pPO )
653 - {
546 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<RestrictedResource, UserXrefRestrictedResource> getValueHolder( RestrictedResource pPO ) {
654 547 return pPO.mUsers;
655 548 }
656 549
657 550 @Override
658 - public Object getValueOnPO( RestrictedResource pPO )
659 - {
551 + public Object getValueOnPO( RestrictedResource pPO ) {
660 552 return pPO.getUsers();
661 553 }
662 554
663 555 @Override
664 - public void setValueOnPO( RestrictedResource pPO, Object pValue )
665 - {
556 + public void setValueOnPO( RestrictedResource pPO, Object pValue ) {
666 557 pPO.setUsers( to_POs( pPO, UserXrefRestrictedResource.class, pValue ) );
667 558 }
668 559
669 560 @Override
670 - public void addValueOnPO( RestrictedResource pPO, Object pValue )
671 - {
561 + public void addValueOnPO( RestrictedResource pPO, Object pValue ) {
672 562 pPO.addUsers( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
673 563 }
674 564
675 565 @Override
676 - public void removeValueOnPO( RestrictedResource pPO, Object pValue )
677 - {
566 + public void removeValueOnPO( RestrictedResource pPO, Object pValue ) {
678 567 pPO.removeUsers( to_PO( pPO, UserXrefRestrictedResource.class, pValue ) );
679 568 }
680 569 }
681 570
682 571 static class MyMetaData
683 - extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<RestrictedResource>
684 - {
572 + extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<RestrictedResource> {
685 573 public static final String OBJECT_NAME = "RestrictedResource";
686 574 public static final String TABLE_NAME = "RestrictedResource";
687 575
688 - MyMetaData()
689 - {
576 + MyMetaData() {
690 577 super( OBJECT_NAME, TABLE_NAME, new AttributeAccessorKeySet( CD_ID ), //
691 578
692 579 CD_RecordVersion, /* ...... */
  @@ -713,32 +600,27 @@
713 600 }
714 601
715 602 @Override
716 - public Class getPOclass()
717 - {
603 + public Class getPOclass() {
718 604 return RestrictedResource.class;
719 605 }
720 606
721 607 @Override
722 - public RestrictedResource createNew( Transaction pTransaction )
723 - {
608 + public RestrictedResource createNew( Transaction pTransaction ) {
724 609 return new RestrictedResource( pTransaction );
725 610 }
726 611
727 612 @Override
728 - public RestrictedResource createPOfromFinder()
729 - {
613 + public RestrictedResource createPOfromFinder() {
730 614 return new RestrictedResource( CONSTRUCTION_CONTROL );
731 615 }
732 616
733 617 @Override
734 - public String getDisplayValueFormat()
735 - {
618 + public String getDisplayValueFormat() {
736 619 return "${Name}";
737 620 }
738 621
739 622 @Override
740 - public String getRecordVersionAttributeName()
741 - {
623 + public String getRecordVersionAttributeName() {
742 624 return CD_RecordVersion.getName();
743 625 }
744 626 }

View View this file contents

History View the full history

Feeds

Commits for /trunk/GWT_Sandbox/InitFrom/src/org/litesoft/initfrom/server/pos/RestrictedResourceGO.java

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