Added: incubator/jdo/trunk/tck11/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBoolean.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck11/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBoolean.java?view=auto&rev=158179 ============================================================================== --- incubator/jdo/trunk/tck11/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBoolean.java (added) +++ incubator/jdo/trunk/tck11/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBoolean.java Fri Mar 18 17:07:39 2005 @@ -0,0 +1,1085 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.tck.pc.fieldtypes; + +import java.io.Serializable; + +public class FieldsOfBoolean { + public int identifier; + private Boolean Boolean0; + private Boolean Boolean1; + private Boolean Boolean2; + private Boolean Boolean3; + private Boolean Boolean4; + private Boolean Boolean5; + private Boolean Boolean6; + private Boolean Boolean7; + private static Boolean Boolean8; + private transient Boolean Boolean9; + private transient Boolean Boolean10; + private transient Boolean Boolean11; + private transient Boolean Boolean12; + private transient Boolean Boolean13; + private transient Boolean Boolean14; + private final Boolean Boolean15 = new Boolean(false); + private volatile Boolean Boolean16; + private volatile Boolean Boolean17; + private volatile Boolean Boolean18; + private volatile Boolean Boolean19; + private volatile Boolean Boolean20; + private volatile Boolean Boolean21; + private volatile Boolean Boolean22; + private volatile Boolean Boolean23; + private static transient Boolean Boolean24; + private static final Boolean Boolean25 = new Boolean(false); + private static volatile Boolean Boolean26; + private transient final Boolean Boolean27 = new Boolean(false); + private transient volatile Boolean Boolean28; + private transient volatile Boolean Boolean29; + private transient volatile Boolean Boolean30; + private transient volatile Boolean Boolean31; + private transient volatile Boolean Boolean32; + private transient volatile Boolean Boolean33; + private static transient final Boolean Boolean34 = new Boolean(false); + private static transient volatile Boolean Boolean35; + public Boolean Boolean36; + public Boolean Boolean37; + public Boolean Boolean38; + public Boolean Boolean39; + public Boolean Boolean40; + public Boolean Boolean41; + public Boolean Boolean42; + public Boolean Boolean43; + public static Boolean Boolean44; + public transient Boolean Boolean45; + public transient Boolean Boolean46; + public transient Boolean Boolean47; + public transient Boolean Boolean48; + public transient Boolean Boolean49; + public transient Boolean Boolean50; + public final Boolean Boolean51 = new Boolean(false); + public volatile Boolean Boolean52; + public volatile Boolean Boolean53; + public volatile Boolean Boolean54; + public volatile Boolean Boolean55; + public volatile Boolean Boolean56; + public volatile Boolean Boolean57; + public volatile Boolean Boolean58; + public volatile Boolean Boolean59; + public static transient Boolean Boolean60; + public static final Boolean Boolean61 = new Boolean(false); + public static volatile Boolean Boolean62; + public transient final Boolean Boolean63 = new Boolean(false); + public transient volatile Boolean Boolean64; + public transient volatile Boolean Boolean65; + public transient volatile Boolean Boolean66; + public transient volatile Boolean Boolean67; + public transient volatile Boolean Boolean68; + public transient volatile Boolean Boolean69; + public static transient final Boolean Boolean70 = new Boolean(false); + public static transient volatile Boolean Boolean71; + protected Boolean Boolean72; + protected Boolean Boolean73; + protected Boolean Boolean74; + protected Boolean Boolean75; + protected Boolean Boolean76; + protected Boolean Boolean77; + protected Boolean Boolean78; + protected Boolean Boolean79; + protected static Boolean Boolean80; + protected transient Boolean Boolean81; + protected transient Boolean Boolean82; + protected transient Boolean Boolean83; + protected transient Boolean Boolean84; + protected transient Boolean Boolean85; + protected transient Boolean Boolean86; + protected final Boolean Boolean87 = new Boolean(false); + protected volatile Boolean Boolean88; + protected volatile Boolean Boolean89; + protected volatile Boolean Boolean90; + protected volatile Boolean Boolean91; + protected volatile Boolean Boolean92; + protected volatile Boolean Boolean93; + protected volatile Boolean Boolean94; + protected volatile Boolean Boolean95; + protected static transient Boolean Boolean96; + protected static final Boolean Boolean97 = new Boolean(false); + protected static volatile Boolean Boolean98; + protected transient final Boolean Boolean99 = new Boolean(false); + protected transient volatile Boolean Boolean100; + protected transient volatile Boolean Boolean101; + protected transient volatile Boolean Boolean102; + protected transient volatile Boolean Boolean103; + protected transient volatile Boolean Boolean104; + protected transient volatile Boolean Boolean105; + protected static transient final Boolean Boolean106 = new Boolean(false); + protected static transient volatile Boolean Boolean107; + Boolean Boolean108; + Boolean Boolean109; + Boolean Boolean110; + Boolean Boolean111; + Boolean Boolean112; + Boolean Boolean113; + Boolean Boolean114; + Boolean Boolean115; + static Boolean Boolean116; + transient Boolean Boolean117; + transient Boolean Boolean118; + transient Boolean Boolean119; + transient Boolean Boolean120; + transient Boolean Boolean121; + transient Boolean Boolean122; + final Boolean Boolean123 = new Boolean(false); + volatile Boolean Boolean124; + volatile Boolean Boolean125; + volatile Boolean Boolean126; + volatile Boolean Boolean127; + volatile Boolean Boolean128; + volatile Boolean Boolean129; + volatile Boolean Boolean130; + volatile Boolean Boolean131; + static transient Boolean Boolean132; + static final Boolean Boolean133 = new Boolean(false); + static volatile Boolean Boolean134; + transient final Boolean Boolean135 = new Boolean(false); + transient volatile Boolean Boolean136; + transient volatile Boolean Boolean137; + transient volatile Boolean Boolean138; + transient volatile Boolean Boolean139; + transient volatile Boolean Boolean140; + transient volatile Boolean Boolean141; + static transient final Boolean Boolean142 = new Boolean(false); + static transient volatile Boolean Boolean143; + +public static final boolean [] isPersistent = { +true,true,true,false,true,true,true,false,false,false, +false,true,true,true,false,false,true,true,true,false, +true,true,true,false,false,false,false,false,false,false, +true,true,true,false,false,false,true,true,true,false, +true,true,true,false,false,false,false,true,true,true, +false,false,true,true,true,false,true,true,true,false, +false,false,false,false,false,false,true,true,true,false, +false,false,true,true,true,false,true,true,true,false, +false,false,false,true,true,true,false,false,true,true, +true,false,true,true,true,false,false,false,false,false, +false,false,true,true,true,false,false,false,true,true, +true,false,true,true,true,false,false,false,false,true, +true,true,false,false,true,true,true,false,true,true, +true,false,false,false,false,false,false,false,true,true, +true,false,false,false + }; + +public static final boolean [] isStatic = { +false,false,false,false,false,false,false,false,true,false, +false,false,false,false,false,false,false,false,false,false, +false,false,false,false,true,true,true,false,false,false, +false,false,false,false,true,true,false,false,false,false, +false,false,false,false,true,false,false,false,false,false, +false,false,false,false,false,false,false,false,false,false, +true,true,true,false,false,false,false,false,false,false, +true,true,false,false,false,false,false,false,false,false, +true,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,false,true,true,true,false, +false,false,false,false,false,false,true,true,false,false, +false,false,false,false,false,false,true,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,false,true,true,true,false,false,false,false,false, +false,false,true,true + }; + +public static final boolean [] isFinal = { +false,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,true,false,false,false,false, +false,false,false,false,false,true,false,true,false,false, +false,false,false,false,true,false,false,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,true,false,false,false,false,false,false,false,false, +false,true,false,true,false,false,false,false,false,false, +true,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,false,false,true,false,false, +false,false,false,false,false,false,false,true,false,true, +false,false,false,false,false,false,true,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,false,false,true,false,false,false,false,false,false, +false,false,false,true,false,true,false,false,false,false, +false,false,true,false + }; + + public static final String [] fieldSpecs = { + "private Boolean Boolean0", + "embedded= true private Boolean Boolean1", + "embedded= false private Boolean Boolean2", + "persistence-modifier= none private Boolean Boolean3", + "persistence-modifier= persistent private Boolean Boolean4", + "persistence-modifier= persistent embedded= true private Boolean Boolean5", + "persistence-modifier= persistent embedded= false private Boolean Boolean6", + "persistence-modifier= transactional private Boolean Boolean7", + "private static Boolean Boolean8", + "private transient Boolean Boolean9", + "persistence-modifier= none private transient Boolean Boolean10", + "persistence-modifier= persistent private transient Boolean Boolean11", + "persistence-modifier= persistent embedded= true private transient Boolean Boolean12", + "persistence-modifier= persistent embedded= false private transient Boolean Boolean13", + "persistence-modifier= transactional private transient Boolean Boolean14", + "private final Boolean Boolean15", + "private volatile Boolean Boolean16", + "embedded= true private volatile Boolean Boolean17", + "embedded= false private volatile Boolean Boolean18", + "persistence-modifier= none private volatile Boolean Boolean19", + "persistence-modifier= persistent private volatile Boolean Boolean20", + "persistence-modifier= persistent embedded= true private volatile Boolean Boolean21", + "persistence-modifier= persistent embedded= false private volatile Boolean Boolean22", + "persistence-modifier= transactional private volatile Boolean Boolean23", + "private static transient Boolean Boolean24", + "private static final Boolean Boolean25", + "private static volatile Boolean Boolean26", + "private transient final Boolean Boolean27", + "private transient volatile Boolean Boolean28", + "persistence-modifier= none private transient volatile Boolean Boolean29", + "persistence-modifier= persistent private transient volatile Boolean Boolean30", + "persistence-modifier= persistent embedded= true private transient volatile Boolean Boolean31", + "persistence-modifier= persistent embedded= false private transient volatile Boolean Boolean32", + "persistence-modifier= transactional private transient volatile Boolean Boolean33", + "private static transient final Boolean Boolean34", + "private static transient volatile Boolean Boolean35", + "public Boolean Boolean36", + "embedded= true public Boolean Boolean37", + "embedded= false public Boolean Boolean38", + "persistence-modifier= none public Boolean Boolean39", + "persistence-modifier= persistent public Boolean Boolean40", + "persistence-modifier= persistent embedded= true public Boolean Boolean41", + "persistence-modifier= persistent embedded= false public Boolean Boolean42", + "persistence-modifier= transactional public Boolean Boolean43", + "public static Boolean Boolean44", + "public transient Boolean Boolean45", + "persistence-modifier= none public transient Boolean Boolean46", + "persistence-modifier= persistent public transient Boolean Boolean47", + "persistence-modifier= persistent embedded= true public transient Boolean Boolean48", + "persistence-modifier= persistent embedded= false public transient Boolean Boolean49", + "persistence-modifier= transactional public transient Boolean Boolean50", + "public final Boolean Boolean51", + "public volatile Boolean Boolean52", + "embedded= true public volatile Boolean Boolean53", + "embedded= false public volatile Boolean Boolean54", + "persistence-modifier= none public volatile Boolean Boolean55", + "persistence-modifier= persistent public volatile Boolean Boolean56", + "persistence-modifier= persistent embedded= true public volatile Boolean Boolean57", + "persistence-modifier= persistent embedded= false public volatile Boolean Boolean58", + "persistence-modifier= transactional public volatile Boolean Boolean59", + "public static transient Boolean Boolean60", + "public static final Boolean Boolean61", + "public static volatile Boolean Boolean62", + "public transient final Boolean Boolean63", + "public transient volatile Boolean Boolean64", + "persistence-modifier= none public transient volatile Boolean Boolean65", + "persistence-modifier= persistent public transient volatile Boolean Boolean66", + "persistence-modifier= persistent embedded= true public transient volatile Boolean Boolean67", + "persistence-modifier= persistent embedded= false public transient volatile Boolean Boolean68", + "persistence-modifier= transactional public transient volatile Boolean Boolean69", + "public static transient final Boolean Boolean70", + "public static transient volatile Boolean Boolean71", + "protected Boolean Boolean72", + "embedded= true protected Boolean Boolean73", + "embedded= false protected Boolean Boolean74", + "persistence-modifier= none protected Boolean Boolean75", + "persistence-modifier= persistent protected Boolean Boolean76", + "persistence-modifier= persistent embedded= true protected Boolean Boolean77", + "persistence-modifier= persistent embedded= false protected Boolean Boolean78", + "persistence-modifier= transactional protected Boolean Boolean79", + "protected static Boolean Boolean80", + "protected transient Boolean Boolean81", + "persistence-modifier= none protected transient Boolean Boolean82", + "persistence-modifier= persistent protected transient Boolean Boolean83", + "persistence-modifier= persistent embedded= true protected transient Boolean Boolean84", + "persistence-modifier= persistent embedded= false protected transient Boolean Boolean85", + "persistence-modifier= transactional protected transient Boolean Boolean86", + "protected final Boolean Boolean87", + "protected volatile Boolean Boolean88", + "embedded= true protected volatile Boolean Boolean89", + "embedded= false protected volatile Boolean Boolean90", + "persistence-modifier= none protected volatile Boolean Boolean91", + "persistence-modifier= persistent protected volatile Boolean Boolean92", + "persistence-modifier= persistent embedded= true protected volatile Boolean Boolean93", + "persistence-modifier= persistent embedded= false protected volatile Boolean Boolean94", + "persistence-modifier= transactional protected volatile Boolean Boolean95", + "protected static transient Boolean Boolean96", + "protected static final Boolean Boolean97", + "protected static volatile Boolean Boolean98", + "protected transient final Boolean Boolean99", + "protected transient volatile Boolean Boolean100", + "persistence-modifier= none protected transient volatile Boolean Boolean101", + "persistence-modifier= persistent protected transient volatile Boolean Boolean102", + "persistence-modifier= persistent embedded= true protected transient volatile Boolean Boolean103", + "persistence-modifier= persistent embedded= false protected transient volatile Boolean Boolean104", + "persistence-modifier= transactional protected transient volatile Boolean Boolean105", + "protected static transient final Boolean Boolean106", + "protected static transient volatile Boolean Boolean107", + "Boolean Boolean108", + "embedded= true Boolean Boolean109", + "embedded= false Boolean Boolean110", + "persistence-modifier= none Boolean Boolean111", + "persistence-modifier= persistent Boolean Boolean112", + "persistence-modifier= persistent embedded= true Boolean Boolean113", + "persistence-modifier= persistent embedded= false Boolean Boolean114", + "persistence-modifier= transactional Boolean Boolean115", + "static Boolean Boolean116", + "transient Boolean Boolean117", + "persistence-modifier= none transient Boolean Boolean118", + "persistence-modifier= persistent transient Boolean Boolean119", + "persistence-modifier= persistent embedded= true transient Boolean Boolean120", + "persistence-modifier= persistent embedded= false transient Boolean Boolean121", + "persistence-modifier= transactional transient Boolean Boolean122", + "final Boolean Boolean123", + "volatile Boolean Boolean124", + "embedded= true volatile Boolean Boolean125", + "embedded= false volatile Boolean Boolean126", + "persistence-modifier= none volatile Boolean Boolean127", + "persistence-modifier= persistent volatile Boolean Boolean128", + "persistence-modifier= persistent embedded= true volatile Boolean Boolean129", + "persistence-modifier= persistent embedded= false volatile Boolean Boolean130", + "persistence-modifier= transactional volatile Boolean Boolean131", + "static transient Boolean Boolean132", + "static final Boolean Boolean133", + "static volatile Boolean Boolean134", + "transient final Boolean Boolean135", + "transient volatile Boolean Boolean136", + "persistence-modifier= none transient volatile Boolean Boolean137", + "persistence-modifier= persistent transient volatile Boolean Boolean138", + "persistence-modifier= persistent embedded= true transient volatile Boolean Boolean139", + "persistence-modifier= persistent embedded= false transient volatile Boolean Boolean140", + "persistence-modifier= transactional transient volatile Boolean Boolean141", + "static transient final Boolean Boolean142", + "static transient volatile Boolean Boolean143" + }; + public int getLength() + { + return fieldSpecs.length; + } + public Boolean get(int index) + { + switch (index) + { + case(0): + return Boolean0; + case(1): + return Boolean1; + case(2): + return Boolean2; + case(3): + return Boolean3; + case(4): + return Boolean4; + case(5): + return Boolean5; + case(6): + return Boolean6; + case(7): + return Boolean7; + case(8): + return Boolean8; + case(9): + return Boolean9; + case(10): + return Boolean10; + case(11): + return Boolean11; + case(12): + return Boolean12; + case(13): + return Boolean13; + case(14): + return Boolean14; + case(15): + return Boolean15; + case(16): + return Boolean16; + case(17): + return Boolean17; + case(18): + return Boolean18; + case(19): + return Boolean19; + case(20): + return Boolean20; + case(21): + return Boolean21; + case(22): + return Boolean22; + case(23): + return Boolean23; + case(24): + return Boolean24; + case(25): + return Boolean25; + case(26): + return Boolean26; + case(27): + return Boolean27; + case(28): + return Boolean28; + case(29): + return Boolean29; + case(30): + return Boolean30; + case(31): + return Boolean31; + case(32): + return Boolean32; + case(33): + return Boolean33; + case(34): + return Boolean34; + case(35): + return Boolean35; + case(36): + return Boolean36; + case(37): + return Boolean37; + case(38): + return Boolean38; + case(39): + return Boolean39; + case(40): + return Boolean40; + case(41): + return Boolean41; + case(42): + return Boolean42; + case(43): + return Boolean43; + case(44): + return Boolean44; + case(45): + return Boolean45; + case(46): + return Boolean46; + case(47): + return Boolean47; + case(48): + return Boolean48; + case(49): + return Boolean49; + case(50): + return Boolean50; + case(51): + return Boolean51; + case(52): + return Boolean52; + case(53): + return Boolean53; + case(54): + return Boolean54; + case(55): + return Boolean55; + case(56): + return Boolean56; + case(57): + return Boolean57; + case(58): + return Boolean58; + case(59): + return Boolean59; + case(60): + return Boolean60; + case(61): + return Boolean61; + case(62): + return Boolean62; + case(63): + return Boolean63; + case(64): + return Boolean64; + case(65): + return Boolean65; + case(66): + return Boolean66; + case(67): + return Boolean67; + case(68): + return Boolean68; + case(69): + return Boolean69; + case(70): + return Boolean70; + case(71): + return Boolean71; + case(72): + return Boolean72; + case(73): + return Boolean73; + case(74): + return Boolean74; + case(75): + return Boolean75; + case(76): + return Boolean76; + case(77): + return Boolean77; + case(78): + return Boolean78; + case(79): + return Boolean79; + case(80): + return Boolean80; + case(81): + return Boolean81; + case(82): + return Boolean82; + case(83): + return Boolean83; + case(84): + return Boolean84; + case(85): + return Boolean85; + case(86): + return Boolean86; + case(87): + return Boolean87; + case(88): + return Boolean88; + case(89): + return Boolean89; + case(90): + return Boolean90; + case(91): + return Boolean91; + case(92): + return Boolean92; + case(93): + return Boolean93; + case(94): + return Boolean94; + case(95): + return Boolean95; + case(96): + return Boolean96; + case(97): + return Boolean97; + case(98): + return Boolean98; + case(99): + return Boolean99; + case(100): + return Boolean100; + case(101): + return Boolean101; + case(102): + return Boolean102; + case(103): + return Boolean103; + case(104): + return Boolean104; + case(105): + return Boolean105; + case(106): + return Boolean106; + case(107): + return Boolean107; + case(108): + return Boolean108; + case(109): + return Boolean109; + case(110): + return Boolean110; + case(111): + return Boolean111; + case(112): + return Boolean112; + case(113): + return Boolean113; + case(114): + return Boolean114; + case(115): + return Boolean115; + case(116): + return Boolean116; + case(117): + return Boolean117; + case(118): + return Boolean118; + case(119): + return Boolean119; + case(120): + return Boolean120; + case(121): + return Boolean121; + case(122): + return Boolean122; + case(123): + return Boolean123; + case(124): + return Boolean124; + case(125): + return Boolean125; + case(126): + return Boolean126; + case(127): + return Boolean127; + case(128): + return Boolean128; + case(129): + return Boolean129; + case(130): + return Boolean130; + case(131): + return Boolean131; + case(132): + return Boolean132; + case(133): + return Boolean133; + case(134): + return Boolean134; + case(135): + return Boolean135; + case(136): + return Boolean136; + case(137): + return Boolean137; + case(138): + return Boolean138; + case(139): + return Boolean139; + case(140): + return Boolean140; + case(141): + return Boolean141; + case(142): + return Boolean142; + case(143): + return Boolean143; + default: + throw new IndexOutOfBoundsException(); + } + } + public boolean set(int index,Boolean value) + { + if(fieldSpecs[index].indexOf("final") != -1) + return false; + switch (index) + { + case(0): + Boolean0= value; + break; + case(1): + Boolean1= value; + break; + case(2): + Boolean2= value; + break; + case(3): + Boolean3= value; + break; + case(4): + Boolean4= value; + break; + case(5): + Boolean5= value; + break; + case(6): + Boolean6= value; + break; + case(7): + Boolean7= value; + break; + case(8): + Boolean8= value; + break; + case(9): + Boolean9= value; + break; + case(10): + Boolean10= value; + break; + case(11): + Boolean11= value; + break; + case(12): + Boolean12= value; + break; + case(13): + Boolean13= value; + break; + case(14): + Boolean14= value; + break; + case(16): + Boolean16= value; + break; + case(17): + Boolean17= value; + break; + case(18): + Boolean18= value; + break; + case(19): + Boolean19= value; + break; + case(20): + Boolean20= value; + break; + case(21): + Boolean21= value; + break; + case(22): + Boolean22= value; + break; + case(23): + Boolean23= value; + break; + case(24): + Boolean24= value; + break; + case(26): + Boolean26= value; + break; + case(28): + Boolean28= value; + break; + case(29): + Boolean29= value; + break; + case(30): + Boolean30= value; + break; + case(31): + Boolean31= value; + break; + case(32): + Boolean32= value; + break; + case(33): + Boolean33= value; + break; + case(35): + Boolean35= value; + break; + case(36): + Boolean36= value; + break; + case(37): + Boolean37= value; + break; + case(38): + Boolean38= value; + break; + case(39): + Boolean39= value; + break; + case(40): + Boolean40= value; + break; + case(41): + Boolean41= value; + break; + case(42): + Boolean42= value; + break; + case(43): + Boolean43= value; + break; + case(44): + Boolean44= value; + break; + case(45): + Boolean45= value; + break; + case(46): + Boolean46= value; + break; + case(47): + Boolean47= value; + break; + case(48): + Boolean48= value; + break; + case(49): + Boolean49= value; + break; + case(50): + Boolean50= value; + break; + case(52): + Boolean52= value; + break; + case(53): + Boolean53= value; + break; + case(54): + Boolean54= value; + break; + case(55): + Boolean55= value; + break; + case(56): + Boolean56= value; + break; + case(57): + Boolean57= value; + break; + case(58): + Boolean58= value; + break; + case(59): + Boolean59= value; + break; + case(60): + Boolean60= value; + break; + case(62): + Boolean62= value; + break; + case(64): + Boolean64= value; + break; + case(65): + Boolean65= value; + break; + case(66): + Boolean66= value; + break; + case(67): + Boolean67= value; + break; + case(68): + Boolean68= value; + break; + case(69): + Boolean69= value; + break; + case(71): + Boolean71= value; + break; + case(72): + Boolean72= value; + break; + case(73): + Boolean73= value; + break; + case(74): + Boolean74= value; + break; + case(75): + Boolean75= value; + break; + case(76): + Boolean76= value; + break; + case(77): + Boolean77= value; + break; + case(78): + Boolean78= value; + break; + case(79): + Boolean79= value; + break; + case(80): + Boolean80= value; + break; + case(81): + Boolean81= value; + break; + case(82): + Boolean82= value; + break; + case(83): + Boolean83= value; + break; + case(84): + Boolean84= value; + break; + case(85): + Boolean85= value; + break; + case(86): + Boolean86= value; + break; + case(88): + Boolean88= value; + break; + case(89): + Boolean89= value; + break; + case(90): + Boolean90= value; + break; + case(91): + Boolean91= value; + break; + case(92): + Boolean92= value; + break; + case(93): + Boolean93= value; + break; + case(94): + Boolean94= value; + break; + case(95): + Boolean95= value; + break; + case(96): + Boolean96= value; + break; + case(98): + Boolean98= value; + break; + case(100): + Boolean100= value; + break; + case(101): + Boolean101= value; + break; + case(102): + Boolean102= value; + break; + case(103): + Boolean103= value; + break; + case(104): + Boolean104= value; + break; + case(105): + Boolean105= value; + break; + case(107): + Boolean107= value; + break; + case(108): + Boolean108= value; + break; + case(109): + Boolean109= value; + break; + case(110): + Boolean110= value; + break; + case(111): + Boolean111= value; + break; + case(112): + Boolean112= value; + break; + case(113): + Boolean113= value; + break; + case(114): + Boolean114= value; + break; + case(115): + Boolean115= value; + break; + case(116): + Boolean116= value; + break; + case(117): + Boolean117= value; + break; + case(118): + Boolean118= value; + break; + case(119): + Boolean119= value; + break; + case(120): + Boolean120= value; + break; + case(121): + Boolean121= value; + break; + case(122): + Boolean122= value; + break; + case(124): + Boolean124= value; + break; + case(125): + Boolean125= value; + break; + case(126): + Boolean126= value; + break; + case(127): + Boolean127= value; + break; + case(128): + Boolean128= value; + break; + case(129): + Boolean129= value; + break; + case(130): + Boolean130= value; + break; + case(131): + Boolean131= value; + break; + case(132): + Boolean132= value; + break; + case(134): + Boolean134= value; + break; + case(136): + Boolean136= value; + break; + case(137): + Boolean137= value; + break; + case(138): + Boolean138= value; + break; + case(139): + Boolean139= value; + break; + case(140): + Boolean140= value; + break; + case(141): + Boolean141= value; + break; + case(143): + Boolean143= value; + break; + default: + throw new IndexOutOfBoundsException(); + } + return true; + } + + public static class Oid implements Serializable { + public int identifier; + + public Oid() { + } + + public Oid(String s) { identifier = Integer.parseInt(s); } + + public String toString() { return this.getClass().getName() + ": " + identifier;} + + public int hashCode() { return (int)identifier ; } + + public boolean equals(Object other) { + if (other != null && (other instanceof Oid)) { + Oid k = (Oid)other; + return k.identifier == this.identifier; + } + return false; + } + + } +}
Added: incubator/jdo/trunk/tck11/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfByte.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck11/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfByte.java?view=auto&rev=158179 ============================================================================== --- incubator/jdo/trunk/tck11/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfByte.java (added) +++ incubator/jdo/trunk/tck11/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfByte.java Fri Mar 18 17:07:39 2005 @@ -0,0 +1,1085 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.tck.pc.fieldtypes; + +import java.io.Serializable; + +public class FieldsOfByte { + public int identifier; + private Byte Byte0; + private Byte Byte1; + private Byte Byte2; + private Byte Byte3; + private Byte Byte4; + private Byte Byte5; + private Byte Byte6; + private Byte Byte7; + private static Byte Byte8; + private transient Byte Byte9; + private transient Byte Byte10; + private transient Byte Byte11; + private transient Byte Byte12; + private transient Byte Byte13; + private transient Byte Byte14; + private final Byte Byte15 = new Byte((byte)5); + private volatile Byte Byte16; + private volatile Byte Byte17; + private volatile Byte Byte18; + private volatile Byte Byte19; + private volatile Byte Byte20; + private volatile Byte Byte21; + private volatile Byte Byte22; + private volatile Byte Byte23; + private static transient Byte Byte24; + private static final Byte Byte25 = new Byte((byte)5); + private static volatile Byte Byte26; + private transient final Byte Byte27 = new Byte((byte)5); + private transient volatile Byte Byte28; + private transient volatile Byte Byte29; + private transient volatile Byte Byte30; + private transient volatile Byte Byte31; + private transient volatile Byte Byte32; + private transient volatile Byte Byte33; + private static transient final Byte Byte34 = new Byte((byte)5); + private static transient volatile Byte Byte35; + public Byte Byte36; + public Byte Byte37; + public Byte Byte38; + public Byte Byte39; + public Byte Byte40; + public Byte Byte41; + public Byte Byte42; + public Byte Byte43; + public static Byte Byte44; + public transient Byte Byte45; + public transient Byte Byte46; + public transient Byte Byte47; + public transient Byte Byte48; + public transient Byte Byte49; + public transient Byte Byte50; + public final Byte Byte51 = new Byte((byte)5); + public volatile Byte Byte52; + public volatile Byte Byte53; + public volatile Byte Byte54; + public volatile Byte Byte55; + public volatile Byte Byte56; + public volatile Byte Byte57; + public volatile Byte Byte58; + public volatile Byte Byte59; + public static transient Byte Byte60; + public static final Byte Byte61 = new Byte((byte)5); + public static volatile Byte Byte62; + public transient final Byte Byte63 = new Byte((byte)5); + public transient volatile Byte Byte64; + public transient volatile Byte Byte65; + public transient volatile Byte Byte66; + public transient volatile Byte Byte67; + public transient volatile Byte Byte68; + public transient volatile Byte Byte69; + public static transient final Byte Byte70 = new Byte((byte)5); + public static transient volatile Byte Byte71; + protected Byte Byte72; + protected Byte Byte73; + protected Byte Byte74; + protected Byte Byte75; + protected Byte Byte76; + protected Byte Byte77; + protected Byte Byte78; + protected Byte Byte79; + protected static Byte Byte80; + protected transient Byte Byte81; + protected transient Byte Byte82; + protected transient Byte Byte83; + protected transient Byte Byte84; + protected transient Byte Byte85; + protected transient Byte Byte86; + protected final Byte Byte87 = new Byte((byte)5); + protected volatile Byte Byte88; + protected volatile Byte Byte89; + protected volatile Byte Byte90; + protected volatile Byte Byte91; + protected volatile Byte Byte92; + protected volatile Byte Byte93; + protected volatile Byte Byte94; + protected volatile Byte Byte95; + protected static transient Byte Byte96; + protected static final Byte Byte97 = new Byte((byte)5); + protected static volatile Byte Byte98; + protected transient final Byte Byte99 = new Byte((byte)5); + protected transient volatile Byte Byte100; + protected transient volatile Byte Byte101; + protected transient volatile Byte Byte102; + protected transient volatile Byte Byte103; + protected transient volatile Byte Byte104; + protected transient volatile Byte Byte105; + protected static transient final Byte Byte106 = new Byte((byte)5); + protected static transient volatile Byte Byte107; + Byte Byte108; + Byte Byte109; + Byte Byte110; + Byte Byte111; + Byte Byte112; + Byte Byte113; + Byte Byte114; + Byte Byte115; + static Byte Byte116; + transient Byte Byte117; + transient Byte Byte118; + transient Byte Byte119; + transient Byte Byte120; + transient Byte Byte121; + transient Byte Byte122; + final Byte Byte123 = new Byte((byte)5); + volatile Byte Byte124; + volatile Byte Byte125; + volatile Byte Byte126; + volatile Byte Byte127; + volatile Byte Byte128; + volatile Byte Byte129; + volatile Byte Byte130; + volatile Byte Byte131; + static transient Byte Byte132; + static final Byte Byte133 = new Byte((byte)5); + static volatile Byte Byte134; + transient final Byte Byte135 = new Byte((byte)5); + transient volatile Byte Byte136; + transient volatile Byte Byte137; + transient volatile Byte Byte138; + transient volatile Byte Byte139; + transient volatile Byte Byte140; + transient volatile Byte Byte141; + static transient final Byte Byte142 = new Byte((byte)5); + static transient volatile Byte Byte143; + +public static final boolean [] isPersistent = { +true,true,true,false,true,true,true,false,false,false, +false,true,true,true,false,false,true,true,true,false, +true,true,true,false,false,false,false,false,false,false, +true,true,true,false,false,false,true,true,true,false, +true,true,true,false,false,false,false,true,true,true, +false,false,true,true,true,false,true,true,true,false, +false,false,false,false,false,false,true,true,true,false, +false,false,true,true,true,false,true,true,true,false, +false,false,false,true,true,true,false,false,true,true, +true,false,true,true,true,false,false,false,false,false, +false,false,true,true,true,false,false,false,true,true, +true,false,true,true,true,false,false,false,false,true, +true,true,false,false,true,true,true,false,true,true, +true,false,false,false,false,false,false,false,true,true, +true,false,false,false + }; + +public static final boolean [] isStatic = { +false,false,false,false,false,false,false,false,true,false, +false,false,false,false,false,false,false,false,false,false, +false,false,false,false,true,true,true,false,false,false, +false,false,false,false,true,true,false,false,false,false, +false,false,false,false,true,false,false,false,false,false, +false,false,false,false,false,false,false,false,false,false, +true,true,true,false,false,false,false,false,false,false, +true,true,false,false,false,false,false,false,false,false, +true,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,false,true,true,true,false, +false,false,false,false,false,false,true,true,false,false, +false,false,false,false,false,false,true,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,false,true,true,true,false,false,false,false,false, +false,false,true,true + }; + +public static final boolean [] isFinal = { +false,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,true,false,false,false,false, +false,false,false,false,false,true,false,true,false,false, +false,false,false,false,true,false,false,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,true,false,false,false,false,false,false,false,false, +false,true,false,true,false,false,false,false,false,false, +true,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,false,false,true,false,false, +false,false,false,false,false,false,false,true,false,true, +false,false,false,false,false,false,true,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,false,false,true,false,false,false,false,false,false, +false,false,false,true,false,true,false,false,false,false, +false,false,true,false + }; + + public static final String [] fieldSpecs = { + "private Byte Byte0", + "embedded= true private Byte Byte1", + "embedded= false private Byte Byte2", + "persistence-modifier= none private Byte Byte3", + "persistence-modifier= persistent private Byte Byte4", + "persistence-modifier= persistent embedded= true private Byte Byte5", + "persistence-modifier= persistent embedded= false private Byte Byte6", + "persistence-modifier= transactional private Byte Byte7", + "private static Byte Byte8", + "private transient Byte Byte9", + "persistence-modifier= none private transient Byte Byte10", + "persistence-modifier= persistent private transient Byte Byte11", + "persistence-modifier= persistent embedded= true private transient Byte Byte12", + "persistence-modifier= persistent embedded= false private transient Byte Byte13", + "persistence-modifier= transactional private transient Byte Byte14", + "private final Byte Byte15", + "private volatile Byte Byte16", + "embedded= true private volatile Byte Byte17", + "embedded= false private volatile Byte Byte18", + "persistence-modifier= none private volatile Byte Byte19", + "persistence-modifier= persistent private volatile Byte Byte20", + "persistence-modifier= persistent embedded= true private volatile Byte Byte21", + "persistence-modifier= persistent embedded= false private volatile Byte Byte22", + "persistence-modifier= transactional private volatile Byte Byte23", + "private static transient Byte Byte24", + "private static final Byte Byte25", + "private static volatile Byte Byte26", + "private transient final Byte Byte27", + "private transient volatile Byte Byte28", + "persistence-modifier= none private transient volatile Byte Byte29", + "persistence-modifier= persistent private transient volatile Byte Byte30", + "persistence-modifier= persistent embedded= true private transient volatile Byte Byte31", + "persistence-modifier= persistent embedded= false private transient volatile Byte Byte32", + "persistence-modifier= transactional private transient volatile Byte Byte33", + "private static transient final Byte Byte34", + "private static transient volatile Byte Byte35", + "public Byte Byte36", + "embedded= true public Byte Byte37", + "embedded= false public Byte Byte38", + "persistence-modifier= none public Byte Byte39", + "persistence-modifier= persistent public Byte Byte40", + "persistence-modifier= persistent embedded= true public Byte Byte41", + "persistence-modifier= persistent embedded= false public Byte Byte42", + "persistence-modifier= transactional public Byte Byte43", + "public static Byte Byte44", + "public transient Byte Byte45", + "persistence-modifier= none public transient Byte Byte46", + "persistence-modifier= persistent public transient Byte Byte47", + "persistence-modifier= persistent embedded= true public transient Byte Byte48", + "persistence-modifier= persistent embedded= false public transient Byte Byte49", + "persistence-modifier= transactional public transient Byte Byte50", + "public final Byte Byte51", + "public volatile Byte Byte52", + "embedded= true public volatile Byte Byte53", + "embedded= false public volatile Byte Byte54", + "persistence-modifier= none public volatile Byte Byte55", + "persistence-modifier= persistent public volatile Byte Byte56", + "persistence-modifier= persistent embedded= true public volatile Byte Byte57", + "persistence-modifier= persistent embedded= false public volatile Byte Byte58", + "persistence-modifier= transactional public volatile Byte Byte59", + "public static transient Byte Byte60", + "public static final Byte Byte61", + "public static volatile Byte Byte62", + "public transient final Byte Byte63", + "public transient volatile Byte Byte64", + "persistence-modifier= none public transient volatile Byte Byte65", + "persistence-modifier= persistent public transient volatile Byte Byte66", + "persistence-modifier= persistent embedded= true public transient volatile Byte Byte67", + "persistence-modifier= persistent embedded= false public transient volatile Byte Byte68", + "persistence-modifier= transactional public transient volatile Byte Byte69", + "public static transient final Byte Byte70", + "public static transient volatile Byte Byte71", + "protected Byte Byte72", + "embedded= true protected Byte Byte73", + "embedded= false protected Byte Byte74", + "persistence-modifier= none protected Byte Byte75", + "persistence-modifier= persistent protected Byte Byte76", + "persistence-modifier= persistent embedded= true protected Byte Byte77", + "persistence-modifier= persistent embedded= false protected Byte Byte78", + "persistence-modifier= transactional protected Byte Byte79", + "protected static Byte Byte80", + "protected transient Byte Byte81", + "persistence-modifier= none protected transient Byte Byte82", + "persistence-modifier= persistent protected transient Byte Byte83", + "persistence-modifier= persistent embedded= true protected transient Byte Byte84", + "persistence-modifier= persistent embedded= false protected transient Byte Byte85", + "persistence-modifier= transactional protected transient Byte Byte86", + "protected final Byte Byte87", + "protected volatile Byte Byte88", + "embedded= true protected volatile Byte Byte89", + "embedded= false protected volatile Byte Byte90", + "persistence-modifier= none protected volatile Byte Byte91", + "persistence-modifier= persistent protected volatile Byte Byte92", + "persistence-modifier= persistent embedded= true protected volatile Byte Byte93", + "persistence-modifier= persistent embedded= false protected volatile Byte Byte94", + "persistence-modifier= transactional protected volatile Byte Byte95", + "protected static transient Byte Byte96", + "protected static final Byte Byte97", + "protected static volatile Byte Byte98", + "protected transient final Byte Byte99", + "protected transient volatile Byte Byte100", + "persistence-modifier= none protected transient volatile Byte Byte101", + "persistence-modifier= persistent protected transient volatile Byte Byte102", + "persistence-modifier= persistent embedded= true protected transient volatile Byte Byte103", + "persistence-modifier= persistent embedded= false protected transient volatile Byte Byte104", + "persistence-modifier= transactional protected transient volatile Byte Byte105", + "protected static transient final Byte Byte106", + "protected static transient volatile Byte Byte107", + "Byte Byte108", + "embedded= true Byte Byte109", + "embedded= false Byte Byte110", + "persistence-modifier= none Byte Byte111", + "persistence-modifier= persistent Byte Byte112", + "persistence-modifier= persistent embedded= true Byte Byte113", + "persistence-modifier= persistent embedded= false Byte Byte114", + "persistence-modifier= transactional Byte Byte115", + "static Byte Byte116", + "transient Byte Byte117", + "persistence-modifier= none transient Byte Byte118", + "persistence-modifier= persistent transient Byte Byte119", + "persistence-modifier= persistent embedded= true transient Byte Byte120", + "persistence-modifier= persistent embedded= false transient Byte Byte121", + "persistence-modifier= transactional transient Byte Byte122", + "final Byte Byte123", + "volatile Byte Byte124", + "embedded= true volatile Byte Byte125", + "embedded= false volatile Byte Byte126", + "persistence-modifier= none volatile Byte Byte127", + "persistence-modifier= persistent volatile Byte Byte128", + "persistence-modifier= persistent embedded= true volatile Byte Byte129", + "persistence-modifier= persistent embedded= false volatile Byte Byte130", + "persistence-modifier= transactional volatile Byte Byte131", + "static transient Byte Byte132", + "static final Byte Byte133", + "static volatile Byte Byte134", + "transient final Byte Byte135", + "transient volatile Byte Byte136", + "persistence-modifier= none transient volatile Byte Byte137", + "persistence-modifier= persistent transient volatile Byte Byte138", + "persistence-modifier= persistent embedded= true transient volatile Byte Byte139", + "persistence-modifier= persistent embedded= false transient volatile Byte Byte140", + "persistence-modifier= transactional transient volatile Byte Byte141", + "static transient final Byte Byte142", + "static transient volatile Byte Byte143" + }; + public int getLength() + { + return fieldSpecs.length; + } + public Byte get(int index) + { + switch (index) + { + case(0): + return Byte0; + case(1): + return Byte1; + case(2): + return Byte2; + case(3): + return Byte3; + case(4): + return Byte4; + case(5): + return Byte5; + case(6): + return Byte6; + case(7): + return Byte7; + case(8): + return Byte8; + case(9): + return Byte9; + case(10): + return Byte10; + case(11): + return Byte11; + case(12): + return Byte12; + case(13): + return Byte13; + case(14): + return Byte14; + case(15): + return Byte15; + case(16): + return Byte16; + case(17): + return Byte17; + case(18): + return Byte18; + case(19): + return Byte19; + case(20): + return Byte20; + case(21): + return Byte21; + case(22): + return Byte22; + case(23): + return Byte23; + case(24): + return Byte24; + case(25): + return Byte25; + case(26): + return Byte26; + case(27): + return Byte27; + case(28): + return Byte28; + case(29): + return Byte29; + case(30): + return Byte30; + case(31): + return Byte31; + case(32): + return Byte32; + case(33): + return Byte33; + case(34): + return Byte34; + case(35): + return Byte35; + case(36): + return Byte36; + case(37): + return Byte37; + case(38): + return Byte38; + case(39): + return Byte39; + case(40): + return Byte40; + case(41): + return Byte41; + case(42): + return Byte42; + case(43): + return Byte43; + case(44): + return Byte44; + case(45): + return Byte45; + case(46): + return Byte46; + case(47): + return Byte47; + case(48): + return Byte48; + case(49): + return Byte49; + case(50): + return Byte50; + case(51): + return Byte51; + case(52): + return Byte52; + case(53): + return Byte53; + case(54): + return Byte54; + case(55): + return Byte55; + case(56): + return Byte56; + case(57): + return Byte57; + case(58): + return Byte58; + case(59): + return Byte59; + case(60): + return Byte60; + case(61): + return Byte61; + case(62): + return Byte62; + case(63): + return Byte63; + case(64): + return Byte64; + case(65): + return Byte65; + case(66): + return Byte66; + case(67): + return Byte67; + case(68): + return Byte68; + case(69): + return Byte69; + case(70): + return Byte70; + case(71): + return Byte71; + case(72): + return Byte72; + case(73): + return Byte73; + case(74): + return Byte74; + case(75): + return Byte75; + case(76): + return Byte76; + case(77): + return Byte77; + case(78): + return Byte78; + case(79): + return Byte79; + case(80): + return Byte80; + case(81): + return Byte81; + case(82): + return Byte82; + case(83): + return Byte83; + case(84): + return Byte84; + case(85): + return Byte85; + case(86): + return Byte86; + case(87): + return Byte87; + case(88): + return Byte88; + case(89): + return Byte89; + case(90): + return Byte90; + case(91): + return Byte91; + case(92): + return Byte92; + case(93): + return Byte93; + case(94): + return Byte94; + case(95): + return Byte95; + case(96): + return Byte96; + case(97): + return Byte97; + case(98): + return Byte98; + case(99): + return Byte99; + case(100): + return Byte100; + case(101): + return Byte101; + case(102): + return Byte102; + case(103): + return Byte103; + case(104): + return Byte104; + case(105): + return Byte105; + case(106): + return Byte106; + case(107): + return Byte107; + case(108): + return Byte108; + case(109): + return Byte109; + case(110): + return Byte110; + case(111): + return Byte111; + case(112): + return Byte112; + case(113): + return Byte113; + case(114): + return Byte114; + case(115): + return Byte115; + case(116): + return Byte116; + case(117): + return Byte117; + case(118): + return Byte118; + case(119): + return Byte119; + case(120): + return Byte120; + case(121): + return Byte121; + case(122): + return Byte122; + case(123): + return Byte123; + case(124): + return Byte124; + case(125): + return Byte125; + case(126): + return Byte126; + case(127): + return Byte127; + case(128): + return Byte128; + case(129): + return Byte129; + case(130): + return Byte130; + case(131): + return Byte131; + case(132): + return Byte132; + case(133): + return Byte133; + case(134): + return Byte134; + case(135): + return Byte135; + case(136): + return Byte136; + case(137): + return Byte137; + case(138): + return Byte138; + case(139): + return Byte139; + case(140): + return Byte140; + case(141): + return Byte141; + case(142): + return Byte142; + case(143): + return Byte143; + default: + throw new IndexOutOfBoundsException(); + } + } + public boolean set(int index,Byte value) + { + if(fieldSpecs[index].indexOf("final") != -1) + return false; + switch (index) + { + case(0): + Byte0= value; + break; + case(1): + Byte1= value; + break; + case(2): + Byte2= value; + break; + case(3): + Byte3= value; + break; + case(4): + Byte4= value; + break; + case(5): + Byte5= value; + break; + case(6): + Byte6= value; + break; + case(7): + Byte7= value; + break; + case(8): + Byte8= value; + break; + case(9): + Byte9= value; + break; + case(10): + Byte10= value; + break; + case(11): + Byte11= value; + break; + case(12): + Byte12= value; + break; + case(13): + Byte13= value; + break; + case(14): + Byte14= value; + break; + case(16): + Byte16= value; + break; + case(17): + Byte17= value; + break; + case(18): + Byte18= value; + break; + case(19): + Byte19= value; + break; + case(20): + Byte20= value; + break; + case(21): + Byte21= value; + break; + case(22): + Byte22= value; + break; + case(23): + Byte23= value; + break; + case(24): + Byte24= value; + break; + case(26): + Byte26= value; + break; + case(28): + Byte28= value; + break; + case(29): + Byte29= value; + break; + case(30): + Byte30= value; + break; + case(31): + Byte31= value; + break; + case(32): + Byte32= value; + break; + case(33): + Byte33= value; + break; + case(35): + Byte35= value; + break; + case(36): + Byte36= value; + break; + case(37): + Byte37= value; + break; + case(38): + Byte38= value; + break; + case(39): + Byte39= value; + break; + case(40): + Byte40= value; + break; + case(41): + Byte41= value; + break; + case(42): + Byte42= value; + break; + case(43): + Byte43= value; + break; + case(44): + Byte44= value; + break; + case(45): + Byte45= value; + break; + case(46): + Byte46= value; + break; + case(47): + Byte47= value; + break; + case(48): + Byte48= value; + break; + case(49): + Byte49= value; + break; + case(50): + Byte50= value; + break; + case(52): + Byte52= value; + break; + case(53): + Byte53= value; + break; + case(54): + Byte54= value; + break; + case(55): + Byte55= value; + break; + case(56): + Byte56= value; + break; + case(57): + Byte57= value; + break; + case(58): + Byte58= value; + break; + case(59): + Byte59= value; + break; + case(60): + Byte60= value; + break; + case(62): + Byte62= value; + break; + case(64): + Byte64= value; + break; + case(65): + Byte65= value; + break; + case(66): + Byte66= value; + break; + case(67): + Byte67= value; + break; + case(68): + Byte68= value; + break; + case(69): + Byte69= value; + break; + case(71): + Byte71= value; + break; + case(72): + Byte72= value; + break; + case(73): + Byte73= value; + break; + case(74): + Byte74= value; + break; + case(75): + Byte75= value; + break; + case(76): + Byte76= value; + break; + case(77): + Byte77= value; + break; + case(78): + Byte78= value; + break; + case(79): + Byte79= value; + break; + case(80): + Byte80= value; + break; + case(81): + Byte81= value; + break; + case(82): + Byte82= value; + break; + case(83): + Byte83= value; + break; + case(84): + Byte84= value; + break; + case(85): + Byte85= value; + break; + case(86): + Byte86= value; + break; + case(88): + Byte88= value; + break; + case(89): + Byte89= value; + break; + case(90): + Byte90= value; + break; + case(91): + Byte91= value; + break; + case(92): + Byte92= value; + break; + case(93): + Byte93= value; + break; + case(94): + Byte94= value; + break; + case(95): + Byte95= value; + break; + case(96): + Byte96= value; + break; + case(98): + Byte98= value; + break; + case(100): + Byte100= value; + break; + case(101): + Byte101= value; + break; + case(102): + Byte102= value; + break; + case(103): + Byte103= value; + break; + case(104): + Byte104= value; + break; + case(105): + Byte105= value; + break; + case(107): + Byte107= value; + break; + case(108): + Byte108= value; + break; + case(109): + Byte109= value; + break; + case(110): + Byte110= value; + break; + case(111): + Byte111= value; + break; + case(112): + Byte112= value; + break; + case(113): + Byte113= value; + break; + case(114): + Byte114= value; + break; + case(115): + Byte115= value; + break; + case(116): + Byte116= value; + break; + case(117): + Byte117= value; + break; + case(118): + Byte118= value; + break; + case(119): + Byte119= value; + break; + case(120): + Byte120= value; + break; + case(121): + Byte121= value; + break; + case(122): + Byte122= value; + break; + case(124): + Byte124= value; + break; + case(125): + Byte125= value; + break; + case(126): + Byte126= value; + break; + case(127): + Byte127= value; + break; + case(128): + Byte128= value; + break; + case(129): + Byte129= value; + break; + case(130): + Byte130= value; + break; + case(131): + Byte131= value; + break; + case(132): + Byte132= value; + break; + case(134): + Byte134= value; + break; + case(136): + Byte136= value; + break; + case(137): + Byte137= value; + break; + case(138): + Byte138= value; + break; + case(139): + Byte139= value; + break; + case(140): + Byte140= value; + break; + case(141): + Byte141= value; + break; + case(143): + Byte143= value; + break; + default: + throw new IndexOutOfBoundsException(); + } + return true; + } + + public static class Oid implements Serializable { + public int identifier; + + public Oid() { + } + + public Oid(String s) { identifier = Integer.parseInt(s); } + + public String toString() { return this.getClass().getName() + ": " + identifier;} + + public int hashCode() { return (int)identifier ; } + + public boolean equals(Object other) { + if (other != null && (other instanceof Oid)) { + Oid k = (Oid)other; + return k.identifier == this.identifier; + } + return false; + } + + } +}
