001: package org.apache.ojb.broker;
002:
003: /**
004: * TestClasses for Per-Criteria-Path-Hints
005: * @author PAW
006: *
007: */
008: import java.util.ArrayList;
009: import java.util.Collection;
010: import java.util.Iterator;
011:
012: import junit.framework.TestCase;
013: import org.apache.ojb.broker.query.Criteria;
014: import org.apache.ojb.broker.query.Query;
015: import org.apache.ojb.broker.query.QueryByCriteria;
016: import org.apache.ojb.broker.query.QueryFactory;
017: import org.apache.ojb.broker.query.UserAlias;
018:
019: public class PathTest extends TestCase {
020:
021: private static Class CLASS = PathTest.class;
022: private int COUNT = 10;
023: private int id_filter = 10000;
024: private PersistenceBroker broker = null;
025:
026: public static void main(String[] args) {
027: String[] arr = { CLASS.getName() };
028: junit.textui.TestRunner.main(arr);
029: }
030:
031: /**
032: * Insert the method's description here.
033: * Creation date: (06.12.2000 21:58:53)
034: */
035: public void setUp() {
036: try {
037: broker = PersistenceBrokerFactory
038: .defaultPersistenceBroker();
039: } catch (PBFactoryException e) {
040: }
041: }
042:
043: /**
044: * Insert the method's description here.
045: * Creation date: (06.12.2000 21:59:14)
046: */
047: public void tearDown() {
048: broker.close();
049: }
050:
051: public PathTest(String name) {
052: super (name);
053: }
054:
055: public void testDeleteData() throws Exception {
056: broker.beginTransaction();
057: Criteria crit = new Criteria();
058:
059: Query query = QueryFactory.newQuery(D.class, crit);
060: Collection Ds = broker.getCollectionByQuery(query);
061: for (Iterator iterator = Ds.iterator(); iterator.hasNext();) {
062: broker.delete(iterator.next());
063: }
064: query = QueryFactory.newQuery(C.class, crit);
065: Collection Cs = broker.getCollectionByQuery(query);
066: for (Iterator iterator = Cs.iterator(); iterator.hasNext();) {
067: broker.delete(iterator.next());
068: }
069: query = QueryFactory.newQuery(B.class, crit);
070: Collection Bs = broker.getCollectionByQuery(query);
071: for (Iterator iterator = Bs.iterator(); iterator.hasNext();) {
072: broker.delete(iterator.next());
073: }
074: query = QueryFactory.newQuery(A.class, crit);
075: Collection As = broker.getCollectionByQuery(query);
076: for (Iterator iterator = As.iterator(); iterator.hasNext();) {
077: broker.delete(iterator.next());
078: }
079: broker.commitTransaction();
080: }
081:
082: // private static int NUM_A = 1;
083: // private static int NUM_B_PER_A = 4;
084: // private static int NUM_C_PER_B = 2;
085: // private static int NUM_C1_PER_B = 3;
086: // private static int NUM_D_PER_C = 1;
087:
088: private static int NUM_A = 3;
089: private static int NUM_B_PER_A = 4;
090: private static int NUM_C_PER_B = 2;
091: private static int NUM_C1_PER_B = 3;
092: private static int NUM_D_PER_C = 2;
093:
094: private static int A_OFFSET = 10000;
095: private static int B_OFFSET = 1000;
096: private static int C_OFFSET = 100;
097: private static int D_OFFSET = 10;
098:
099: public void testCreateData() throws Exception {
100: broker.beginTransaction();
101:
102: for (int ia = 0; ia < NUM_A; ia++) {
103: A a = new A(A_OFFSET + A_OFFSET * ia);
104: broker.store(a);
105: System.out.println("A - " + a.getAAttrib());
106: for (int ib = 0; ib < NUM_B_PER_A; ib++) {
107: B b = new B(A_OFFSET + B_OFFSET * ib);
108: b.setA(a);
109: broker.store(b);
110: System.out.println("\tB - " + b.getBAttrib());
111: for (int ic = 0; ic < NUM_C_PER_B; ic++) {
112: C c = new C(A_OFFSET + B_OFFSET * ib + C_OFFSET
113: * ic);
114: c.setB(b);
115: for (int id = 0; id < NUM_D_PER_C; id++) {
116: D d = new D(A_OFFSET + B_OFFSET * ib + C_OFFSET
117: * ic + D_OFFSET * id);
118: c.setD(d);
119: broker.store(d);
120: broker.store(c);
121: System.out.println("\t\tC - " + c.getCAttrib());
122: System.out.println("\t\t\tD - "
123: + d.getDAttrib());
124: }
125: }
126: for (int ic = 0; ic < NUM_C1_PER_B; ic++) {
127: C1 c1 = new C1(A_OFFSET + B_OFFSET * ib + C_OFFSET
128: * ic);
129: c1.setB(b);
130: for (int id = 0; id < NUM_D_PER_C; id++) {
131: D d = new D(A_OFFSET + B_OFFSET * ib + C_OFFSET
132: * ic + D_OFFSET * id);
133: c1.setD(d);
134: c1.setC1Attrib(c1.getCAttrib() + 1);
135: broker.store(d);
136: broker.store(c1);
137: System.out.println("\t\tC1 - "
138: + c1.getC1Attrib());
139: System.out.println("\t\t\tD - "
140: + d.getDAttrib());
141: }
142: }
143: }
144: }
145:
146: broker.commitTransaction();
147:
148: broker.clearCache();
149:
150: Criteria crit = new Criteria();
151:
152: Query query = QueryFactory.newQuery(A.class, crit);
153: Collection As = broker.getCollectionByQuery(query);
154: assertEquals(NUM_A, As.size());
155:
156: query = QueryFactory.newQuery(B.class, crit);
157: Collection Bs = broker.getCollectionByQuery(query);
158: int numB = NUM_A * NUM_B_PER_A;
159: assertEquals(numB, Bs.size());
160:
161: query = QueryFactory.newQuery(C.class, crit);
162: Collection Cs = broker.getCollectionByQuery(query);
163: int numC = numB * (NUM_C_PER_B + NUM_C1_PER_B);
164: assertEquals(numC, Cs.size());
165:
166: query = QueryFactory.newQuery(D.class, crit);
167: Collection Ds = broker.getCollectionByQuery(query);
168: int numD = numC * NUM_D_PER_C;
169: assertEquals(numD, Ds.size());
170:
171: }
172:
173: // This is the result of the above population for NUM_A = 1
174: //
175: // A - 10000
176: // B - 10000
177: // C - 10000
178: // D - 10010
179: // C - 10100
180: // D - 10110
181: // C1 - 10001
182: // D - 10010
183: // C1 - 10101
184: // D - 10110
185: // C1 - 10201
186: // D - 10210
187: // B - 11000
188: // C - 11000
189: // D - 11010
190: // C - 11100
191: // D - 11110
192: // C1 - 11001
193: // D - 11010
194: // C1 - 11101
195: // D - 11110
196: // C1 - 11201
197: // D - 11210
198: // B - 12000
199: // C - 12000
200: // D - 12010
201: // C - 12100
202: // D - 12110
203: // C1 - 12001
204: // D - 12010
205: // C1 - 12101
206: // D - 12110
207: // C1 - 12201
208: // D - 12210
209: // B - 13000
210: // C - 13000
211: // D - 13010
212: // C - 13100
213: // D - 13110
214: // C1 - 13001
215: // D - 13010
216: // C1 - 13101
217: // D - 13110
218: // C1 - 13201
219: // D - 13210
220:
221: /*
222: * Find all Bs having a particular C1 (c1)
223: * Works
224: */
225: public void testPathClassOnSegment1() throws Exception {
226: try {
227: // c1 criteria
228: Criteria crit1 = new Criteria();
229: crit1.addEqualTo("cSet.c1Attrib", new Integer("10001"));
230: crit1.addPathClass("cSet", C1.class);
231:
232: Query query = new QueryByCriteria(B.class, crit1);
233:
234: Collection allBs = broker.getCollectionByQuery(query);
235:
236: java.util.Iterator itr = allBs.iterator();
237:
238: assertEquals(1 * NUM_A, allBs.size());
239: System.out
240: .println("testPathClassOnSegment1() iteration size:"
241: + allBs.size());
242: while (itr.hasNext()) {
243: B b = (B) itr.next();
244: System.out.println("Found B: " + b.getId() + " "
245: + b.getBAttrib());
246: }
247: } catch (Throwable t) {
248: t.printStackTrace(System.out);
249: fail("testPathClassOnSegment1: " + t.getMessage());
250: }
251: }
252:
253: /*
254: * Find all As having a particular C1 (c1)
255: * Works
256: */
257: public void testPathClassOnSegment2() throws Exception {
258: try {
259: // c1 criteria
260: Criteria crit1 = new Criteria();
261: crit1
262: .addEqualTo("bSet.cSet.c1Attrib", new Integer(
263: "10001"));
264: crit1.addPathClass("bSet.cSet", C1.class);
265:
266: Query query = new QueryByCriteria(A.class, crit1);
267:
268: Collection allAs = broker.getCollectionByQuery(query);
269:
270: java.util.Iterator itr = allAs.iterator();
271:
272: assertEquals(allAs.size(), 1 * NUM_A);
273: System.out
274: .println("testPathClassOnSegment2() iteration size:"
275: + allAs.size());
276: while (itr.hasNext()) {
277: A a = (A) itr.next();
278: System.out.println("Found A: " + a.getId() + " "
279: + a.getAAttrib());
280: }
281: } catch (Throwable t) {
282: t.printStackTrace(System.out);
283: fail("testPathClassOnSegment2: " + t.getMessage());
284: }
285: }
286:
287: /*
288: * Find all Bs having a C with a particular D (d1)
289: * Works
290: */
291: public void testSingleAlias() throws Exception {
292: try {
293: // d1 criteria
294: Criteria crit1 = new Criteria();
295: crit1.setAlias("cToD1", "cSet"); // unnecessary, but its use should not
296: // cause incorrect results
297: crit1.addEqualTo("cSet.d.dAttrib", new Integer("10010"));
298:
299: Query query = new QueryByCriteria(B.class, crit1);
300:
301: Collection allBs = broker.getCollectionByQuery(query);
302:
303: java.util.Iterator itr = allBs.iterator();
304:
305: assertEquals(2 * NUM_A, allBs.size());
306: System.out.println("testSingleAlias() iteration size:"
307: + allBs.size());
308: while (itr.hasNext()) {
309: B b = (B) itr.next();
310: System.out.println("Found B: " + b.getId() + " "
311: + b.getBAttrib());
312: }
313: } catch (Throwable t) {
314: t.printStackTrace(System.out);
315: fail("testSingleAlias: " + t.getMessage());
316: }
317: }
318:
319: /*
320: * Find all Bs having any C with a particular D (d1) and any C with a particular D (d2)
321: * Works
322: */
323: public void testTwoAliasesTwoSegments() throws Exception {
324: try {
325: // d1 criteria
326: Criteria crit1 = new Criteria();
327: crit1.setAlias("cToD1", "cSet.d");
328: crit1.addEqualTo("cSet.d.dAttrib", new Integer("10010"));
329:
330: // d2 criteria
331: Criteria crit2 = new Criteria();
332: crit2.setAlias("cToD2", "cSet.d");
333: crit2.addEqualTo("cSet.d.dAttrib", new Integer("10110"));
334:
335: crit1.addAndCriteria(crit2);
336:
337: Query query = new QueryByCriteria(B.class, crit1);
338:
339: Collection allBs = broker.getCollectionByQuery(query);
340:
341: java.util.Iterator itr = allBs.iterator();
342:
343: assertEquals(4 * NUM_A, allBs.size());
344: System.out
345: .println("testTwoAliasesTwoSegments() iteration size:"
346: + allBs.size());
347: while (itr.hasNext()) {
348: B b = (B) itr.next();
349: System.out.println("Found B: " + b.getId() + " "
350: + b.getBAttrib());
351: }
352: } catch (Throwable t) {
353: t.printStackTrace(System.out);
354: fail("testTwoAliasesTwoSegments: " + t.getMessage());
355: }
356: }
357:
358: /*
359: * Find all As having any B with any C with a particular D (d1) and any C with a particular D (d2)
360: * Works
361: */
362: public void testTwoAliasesThreeSegments() throws Exception {
363: try {
364: // d1 criteria
365: Criteria crit1 = new Criteria();
366: crit1.addEqualTo("bSet.cSet.d.dAttrib",
367: new Integer("10010"));
368: crit1.setAlias("bToCToD1", "cSet.d");
369:
370: // d2 criteria
371: Criteria crit2 = new Criteria();
372: crit2.addEqualTo("bSet.cSet.d.dAttrib",
373: new Integer("10110"));
374: crit2.setAlias("bToCToD2", "cSet.d");
375:
376: crit1.addAndCriteria(crit2);
377:
378: boolean isDistinct = true;
379: Query query = new QueryByCriteria(A.class, crit1, true);
380:
381: Collection allAs = broker.getCollectionByQuery(query);
382:
383: java.util.Iterator itr = allAs.iterator();
384:
385: assertEquals(1 * NUM_A, allAs.size());
386: System.out
387: .println("testTwoAliasesThreeSegments() iteration size:"
388: + allAs.size());
389: while (itr.hasNext()) {
390: A a = (A) itr.next();
391: System.out.println("Found A: " + a.getId() + " "
392: + a.getAAttrib());
393: }
394: } catch (Throwable t) {
395: t.printStackTrace(System.out);
396: fail("testTwoAliasesThreeSegments: " + t.getMessage());
397: }
398: }
399:
400: /*
401: * Find all Bs having a particular C (c) and a particular C1 (c1)
402: */
403: public void testPathClassPerCriteria() throws Exception {
404: try {
405: // C criteria
406: Criteria crit1 = new Criteria();
407: crit1.addEqualTo("cSet.cAttrib", new Integer("10200"));
408: crit1.addPathClass("cSet", C.class);
409: crit1.setAlias("alias1");
410:
411: // C1 criteria (subclass of C)
412: Criteria crit2 = new Criteria();
413: crit2.addEqualTo("cSet.c1Attrib", new Integer("10001"));
414: crit2.addPathClass("cSet", C1.class);
415: crit2.setAlias("alias2");
416:
417: crit1.addAndCriteria(crit2);
418:
419: Query query = new QueryByCriteria(B.class, crit1);
420:
421: Collection allBs = broker.getCollectionByQuery(query);
422:
423: java.util.Iterator itr = allBs.iterator();
424:
425: assertEquals(1 * NUM_A, allBs.size());
426: System.out
427: .println("testPathClassPerCriteria() iteration size:"
428: + allBs.size());
429: while (itr.hasNext()) {
430: B b = (B) itr.next();
431: System.out.println("Found B: " + b.getId() + " "
432: + b.getBAttrib());
433: }
434: } catch (Throwable t) {
435: t.printStackTrace(System.out);
436: fail("testPathClassPerCriteria: " + t.getMessage());
437: }
438: }
439:
440: /*
441: * Find all Bs having a particular C1 (c1_a) and a particular C3 (c1_b)
442: * Works
443: */
444: public void testPathClassPerQuery() throws Exception {
445: try {
446: // c1_a criteria
447: Criteria crit1 = new Criteria();
448: crit1.addEqualTo("cSet.c1Attrib", new Integer("12001"));
449: //crit1.addPathClass("cSet", C1.class); // can use 1 query setting instead
450: crit1.setAlias("alias1");
451:
452: // c2_b criteria
453: Criteria crit2 = new Criteria();
454: crit2.addEqualTo("cSet.c1Attrib", new Integer("12101"));
455: //crit2.addPathClass("cSet", C1.class); // can use 1 query setting instead
456: crit2.setAlias("alias2");
457:
458: crit1.addAndCriteria(crit2);
459:
460: QueryByCriteria query = new QueryByCriteria(B.class, crit1);
461: query.addPathClass("cSet", C1.class);
462:
463: Collection allBs = broker.getCollectionByQuery(query);
464:
465: java.util.Iterator itr = allBs.iterator();
466:
467: assertEquals(1 * NUM_A, allBs.size());
468: System.out
469: .println("testPathClassPerQuery() iteration size:"
470: + allBs.size());
471: while (itr.hasNext()) {
472: B b = (B) itr.next();
473: System.out.println("Found B: " + b.getId() + " "
474: + b.getBAttrib());
475: }
476: } catch (Throwable t) {
477: t.printStackTrace(System.out);
478: fail("testPathClassPerQuery: " + t.getMessage());
479: }
480: }
481:
482: /*
483: * Find all As having a B with both a particular C-D combination and
484: * another particular C-D combination
485: */
486: public void testThreeSegmentsAliasOnSegment2And3() throws Exception {
487: try {
488: // d1 criteria
489: Criteria crit1 = new Criteria();
490: crit1.addEqualTo("bSet.cSet.d.dAttrib",
491: new Integer("10010"));
492: crit1.setAlias("bToCToD1", "cSet.d");
493:
494: // d2 criteria
495: Criteria crit2 = new Criteria();
496: crit2.addEqualTo("bSet.cSet.d.dAttrib",
497: new Integer("10110"));
498: crit2.setAlias("bToCToD2", "cSet.d");
499:
500: crit1.addAndCriteria(crit2);
501:
502: boolean isDistinct = true;
503: Query query = new QueryByCriteria(A.class, crit1,
504: isDistinct);
505:
506: Collection allAs = broker.getCollectionByQuery(query);
507:
508: java.util.Iterator itr = allAs.iterator();
509:
510: assertEquals(1 * NUM_A, allAs.size());
511: System.out
512: .println("testThreeSegmentsAliasOnSegment2And3() iteration size:"
513: + allAs.size());
514: while (itr.hasNext()) {
515: A a = (A) itr.next();
516: System.out.println("Found A: " + a.getId() + " "
517: + a.getAAttrib());
518: }
519: } catch (Throwable t) {
520: t.printStackTrace(System.out);
521: fail("testThreeSegmentsAliasOnSegment2And3: "
522: + t.getMessage());
523: }
524: }
525:
526: /*
527: * Same as above using an explicit UserAlias
528: */
529: public void testThreeSegmentsAliasOnSegment2And3UserAlias()
530: throws Exception {
531: try {
532: UserAlias userAlias1 = new UserAlias("alias1");
533: userAlias1.add("bSet.cSet");
534: userAlias1.add("bSet.cSet.d");
535:
536: // d1 criteria
537: Criteria crit1 = new Criteria();
538: crit1.addEqualTo("bSet.cSet.d.dAttrib",
539: new Integer("10010"));
540: crit1.setAlias(userAlias1);
541:
542: // d2 criteria
543: UserAlias userAlias2 = new UserAlias("alias2");
544: userAlias2.add("bSet.cSet");
545: userAlias2.add("bSet.cSet.d");
546:
547: Criteria crit2 = new Criteria();
548: crit2.addEqualTo("bSet.cSet.d.dAttrib",
549: new Integer("10110"));
550: crit2.setAlias(userAlias2);
551:
552: crit1.addAndCriteria(crit2);
553:
554: boolean isDistinct = true;
555: Query query = new QueryByCriteria(A.class, crit1,
556: isDistinct);
557:
558: Collection allAs = broker.getCollectionByQuery(query);
559:
560: java.util.Iterator itr = allAs.iterator();
561:
562: assertEquals(1 * NUM_A, allAs.size());
563: System.out
564: .println("testThreeSegmentsAliasOnSegment2And3UserAlias() iteration size:"
565: + allAs.size());
566: while (itr.hasNext()) {
567: A a = (A) itr.next();
568: System.out.println("Found A: " + a.getId() + " "
569: + a.getAAttrib());
570: }
571: } catch (Throwable t) {
572: t.printStackTrace(System.out);
573: fail("testThreeSegmentsAliasOnSegment2And3UserAlias: "
574: + t.getMessage());
575: }
576: }
577:
578: public void testSubQueryExists() {
579: // subquery
580: Criteria subCrit = new Criteria();
581: subCrit.addEqualTo(Criteria.PARENT_QUERY_PREFIX
582: + "bSet.cSet.d.dAttrib", new Integer("10011"));
583: // subCrit.setAlias("subAlias", "cSet.d");
584: QueryByCriteria subQuery = new QueryByCriteria(A.class, subCrit);
585:
586: // parent query
587: Criteria crit = new Criteria();
588: crit.addEqualTo("bSet.cSet.d.dAttrib", new Integer("10010"));
589: // crit.setAlias("alias", "cSet.d");
590: crit.addNotExists(subQuery);
591: QueryByCriteria query = new QueryByCriteria(A.class, crit, true);
592:
593: Collection result = broker.getCollectionByQuery(query);
594: assertEquals(1 * NUM_A, result.size());
595:
596: Iterator itr = result.iterator();
597: while (itr.hasNext()) {
598: A a = (A) itr.next();
599: System.out.println("Found A: " + a.getId() + " "
600: + a.getAAttrib());
601: }
602: }
603:
604: // Inner Classes
605:
606: public static class A {
607: private long id;
608: private int aAttrib;
609: private Collection bSet;
610:
611: public A() {
612: }
613:
614: public A(int aAttrib) {
615: this .aAttrib = aAttrib;
616: this .bSet = new ArrayList();
617: }
618:
619: // make javabeans conform
620: public int getaAttrib() {
621: return aAttrib;
622: }
623:
624: // make javabeans conform
625: public Collection getbSet() {
626: return bSet;
627: }
628:
629: // make javabeans conform
630: public void setbSet(Collection bSet) {
631: this .bSet = bSet;
632: }
633:
634: // make javabeans conform
635: public void setaAttrib(int aAttrib) {
636: this .aAttrib = aAttrib;
637: }
638:
639: /**
640: * @return
641: */
642: public int getAAttrib() {
643: return aAttrib;
644: }
645:
646: /**
647: * @return
648: */
649: public Collection getBSet() {
650: return bSet;
651: }
652:
653: /**
654: * @return
655: */
656: public long getId() {
657: return id;
658: }
659:
660: /**
661: * @param i
662: */
663: public void setAAttrib(int i) {
664: aAttrib = i;
665: }
666:
667: /**
668: * @param collection
669: */
670: public void setBSet(Collection collection) {
671: bSet = collection;
672: }
673:
674: /**
675: * @param l
676: */
677: public void setId(long l) {
678: id = l;
679: }
680:
681: }
682:
683: public static class B {
684: private long id;
685: private long aId;
686: private int bAttrib;
687: private A a;
688: private Collection cSet;
689:
690: public B() {
691: }
692:
693: public B(int bAttrib) {
694: this .bAttrib = bAttrib;
695: this .cSet = new ArrayList();
696: }
697:
698: /**
699: * @return
700: */
701: public int getBAttrib() {
702: return bAttrib;
703: }
704:
705: /**
706: * @return
707: */
708: public Collection getCSet() {
709: return cSet;
710: }
711:
712: /**
713: * @return
714: */
715: public long getId() {
716: return id;
717: }
718:
719: /**
720: * @param i
721: */
722: public void setBAttrib(int i) {
723: bAttrib = i;
724: }
725:
726: /**
727: * @param collection
728: */
729: public void setCSet(Collection collection) {
730: cSet = collection;
731: }
732:
733: /**
734: * @param l
735: */
736: public void setId(long l) {
737: id = l;
738: }
739:
740: /**
741: * @return
742: */
743: public A getA() {
744: return a;
745: }
746:
747: /**
748: * @param a
749: */
750: public void setA(A a) {
751: this .a = a;
752: a.getBSet().add(this );
753: }
754:
755: }
756:
757: public static class C {
758: private long id;
759: private long bId;
760: private B b;
761: private long dId;
762: private D d;
763: private int cAttrib;
764:
765: public C() {
766: }
767:
768: public C(int cAttrib) {
769: this .cAttrib = cAttrib;
770: }
771:
772: /**
773: * @return
774: */
775: public int getCAttrib() {
776: return cAttrib;
777: }
778:
779: /**
780: * @return
781: */
782: public D getD() {
783: return d;
784: }
785:
786: /**
787: * @return
788: */
789: public long getId() {
790: return id;
791: }
792:
793: /**
794: * @param i
795: */
796: public void setCAttrib(int i) {
797: cAttrib = i;
798: }
799:
800: /**
801: * @param collection
802: */
803: public void setD(D d) {
804: this .d = d;
805: }
806:
807: /**
808: * @param l
809: */
810: public void setId(long l) {
811: id = l;
812: }
813:
814: /**
815: * @return
816: */
817: public B getB() {
818: return b;
819: }
820:
821: /**
822: * @param b
823: */
824: public void setB(B b) {
825: this .b = b;
826: b.getCSet().add(this );
827: }
828:
829: }
830:
831: public static class C1 extends C {
832:
833: private int c1Attrib;
834:
835: /**
836: * @param cAttrib
837: */
838:
839: public C1() {
840: }
841:
842: public C1(int cAttrib) {
843: super (cAttrib);
844: }
845:
846: /**
847: * @return
848: */
849: public int getC1Attrib() {
850: return c1Attrib;
851: }
852:
853: /**
854: * @param i
855: */
856: public void setC1Attrib(int i) {
857: c1Attrib = i;
858: }
859:
860: }
861:
862: public static class D {
863: private long id;
864: private int dAttrib;
865:
866: public D() {
867: }
868:
869: public D(int dAttrib) {
870: this .dAttrib = dAttrib;
871: }
872:
873: /**
874: * @return
875: */
876: public int getDAttrib() {
877: return dAttrib;
878: }
879:
880: /**
881: * @return
882: */
883: public long getId() {
884: return id;
885: }
886:
887: /**
888: * @param i
889: */
890: public void setDAttrib(int i) {
891: dAttrib = i;
892: }
893:
894: /**
895: * @param l
896: */
897: public void setId(long l) {
898: id = l;
899: }
900:
901: }
902:
903: }
|