001package org.hl7.fhir.convertors.conv10_30.resources10_30;
002
003import org.hl7.fhir.convertors.context.ConversionContext10_30;
004import org.hl7.fhir.convertors.conv10_30.datatypes10_30.Reference10_30;
005import org.hl7.fhir.convertors.conv10_30.datatypes10_30.complextypes10_30.CodeableConcept10_30;
006import org.hl7.fhir.convertors.conv10_30.datatypes10_30.complextypes10_30.Identifier10_30;
007import org.hl7.fhir.convertors.conv10_30.datatypes10_30.complextypes10_30.Timing10_30;
008import org.hl7.fhir.convertors.conv10_30.datatypes10_30.primitivetypes10_30.Instant10_30;
009import org.hl7.fhir.dstu2.model.DeviceMetric;
010import org.hl7.fhir.dstu2.model.Enumeration;
011import org.hl7.fhir.exceptions.FHIRException;
012
013public class DeviceMetric10_30 {
014
015  public static org.hl7.fhir.dstu2.model.DeviceMetric convertDeviceMetric(org.hl7.fhir.dstu3.model.DeviceMetric src) throws FHIRException {
016    if (src == null || src.isEmpty())
017      return null;
018    org.hl7.fhir.dstu2.model.DeviceMetric tgt = new org.hl7.fhir.dstu2.model.DeviceMetric();
019    ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyDomainResource(src, tgt);
020    if (src.hasType())
021      tgt.setType(CodeableConcept10_30.convertCodeableConcept(src.getType()));
022    if (src.hasIdentifier())
023      tgt.setIdentifier(Identifier10_30.convertIdentifier(src.getIdentifier()));
024    if (src.hasUnit())
025      tgt.setUnit(CodeableConcept10_30.convertCodeableConcept(src.getUnit()));
026    if (src.hasSource())
027      tgt.setSource(Reference10_30.convertReference(src.getSource()));
028    if (src.hasParent())
029      tgt.setParent(Reference10_30.convertReference(src.getParent()));
030    if (src.hasOperationalStatus())
031      tgt.setOperationalStatusElement(convertDeviceMetricOperationalStatus(src.getOperationalStatusElement()));
032    if (src.hasColor())
033      tgt.setColorElement(convertDeviceMetricColor(src.getColorElement()));
034    if (src.hasCategory())
035      tgt.setCategoryElement(convertDeviceMetricCategory(src.getCategoryElement()));
036    if (src.hasMeasurementPeriod())
037      tgt.setMeasurementPeriod(Timing10_30.convertTiming(src.getMeasurementPeriod()));
038    for (org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationComponent t : src.getCalibration())
039      tgt.addCalibration(convertDeviceMetricCalibrationComponent(t));
040    return tgt;
041  }
042
043  public static org.hl7.fhir.dstu3.model.DeviceMetric convertDeviceMetric(org.hl7.fhir.dstu2.model.DeviceMetric src) throws FHIRException {
044    if (src == null || src.isEmpty())
045      return null;
046    org.hl7.fhir.dstu3.model.DeviceMetric tgt = new org.hl7.fhir.dstu3.model.DeviceMetric();
047    ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyDomainResource(src, tgt);
048    if (src.hasType())
049      tgt.setType(CodeableConcept10_30.convertCodeableConcept(src.getType()));
050    if (src.hasIdentifier())
051      tgt.setIdentifier(Identifier10_30.convertIdentifier(src.getIdentifier()));
052    if (src.hasUnit())
053      tgt.setUnit(CodeableConcept10_30.convertCodeableConcept(src.getUnit()));
054    if (src.hasSource())
055      tgt.setSource(Reference10_30.convertReference(src.getSource()));
056    if (src.hasParent())
057      tgt.setParent(Reference10_30.convertReference(src.getParent()));
058    if (src.hasOperationalStatus())
059      tgt.setOperationalStatusElement(convertDeviceMetricOperationalStatus(src.getOperationalStatusElement()));
060    if (src.hasColor())
061      tgt.setColorElement(convertDeviceMetricColor(src.getColorElement()));
062    if (src.hasCategory())
063      tgt.setCategoryElement(convertDeviceMetricCategory(src.getCategoryElement()));
064    if (src.hasMeasurementPeriod())
065      tgt.setMeasurementPeriod(Timing10_30.convertTiming(src.getMeasurementPeriod()));
066    for (org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationComponent t : src.getCalibration())
067      tgt.addCalibration(convertDeviceMetricCalibrationComponent(t));
068    return tgt;
069  }
070
071  public static org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationComponent convertDeviceMetricCalibrationComponent(org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationComponent src) throws FHIRException {
072    if (src == null || src.isEmpty())
073      return null;
074    org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationComponent tgt = new org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationComponent();
075    ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyBackboneElement(src,tgt);
076    if (src.hasType())
077      tgt.setTypeElement(convertDeviceMetricCalibrationType(src.getTypeElement()));
078    if (src.hasState())
079      tgt.setStateElement(convertDeviceMetricCalibrationState(src.getStateElement()));
080    if (src.hasTimeElement())
081      tgt.setTimeElement(Instant10_30.convertInstant(src.getTimeElement()));
082    return tgt;
083  }
084
085  public static org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationComponent convertDeviceMetricCalibrationComponent(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationComponent src) throws FHIRException {
086    if (src == null || src.isEmpty())
087      return null;
088    org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationComponent tgt = new org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationComponent();
089    ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyBackboneElement(src,tgt);
090    if (src.hasType())
091      tgt.setTypeElement(convertDeviceMetricCalibrationType(src.getTypeElement()));
092    if (src.hasState())
093      tgt.setStateElement(convertDeviceMetricCalibrationState(src.getStateElement()));
094    if (src.hasTimeElement())
095      tgt.setTimeElement(Instant10_30.convertInstant(src.getTimeElement()));
096    return tgt;
097  }
098
099  static public org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationState> convertDeviceMetricCalibrationState(org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationState> src) throws FHIRException {
100      if (src == null || src.isEmpty())
101          return null;
102      Enumeration<DeviceMetric.DeviceMetricCalibrationState> tgt = new Enumeration<>(new DeviceMetric.DeviceMetricCalibrationStateEnumFactory());
103      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
104      if (src.getValue() == null) {
105          tgt.setValue(null);
106      } else {
107          switch (src.getValue()) {
108              case NOTCALIBRATED:
109                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationState.NOTCALIBRATED);
110                  break;
111              case CALIBRATIONREQUIRED:
112                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationState.CALIBRATIONREQUIRED);
113                  break;
114              case CALIBRATED:
115                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationState.CALIBRATED);
116                  break;
117              case UNSPECIFIED:
118                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationState.UNSPECIFIED);
119                  break;
120              default:
121                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationState.NULL);
122                  break;
123          }
124      }
125      return tgt;
126  }
127
128  static public org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationState> convertDeviceMetricCalibrationState(org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationState> src) throws FHIRException {
129      if (src == null || src.isEmpty())
130          return null;
131      org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationState> tgt = new org.hl7.fhir.dstu3.model.Enumeration<>(new org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationStateEnumFactory());
132      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
133      if (src.getValue() == null) {
134          tgt.setValue(null);
135      } else {
136          switch (src.getValue()) {
137              case NOTCALIBRATED:
138                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationState.NOTCALIBRATED);
139                  break;
140              case CALIBRATIONREQUIRED:
141                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationState.CALIBRATIONREQUIRED);
142                  break;
143              case CALIBRATED:
144                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationState.CALIBRATED);
145                  break;
146              case UNSPECIFIED:
147                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationState.UNSPECIFIED);
148                  break;
149              default:
150                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationState.NULL);
151                  break;
152          }
153      }
154      return tgt;
155  }
156
157  static public org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationType> convertDeviceMetricCalibrationType(org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationType> src) throws FHIRException {
158      if (src == null || src.isEmpty())
159          return null;
160      org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationType> tgt = new org.hl7.fhir.dstu3.model.Enumeration<>(new org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationTypeEnumFactory());
161      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
162      if (src.getValue() == null) {
163          tgt.setValue(null);
164      } else {
165          switch (src.getValue()) {
166              case UNSPECIFIED:
167                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationType.UNSPECIFIED);
168                  break;
169              case OFFSET:
170                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationType.OFFSET);
171                  break;
172              case GAIN:
173                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationType.GAIN);
174                  break;
175              case TWOPOINT:
176                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationType.TWOPOINT);
177                  break;
178              default:
179                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationType.NULL);
180                  break;
181          }
182      }
183      return tgt;
184  }
185
186  static public org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCalibrationType> convertDeviceMetricCalibrationType(org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCalibrationType> src) throws FHIRException {
187      if (src == null || src.isEmpty())
188          return null;
189      Enumeration<DeviceMetric.DeviceMetricCalibrationType> tgt = new Enumeration<>(new DeviceMetric.DeviceMetricCalibrationTypeEnumFactory());
190      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
191      if (src.getValue() == null) {
192          tgt.setValue(null);
193      } else {
194          switch (src.getValue()) {
195              case UNSPECIFIED:
196                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationType.UNSPECIFIED);
197                  break;
198              case OFFSET:
199                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationType.OFFSET);
200                  break;
201              case GAIN:
202                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationType.GAIN);
203                  break;
204              case TWOPOINT:
205                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationType.TWOPOINT);
206                  break;
207              default:
208                  tgt.setValue(DeviceMetric.DeviceMetricCalibrationType.NULL);
209                  break;
210          }
211      }
212      return tgt;
213  }
214
215  static public org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategory> convertDeviceMetricCategory(org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCategory> src) throws FHIRException {
216      if (src == null || src.isEmpty())
217          return null;
218      org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategory> tgt = new org.hl7.fhir.dstu3.model.Enumeration<>(new org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategoryEnumFactory());
219      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
220      if (src.getValue() == null) {
221          tgt.setValue(null);
222      } else {
223          switch (src.getValue()) {
224              case MEASUREMENT:
225                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategory.MEASUREMENT);
226                  break;
227              case SETTING:
228                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategory.SETTING);
229                  break;
230              case CALCULATION:
231                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategory.CALCULATION);
232                  break;
233              case UNSPECIFIED:
234                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategory.UNSPECIFIED);
235                  break;
236              default:
237                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategory.NULL);
238                  break;
239          }
240      }
241      return tgt;
242  }
243
244  static public org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricCategory> convertDeviceMetricCategory(org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricCategory> src) throws FHIRException {
245      if (src == null || src.isEmpty())
246          return null;
247      Enumeration<DeviceMetric.DeviceMetricCategory> tgt = new Enumeration<>(new DeviceMetric.DeviceMetricCategoryEnumFactory());
248      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
249      if (src.getValue() == null) {
250          tgt.setValue(null);
251      } else {
252          switch (src.getValue()) {
253              case MEASUREMENT:
254                  tgt.setValue(DeviceMetric.DeviceMetricCategory.MEASUREMENT);
255                  break;
256              case SETTING:
257                  tgt.setValue(DeviceMetric.DeviceMetricCategory.SETTING);
258                  break;
259              case CALCULATION:
260                  tgt.setValue(DeviceMetric.DeviceMetricCategory.CALCULATION);
261                  break;
262              case UNSPECIFIED:
263                  tgt.setValue(DeviceMetric.DeviceMetricCategory.UNSPECIFIED);
264                  break;
265              default:
266                  tgt.setValue(DeviceMetric.DeviceMetricCategory.NULL);
267                  break;
268          }
269      }
270      return tgt;
271  }
272
273  static public org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricColor> convertDeviceMetricColor(org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor> src) throws FHIRException {
274      if (src == null || src.isEmpty())
275          return null;
276      Enumeration<DeviceMetric.DeviceMetricColor> tgt = new Enumeration<>(new DeviceMetric.DeviceMetricColorEnumFactory());
277      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
278      if (src.getValue() == null) {
279          tgt.setValue(null);
280      } else {
281          switch (src.getValue()) {
282              case BLACK:
283                  tgt.setValue(DeviceMetric.DeviceMetricColor.BLACK);
284                  break;
285              case RED:
286                  tgt.setValue(DeviceMetric.DeviceMetricColor.RED);
287                  break;
288              case GREEN:
289                  tgt.setValue(DeviceMetric.DeviceMetricColor.GREEN);
290                  break;
291              case YELLOW:
292                  tgt.setValue(DeviceMetric.DeviceMetricColor.YELLOW);
293                  break;
294              case BLUE:
295                  tgt.setValue(DeviceMetric.DeviceMetricColor.BLUE);
296                  break;
297              case MAGENTA:
298                  tgt.setValue(DeviceMetric.DeviceMetricColor.MAGENTA);
299                  break;
300              case CYAN:
301                  tgt.setValue(DeviceMetric.DeviceMetricColor.CYAN);
302                  break;
303              case WHITE:
304                  tgt.setValue(DeviceMetric.DeviceMetricColor.WHITE);
305                  break;
306              default:
307                  tgt.setValue(DeviceMetric.DeviceMetricColor.NULL);
308                  break;
309          }
310      }
311      return tgt;
312  }
313
314  static public org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor> convertDeviceMetricColor(org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricColor> src) throws FHIRException {
315      if (src == null || src.isEmpty())
316          return null;
317      org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor> tgt = new org.hl7.fhir.dstu3.model.Enumeration<>(new org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColorEnumFactory());
318      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
319      if (src.getValue() == null) {
320          tgt.setValue(null);
321      } else {
322          switch (src.getValue()) {
323              case BLACK:
324                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.BLACK);
325                  break;
326              case RED:
327                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.RED);
328                  break;
329              case GREEN:
330                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.GREEN);
331                  break;
332              case YELLOW:
333                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.YELLOW);
334                  break;
335              case BLUE:
336                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.BLUE);
337                  break;
338              case MAGENTA:
339                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.MAGENTA);
340                  break;
341              case CYAN:
342                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.CYAN);
343                  break;
344              case WHITE:
345                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.WHITE);
346                  break;
347              default:
348                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricColor.NULL);
349                  break;
350          }
351      }
352      return tgt;
353  }
354
355  static public org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricOperationalStatus> convertDeviceMetricOperationalStatus(org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricOperationalStatus> src) throws FHIRException {
356      if (src == null || src.isEmpty())
357          return null;
358      Enumeration<DeviceMetric.DeviceMetricOperationalStatus> tgt = new Enumeration<>(new DeviceMetric.DeviceMetricOperationalStatusEnumFactory());
359      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
360      if (src.getValue() == null) {
361          tgt.setValue(null);
362      } else {
363          switch (src.getValue()) {
364              case ON:
365                  tgt.setValue(DeviceMetric.DeviceMetricOperationalStatus.ON);
366                  break;
367              case OFF:
368                  tgt.setValue(DeviceMetric.DeviceMetricOperationalStatus.OFF);
369                  break;
370              case STANDBY:
371                  tgt.setValue(DeviceMetric.DeviceMetricOperationalStatus.STANDBY);
372                  break;
373              default:
374                  tgt.setValue(DeviceMetric.DeviceMetricOperationalStatus.NULL);
375                  break;
376          }
377      }
378      return tgt;
379  }
380
381  static public org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricOperationalStatus> convertDeviceMetricOperationalStatus(org.hl7.fhir.dstu2.model.Enumeration<org.hl7.fhir.dstu2.model.DeviceMetric.DeviceMetricOperationalStatus> src) throws FHIRException {
382      if (src == null || src.isEmpty())
383          return null;
384      org.hl7.fhir.dstu3.model.Enumeration<org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricOperationalStatus> tgt = new org.hl7.fhir.dstu3.model.Enumeration<>(new org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricOperationalStatusEnumFactory());
385      ConversionContext10_30.INSTANCE.getVersionConvertor_10_30().copyElement(src, tgt);
386      if (src.getValue() == null) {
387          tgt.setValue(null);
388      } else {
389          switch (src.getValue()) {
390              case ON:
391                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricOperationalStatus.ON);
392                  break;
393              case OFF:
394                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricOperationalStatus.OFF);
395                  break;
396              case STANDBY:
397                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricOperationalStatus.STANDBY);
398                  break;
399              default:
400                  tgt.setValue(org.hl7.fhir.dstu3.model.DeviceMetric.DeviceMetricOperationalStatus.NULL);
401                  break;
402          }
403      }
404      return tgt;
405  }
406}