litesoft
Subversion Repository Public Repository

litesoft

URLs

Copy to Clipboard
Explore
Commits

Diff Revisions 947 vs 948 for /trunk/Java/DATT/src/org/litesoft/datt/server/pos/StoryGO.java

Diff revisions: vs.
  @@ -9,25 +9,21 @@
9 9
10 10 public abstract class StoryGO
11 11 extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<Story>
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 StoryMetaData.INSTANCE;
19 17 }
20 18
21 - protected StoryGO( Transaction pTransaction )
22 - {
19 + protected StoryGO( Transaction pTransaction ) {
23 20 super( StoryMetaData.INSTANCE, pTransaction );
24 21 mID = getNextSequenceNumber( getClass() );
25 22 registerWithTransaction();
26 23 setDefaults();
27 24 }
28 25
29 - protected StoryGO( ConstructionControl pConstructionControl )
30 - {
26 + protected StoryGO( ConstructionControl pConstructionControl ) {
31 27 super( StoryMetaData.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<Story>
45 - {
46 - public AttributeAccessor_RecordVersion()
47 - {
39 + extends AttributeAccessorSCD_RecordVersion<Story> {
40 + public AttributeAccessor_RecordVersion() {
48 41 super( "RecordVersion", "RecordVersion" );
49 42 }
50 43
51 44 @Override
52 - protected RecordVersionHelper getRecordVersionHelper( Story pPO )
53 - {
45 + protected RecordVersionHelper getRecordVersionHelper( Story 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<Story>
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( Story pPO )
84 - {
71 + public Object getValueOnPO( Story pPO ) {
85 72 return pPO.getID();
86 73 }
87 74
88 75 @Override
89 - public void db_setValueOnPO( Story pPO, Object pValue )
90 - {
76 + public void db_setValueOnPO( Story pPO, Object pValue ) {
91 77 pPO.LLsetID( to_Long( pValue ) );
92 78 }
93 79 }
  @@ -99,77 +85,64 @@
99 85 abstract protected void LLclearChanges();
100 86
101 87 private static class AttributeAccessor_Changes
102 - extends AttributeAccessorSCDsimpleVirtualReadOnly<Story>
103 - {
104 - public AttributeAccessor_Changes()
105 - {
88 + extends AttributeAccessorSCDsimpleVirtualReadOnly<Story> {
89 + public AttributeAccessor_Changes() {
106 90 super( "Changes", false, _Text.RO().with( DisplayWidthInitial.of( 40 ), //
107 91 DisplayHeightInitial.of( 4 ) ) );
108 92 }
109 93
110 94 @Override
111 - public Object getValueOnPO( Story pPO )
112 - {
95 + public Object getValueOnPO( Story pPO ) {
113 96 return pPO.getChanges();
114 97 }
115 98
116 99 @Override
117 - protected void LL_clearVirtualValueOnPO( Story pPO )
118 - {
100 + protected void LL_clearVirtualValueOnPO( Story pPO ) {
119 101 pPO.LLclearChanges();
120 102 }
121 103 }
122 104
123 - public static final AttributeAccessorSCDtoOneRegular<Story,User> CD_Creator = new AttributeAccessor_Creator();
105 + public static final AttributeAccessorSCDtoOneRegular<Story, User> CD_Creator = new AttributeAccessor_Creator();
124 106
125 - protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,User> mCreator = //
126 - new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,User>( (Story) this, CD_Creator );
107 + protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, User> mCreator = //
108 + new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, User>( (Story) this, CD_Creator );
127 109
128 - public User getCreator()
129 - {
110 + public User getCreator() {
130 111 return processLazyLoadAccess( mCreator );
131 112 }
132 113
133 - public void setCreator( User pCreator )
134 - {
114 + public void setCreator( User pCreator ) {
135 115 processLazyLoadMutation( mCreator, pCreator );
136 116 }
137 117
138 118 private static class AttributeAccessor_Creator
139 - extends AttributeAccessorSCDtoOneRegular<Story,User>
140 - {
141 - public AttributeAccessor_Creator()
142 - {
119 + extends AttributeAccessorSCDtoOneRegular<Story, User> {
120 + public AttributeAccessor_Creator() {
143 121 super( "Creator", "Creator_id", User.class, "ID", "Stories", false, true, Mutability.RW );
144 122 }
145 123
146 124 @Override
147 - public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,User> getValueHolder( Story pPO )
148 - {
125 + public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, User> getValueHolder( Story pPO ) {
149 126 return pPO.mCreator;
150 127 }
151 128
152 129 @Override
153 - public Object getValueOnPO( Story pPO )
154 - {
130 + public Object getValueOnPO( Story pPO ) {
155 131 return pPO.getCreator();
156 132 }
157 133
158 134 @Override
159 - public void setValueOnPO( Story pPO, Object pValue )
160 - {
135 + public void setValueOnPO( Story pPO, Object pValue ) {
161 136 pPO.setCreator( to_PO( pPO, User.class, pValue ) );
162 137 }
163 138
164 139 @Override
165 - public Object db_getValueOnPO( Story pPO )
166 - {
140 + public Object db_getValueOnPO( Story pPO ) {
167 141 return pPO.mCreator.db_getValue();
168 142 }
169 143
170 144 @Override
171 - public void db_setValueOnPO( Story pPO, Object pValue )
172 - {
145 + public void db_setValueOnPO( Story pPO, Object pValue ) {
173 146 pPO.mCreator.db_setValue( to_Long( pValue ) );
174 147 }
175 148 }
  @@ -178,37 +151,31 @@
178 151
179 152 private String mCreatorFullName;
180 153
181 - public String getCreatorFullName()
182 - {
154 + public String getCreatorFullName() {
183 155 return mCreatorFullName;
184 156 }
185 157
186 - public void setCreatorFullName( String pCreatorFullName )
187 - {
158 + public void setCreatorFullName( String pCreatorFullName ) {
188 159 verifyMutability( CD_CreatorFullName, mCreatorFullName, pCreatorFullName );
189 160 mCreatorFullName = pCreatorFullName;
190 161 }
191 162
192 163 private static class AttributeAccessor_CreatorFullName
193 164 extends AttributeAccessorSCDsimplePersistedRegular<Story>
194 - implements CharacterCaseIgnored
195 - {
196 - public AttributeAccessor_CreatorFullName()
197 - {
165 + implements CharacterCaseIgnored {
166 + public AttributeAccessor_CreatorFullName() {
198 167 super( "CreatorFullName", "CreatorFullName", false, _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( Story pPO )
205 - {
173 + public Object getValueOnPO( Story pPO ) {
206 174 return pPO.getCreatorFullName();
207 175 }
208 176
209 177 @Override
210 - public void setValueOnPO( Story pPO, Object pValue )
211 - {
178 + public void setValueOnPO( Story pPO, Object pValue ) {
212 179 pPO.setCreatorFullName( to_String( pValue ) );
213 180 }
214 181 }
  @@ -217,35 +184,29 @@
217 184
218 185 private String mDescription;
219 186
220 - public String getDescription()
221 - {
187 + public String getDescription() {
222 188 return mDescription;
223 189 }
224 190
225 - public void setDescription( String pDescription )
226 - {
191 + public void setDescription( String pDescription ) {
227 192 verifyMutability( CD_Description, mDescription, pDescription );
228 193 mDescription = pDescription;
229 194 }
230 195
231 196 private static class AttributeAccessor_Description
232 - extends AttributeAccessorSCDsimplePersistedRegular<Story>
233 - {
234 - public AttributeAccessor_Description()
235 - {
197 + extends AttributeAccessorSCDsimplePersistedRegular<Story> {
198 + public AttributeAccessor_Description() {
236 199 super( "Description", "Description", false, _Text.with( DisplayWidthInitial.of( 40 ), //
237 200 DisplayHeightInitial.of( 4 ) ) );
238 201 }
239 202
240 203 @Override
241 - public Object getValueOnPO( Story pPO )
242 - {
204 + public Object getValueOnPO( Story pPO ) {
243 205 return pPO.getDescription();
244 206 }
245 207
246 208 @Override
247 - public void setValueOnPO( Story pPO, Object pValue )
248 - {
209 + public void setValueOnPO( Story pPO, Object pValue ) {
249 210 pPO.setDescription( to_String( pValue ) );
250 211 }
251 212 }
  @@ -254,40 +215,33 @@
254 215
255 216 private Boolean mIsDone;
256 217
257 - public Boolean getIsDone()
258 - {
218 + public Boolean getIsDone() {
259 219 return mIsDone;
260 220 }
261 221
262 - public void setIsDone( Boolean pIsDone )
263 - {
222 + public void setIsDone( Boolean pIsDone ) {
264 223 verifyMutability( CD_IsDone, mIsDone, pIsDone );
265 224 mIsDone = pIsDone;
266 225 }
267 226
268 227 private static class AttributeAccessor_IsDone
269 - extends AttributeAccessorSCDsimplePersistedRegular<Story>
270 - {
271 - public AttributeAccessor_IsDone()
272 - {
228 + extends AttributeAccessorSCDsimplePersistedRegular<Story> {
229 + public AttributeAccessor_IsDone() {
273 230 super( "IsDone", "IsDone", true, _Boolean );
274 231 }
275 232
276 233 @Override
277 - public Object getDefault()
278 - {
234 + public Object getDefault() {
279 235 return false;
280 236 }
281 237
282 238 @Override
283 - public Object getValueOnPO( Story pPO )
284 - {
239 + public Object getValueOnPO( Story pPO ) {
285 240 return pPO.getIsDone();
286 241 }
287 242
288 243 @Override
289 - public void setValueOnPO( Story pPO, Object pValue )
290 - {
244 + public void setValueOnPO( Story pPO, Object pValue ) {
291 245 pPO.setIsDone( to_Boolean( pValue ) );
292 246 }
293 247 }
  @@ -296,37 +250,31 @@
296 250
297 251 private String mName;
298 252
299 - public String getName()
300 - {
253 + public String getName() {
301 254 return mName;
302 255 }
303 256
304 - public void setName( String pName )
305 - {
257 + public void setName( String pName ) {
306 258 verifyMutability( CD_Name, mName, pName );
307 259 mName = pName;
308 260 }
309 261
310 262 private static class AttributeAccessor_Name
311 263 extends AttributeAccessorSCDsimplePersistedRegular<Story>
312 - implements CharacterCaseIgnored
313 - {
314 - public AttributeAccessor_Name()
315 - {
264 + implements CharacterCaseIgnored {
265 + public AttributeAccessor_Name() {
316 266 super( "Name", "Name", true, _String.with( MaxLength.of( 40 ), //
317 267 DisplayLength.of( 20 ), //
318 268 Case.Ignored ) );
319 269 }
320 270
321 271 @Override
322 - public Object getValueOnPO( Story pPO )
323 - {
272 + public Object getValueOnPO( Story pPO ) {
324 273 return pPO.getName();
325 274 }
326 275
327 276 @Override
328 - public void setValueOnPO( Story pPO, Object pValue )
329 - {
277 + public void setValueOnPO( Story pPO, Object pValue ) {
330 278 pPO.setName( to_String( pValue ) );
331 279 }
332 280 }
  @@ -338,40 +286,33 @@
338 286 /**
339 287 * Allow insertion of priorities in between
340 288 */
341 - public Float getPriority()
342 - {
289 + public Float getPriority() {
343 290 return mPriority;
344 291 }
345 292
346 - public void setPriority( Float pPriority )
347 - {
293 + public void setPriority( Float pPriority ) {
348 294 verifyMutability( CD_Priority, mPriority, pPriority );
349 295 mPriority = pPriority;
350 296 }
351 297
352 298 private static class AttributeAccessor_Priority
353 - extends AttributeAccessorSCDsimplePersistedRegular<Story>
354 - {
355 - public AttributeAccessor_Priority()
356 - {
299 + extends AttributeAccessorSCDsimplePersistedRegular<Story> {
300 + public AttributeAccessor_Priority() {
357 301 super( "Priority", "Priority", true, _Float.with( DisplayLength.of( 9 ) ) );
358 302 }
359 303
360 304 @Override
361 - public Object getDefault()
362 - {
305 + public Object getDefault() {
363 306 return "0";
364 307 }
365 308
366 309 @Override
367 - public Object getValueOnPO( Story pPO )
368 - {
310 + public Object getValueOnPO( Story pPO ) {
369 311 return pPO.getPriority();
370 312 }
371 313
372 314 @Override
373 - public void setValueOnPO( Story pPO, Object pValue )
374 - {
315 + public void setValueOnPO( Story pPO, Object pValue ) {
375 316 pPO.setPriority( to_Float( pValue ) );
376 317 }
377 318 }
  @@ -380,283 +321,235 @@
380 321
381 322 private String mPriorityLastChangedBy;
382 323
383 - public String getPriorityLastChangedBy()
384 - {
324 + public String getPriorityLastChangedBy() {
385 325 return mPriorityLastChangedBy;
386 326 }
387 327
388 - public void setPriorityLastChangedBy( String pPriorityLastChangedBy )
389 - {
328 + public void setPriorityLastChangedBy( String pPriorityLastChangedBy ) {
390 329 verifyMutability( CD_PriorityLastChangedBy, mPriorityLastChangedBy, pPriorityLastChangedBy );
391 330 mPriorityLastChangedBy = pPriorityLastChangedBy;
392 331 }
393 332
394 333 private static class AttributeAccessor_PriorityLastChangedBy
395 - extends AttributeAccessorSCDsimplePersistedRegular<Story>
396 - {
397 - public AttributeAccessor_PriorityLastChangedBy()
398 - {
334 + extends AttributeAccessorSCDsimplePersistedRegular<Story> {
335 + public AttributeAccessor_PriorityLastChangedBy() {
399 336 super( "PriorityLastChangedBy", "PriorityLastChangedBy", false, _String.with( MaxLength.of( 40 ), //
400 337 DisplayLength.of( 20 ) ) );
401 338 }
402 339
403 340 @Override
404 - public Object getValueOnPO( Story pPO )
405 - {
341 + public Object getValueOnPO( Story pPO ) {
406 342 return pPO.getPriorityLastChangedBy();
407 343 }
408 344
409 345 @Override
410 - public void setValueOnPO( Story pPO, Object pValue )
411 - {
346 + public void setValueOnPO( Story pPO, Object pValue ) {
412 347 pPO.setPriorityLastChangedBy( to_String( pValue ) );
413 348 }
414 349 }
415 350
416 - public static final AttributeAccessorSCDtoOneRegular<Story,RestrictedResource> CD_RestrictedResource = new AttributeAccessor_RestrictedResource();
351 + public static final AttributeAccessorSCDtoOneRegular<Story, RestrictedResource> CD_RestrictedResource = new AttributeAccessor_RestrictedResource();
417 352
418 - protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,RestrictedResource> mRestrictedResource = //
419 - new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,RestrictedResource>( (Story) this, CD_RestrictedResource );
353 + protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, RestrictedResource> mRestrictedResource = //
354 + new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, RestrictedResource>( (Story) this, CD_RestrictedResource );
420 355
421 - public RestrictedResource getRestrictedResource()
422 - {
356 + public RestrictedResource getRestrictedResource() {
423 357 return processLazyLoadAccess( mRestrictedResource );
424 358 }
425 359
426 - public void setRestrictedResource( RestrictedResource pRestrictedResource )
427 - {
360 + public void setRestrictedResource( RestrictedResource pRestrictedResource ) {
428 361 processLazyLoadMutation( mRestrictedResource, pRestrictedResource );
429 362 }
430 363
431 364 private static class AttributeAccessor_RestrictedResource
432 - extends AttributeAccessorSCDtoOneRegular<Story,RestrictedResource>
433 - {
434 - public AttributeAccessor_RestrictedResource()
435 - {
365 + extends AttributeAccessorSCDtoOneRegular<Story, RestrictedResource> {
366 + public AttributeAccessor_RestrictedResource() {
436 367 super( "RestrictedResource", "RestrictedResource_id", RestrictedResource.class, "ID", "Stories", false, true, Mutability.RW );
437 368 }
438 369
439 370 @Override
440 - public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,RestrictedResource> getValueHolder( Story pPO )
441 - {
371 + public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, RestrictedResource> getValueHolder( Story pPO ) {
442 372 return pPO.mRestrictedResource;
443 373 }
444 374
445 375 @Override
446 - public Object getValueOnPO( Story pPO )
447 - {
376 + public Object getValueOnPO( Story pPO ) {
448 377 return pPO.getRestrictedResource();
449 378 }
450 379
451 380 @Override
452 - public void setValueOnPO( Story pPO, Object pValue )
453 - {
381 + public void setValueOnPO( Story pPO, Object pValue ) {
454 382 pPO.setRestrictedResource( to_PO( pPO, RestrictedResource.class, pValue ) );
455 383 }
456 384
457 385 @Override
458 - public Object db_getValueOnPO( Story pPO )
459 - {
386 + public Object db_getValueOnPO( Story pPO ) {
460 387 return pPO.mRestrictedResource.db_getValue();
461 388 }
462 389
463 390 @Override
464 - public void db_setValueOnPO( Story pPO, Object pValue )
465 - {
391 + public void db_setValueOnPO( Story pPO, Object pValue ) {
466 392 pPO.mRestrictedResource.db_setValue( to_Long( pValue ) );
467 393 }
468 394 }
469 395
470 - public static final AttributeAccessorSCDtoOneRegular<Story,StoryTemplate> CD_StoryTemplate = new AttributeAccessor_StoryTemplate();
396 + public static final AttributeAccessorSCDtoOneRegular<Story, StoryTemplate> CD_StoryTemplate = new AttributeAccessor_StoryTemplate();
471 397
472 - protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,StoryTemplate> mStoryTemplate = //
473 - new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,StoryTemplate>( (Story) this, CD_StoryTemplate );
398 + protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, StoryTemplate> mStoryTemplate = //
399 + new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, StoryTemplate>( (Story) this, CD_StoryTemplate );
474 400
475 - public StoryTemplate getStoryTemplate()
476 - {
401 + public StoryTemplate getStoryTemplate() {
477 402 return processLazyLoadAccess( mStoryTemplate );
478 403 }
479 404
480 - public void setStoryTemplate( StoryTemplate pStoryTemplate )
481 - {
405 + public void setStoryTemplate( StoryTemplate pStoryTemplate ) {
482 406 processLazyLoadMutation( mStoryTemplate, pStoryTemplate );
483 407 }
484 408
485 409 private static class AttributeAccessor_StoryTemplate
486 - extends AttributeAccessorSCDtoOneRegular<Story,StoryTemplate>
487 - {
488 - public AttributeAccessor_StoryTemplate()
489 - {
410 + extends AttributeAccessorSCDtoOneRegular<Story, StoryTemplate> {
411 + public AttributeAccessor_StoryTemplate() {
490 412 super( "StoryTemplate", "StoryTemplate_id", StoryTemplate.class, "ID", "Stories", false, false, Mutability.RW );
491 413 }
492 414
493 415 @Override
494 - public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story,StoryTemplate> getValueHolder( Story pPO )
495 - {
416 + public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<Story, StoryTemplate> getValueHolder( Story pPO ) {
496 417 return pPO.mStoryTemplate;
497 418 }
498 419
499 420 @Override
500 - public Object getValueOnPO( Story pPO )
501 - {
421 + public Object getValueOnPO( Story pPO ) {
502 422 return pPO.getStoryTemplate();
503 423 }
504 424
505 425 @Override
506 - public void setValueOnPO( Story pPO, Object pValue )
507 - {
426 + public void setValueOnPO( Story pPO, Object pValue ) {
508 427 pPO.setStoryTemplate( to_PO( pPO, StoryTemplate.class, pValue ) );
509 428 }
510 429
511 430 @Override
512 - public Object db_getValueOnPO( Story pPO )
513 - {
431 + public Object db_getValueOnPO( Story pPO ) {
514 432 return pPO.mStoryTemplate.db_getValue();
515 433 }
516 434
517 435 @Override
518 - public void db_setValueOnPO( Story pPO, Object pValue )
519 - {
436 + public void db_setValueOnPO( Story pPO, Object pValue ) {
520 437 pPO.mStoryTemplate.db_setValue( to_Long( pValue ) );
521 438 }
522 439 }
523 440
524 - public static final AttributeAccessorSCDtoManyRegular<Story,Task> CD_Tasks = new AttributeAccessor_Tasks();
441 + public static final AttributeAccessorSCDtoManyRegular<Story, Task> CD_Tasks = new AttributeAccessor_Tasks();
525 442
526 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story,Task> mTasks = //
527 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story,Task>( (Story) this, CD_Tasks );
443 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story, Task> mTasks = //
444 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story, Task>( (Story) this, CD_Tasks );
528 445
529 - public java.util.List<Task> getTasks()
530 - {
446 + public java.util.List<Task> getTasks() {
531 447 return processLazyLoadAccess( mTasks );
532 448 }
533 449
534 - public void setTasks( java.util.List<Task> pTasks )
535 - {
450 + public void setTasks( java.util.List<Task> pTasks ) {
536 451 processLazyLoadMutation( mTasks, pTasks );
537 452 }
538 453
539 - public void addTasks( Task pTasks )
540 - {
454 + public void addTasks( Task pTasks ) {
541 455 processLazyLoadMutationAdd( mTasks, pTasks );
542 456 }
543 457
544 - public void removeTasks( Task pTasks )
545 - {
458 + public void removeTasks( Task pTasks ) {
546 459 processLazyLoadMutationRemove( mTasks, pTasks );
547 460 }
548 461
549 462 private static class AttributeAccessor_Tasks
550 - extends AttributeAccessorSCDtoManyRegular<Story,Task>
551 - {
552 - public AttributeAccessor_Tasks()
553 - {
463 + extends AttributeAccessorSCDtoManyRegular<Story, Task> {
464 + public AttributeAccessor_Tasks() {
554 465 super( "Tasks", "ID", Task.class, "Story", null, Mutability.RW, false, true );
555 466 }
556 467
557 468 @Override
558 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story,Task> getValueHolder( Story pPO )
559 - {
469 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story, Task> getValueHolder( Story pPO ) {
560 470 return pPO.mTasks;
561 471 }
562 472
563 473 @Override
564 - public Object getValueOnPO( Story pPO )
565 - {
474 + public Object getValueOnPO( Story pPO ) {
566 475 return pPO.getTasks();
567 476 }
568 477
569 478 @Override
570 - public void setValueOnPO( Story pPO, Object pValue )
571 - {
479 + public void setValueOnPO( Story pPO, Object pValue ) {
572 480 pPO.setTasks( to_POs( pPO, Task.class, pValue ) );
573 481 }
574 482
575 483 @Override
576 - public void addValueOnPO( Story pPO, Object pValue )
577 - {
484 + public void addValueOnPO( Story pPO, Object pValue ) {
578 485 pPO.addTasks( to_PO( pPO, Task.class, pValue ) );
579 486 }
580 487
581 488 @Override
582 - public void removeValueOnPO( Story pPO, Object pValue )
583 - {
489 + public void removeValueOnPO( Story pPO, Object pValue ) {
584 490 pPO.removeTasks( to_PO( pPO, Task.class, pValue ) );
585 491 }
586 492 }
587 493
588 - public static final AttributeAccessorSCDtoManyRegular<Story,StoryUpdate> CD_Updates = new AttributeAccessor_Updates();
494 + public static final AttributeAccessorSCDtoManyRegular<Story, StoryUpdate> CD_Updates = new AttributeAccessor_Updates();
589 495
590 - protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story,StoryUpdate> mUpdates = //
591 - new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story,StoryUpdate>( (Story) this, CD_Updates );
496 + protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story, StoryUpdate> mUpdates = //
497 + new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story, StoryUpdate>( (Story) this, CD_Updates );
592 498
593 - public java.util.List<StoryUpdate> getUpdates()
594 - {
499 + public java.util.List<StoryUpdate> getUpdates() {
595 500 return processLazyLoadAccess( mUpdates );
596 501 }
597 502
598 - public void setUpdates( java.util.List<StoryUpdate> pUpdates )
599 - {
503 + public void setUpdates( java.util.List<StoryUpdate> pUpdates ) {
600 504 processLazyLoadMutation( mUpdates, pUpdates );
601 505 }
602 506
603 - public void addUpdates( StoryUpdate pUpdates )
604 - {
507 + public void addUpdates( StoryUpdate pUpdates ) {
605 508 processLazyLoadMutationAdd( mUpdates, pUpdates );
606 509 }
607 510
608 - public void removeUpdates( StoryUpdate pUpdates )
609 - {
511 + public void removeUpdates( StoryUpdate pUpdates ) {
610 512 processLazyLoadMutationRemove( mUpdates, pUpdates );
611 513 }
612 514
613 515 private static class AttributeAccessor_Updates
614 - extends AttributeAccessorSCDtoManyRegular<Story,StoryUpdate>
615 - {
616 - public AttributeAccessor_Updates()
617 - {
516 + extends AttributeAccessorSCDtoManyRegular<Story, StoryUpdate> {
517 + public AttributeAccessor_Updates() {
618 518 super( "Updates", "ID", StoryUpdate.class, "Story", null, Mutability.RW, false, true );
619 519 }
620 520
621 521 @Override
622 - public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story,StoryUpdate> getValueHolder( Story pPO )
623 - {
522 + public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<Story, StoryUpdate> getValueHolder( Story pPO ) {
624 523 return pPO.mUpdates;
625 524 }
626 525
627 526 @Override
628 - public Object getValueOnPO( Story pPO )
629 - {
527 + public Object getValueOnPO( Story pPO ) {
630 528 return pPO.getUpdates();
631 529 }
632 530
633 531 @Override
634 - public void setValueOnPO( Story pPO, Object pValue )
635 - {
532 + public void setValueOnPO( Story pPO, Object pValue ) {
636 533 pPO.setUpdates( to_POs( pPO, StoryUpdate.class, pValue ) );
637 534 }
638 535
639 536 @Override
640 - public void addValueOnPO( Story pPO, Object pValue )
641 - {
537 + public void addValueOnPO( Story pPO, Object pValue ) {
642 538 pPO.addUpdates( to_PO( pPO, StoryUpdate.class, pValue ) );
643 539 }
644 540
645 541 @Override
646 - public void removeValueOnPO( Story pPO, Object pValue )
647 - {
542 + public void removeValueOnPO( Story pPO, Object pValue ) {
648 543 pPO.removeUpdates( to_PO( pPO, StoryUpdate.class, pValue ) );
649 544 }
650 545 }
651 546
652 547 static class MyMetaData
653 - extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<Story>
654 - {
548 + extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<Story> {
655 549 public static final String OBJECT_NAME = "Story";
656 550 public static final String TABLE_NAME = "Story";
657 551
658 - MyMetaData()
659 - {
552 + MyMetaData() {
660 553 super( OBJECT_NAME, TABLE_NAME, new AttributeAccessorKeySet( CD_ID ), //
661 554
662 555 CD_RecordVersion, /* .......... */
  @@ -689,38 +582,32 @@
689 582 }
690 583
691 584 @Override
692 - public Class getPOclass()
693 - {
585 + public Class getPOclass() {
694 586 return Story.class;
695 587 }
696 588
697 589 @Override
698 - public Story createNew( Transaction pTransaction )
699 - {
590 + public Story createNew( Transaction pTransaction ) {
700 591 return new Story( pTransaction );
701 592 }
702 593
703 594 @Override
704 - public Story createPOfromFinder()
705 - {
595 + public Story createPOfromFinder() {
706 596 return new Story( CONSTRUCTION_CONTROL );
707 597 }
708 598
709 599 @Override
710 - public String getDisplayValueFormat()
711 - {
600 + public String getDisplayValueFormat() {
712 601 return "${Name}";
713 602 }
714 603
715 604 @Override
716 - public String getRecordVersionAttributeName()
717 - {
605 + public String getRecordVersionAttributeName() {
718 606 return CD_RecordVersion.getName();
719 607 }
720 608
721 609 @Override
722 - public String getDefaultOrderByAttributeName()
723 - {
610 + public String getDefaultOrderByAttributeName() {
724 611 return "!Priority";
725 612 }
726 613 }

View View this file contents

History View the full history

Feeds

Commits for /trunk/Java/DATT/src/org/litesoft/datt/server/pos/StoryGO.java

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