ca.uhn.fhir.parser.DataFormatException Java Examples

/**
 * Sets the value for this type using the given Java Date object as the time, and using the specified precision, as
 * well as the local timezone as determined by the local operating system. Both of
 * these properties may be modified in subsequent calls if neccesary.
 *
 * @param theValue
 *           The date value
 * @param thePrecision
 *           The precision
 * @throws DataFormatException
 */
public void setValue(Date theValue, TemporalPrecisionEnum thePrecision) throws DataFormatException {
	if (getTimeZone() == null) {
		setTimeZone(TimeZone.getDefault());
	}
	myPrecision = thePrecision;
	myFractionalSeconds = "";
	if (theValue != null) {
		long millis = theValue.getTime() % 1000;
		if (millis < 0) {
			// This is for times before 1970 (see bug #444)
			millis = 1000 + millis;
		}
		String fractionalSeconds = Integer.toString((int) millis);
		myFractionalSeconds = StringUtils.leftPad(fractionalSeconds, 3, '0');
	}
	super.setValue(theValue);
}
 

public static Optional<IBaseResource> loadResource(IFinding finding) throws DataFormatException{
	IBaseResource resource = null;
	String rawContent = finding.getRawContent();
	if (rawContent != null && !rawContent.isEmpty()) {
		// always convert to newest json format
		if (!FindingsFormatUtil.isCurrentFindingsFormat(rawContent)) {
			Optional<String> convertedContent =
				FindingsFormatUtil.convertToCurrentFindingsFormat(rawContent);
			if (convertedContent.isPresent()) {
				rawContent = convertedContent.get();
			}
		}
		resource = getAsResource(rawContent);
	}
	return Optional.ofNullable(resource);
}
 

/**
 * The "@Update" annotation indicates that this method supports replacing an existing
 * resource (by ID) with a new instance of that resource.
 *
 * @param theId      This is the ID of the patient to update
 * @param thePatient This is the actual resource to save
 * @return This method returns a "MethodOutcome"
 */
@Update()
public MethodOutcome updatePatient(@IdParam IdType theId, @ResourceParam Patient thePatient) {
   validateResource(thePatient);

   Long id;
   try {
      id = theId.getIdPartAsLong();
   } catch (DataFormatException e) {
      throw new InvalidRequestException("Invalid ID " + theId.getValue() + " - Must be numeric");
   }

   /*
    * Throw an exception (HTTP 404) if the ID is not known
    */
   if (!myIdToPatientVersions.containsKey(id)) {
      throw new ResourceNotFoundException(theId);
   }

   addNewVersion(thePatient, id);

   return new MethodOutcome();
}
 

protected Boolean parse(String theValue) {
	String value = theValue.trim();
	if ("true".equals(value)) {
		return Boolean.TRUE;
	} else if ("false".equals(value)) {
		return Boolean.FALSE;
	} else {
		throw new DataFormatException("Invalid boolean string: '" + theValue + "'");
	}
}
 

/**
 * Sets the value for this type using the given Java Date object as the time, and using the specified precision, as
 * well as the local timezone as determined by the local operating system. Both of
 * these properties may be modified in subsequent calls if neccesary.
 *
 * @param theValue
 *           The date value
 * @param thePrecision
 *           The precision
 * @throws DataFormatException
 */
public void setValue(Date theValue, TemporalPrecisionEnum thePrecision) throws DataFormatException {
  if (getTimeZone() == null) {
    setTimeZone(TimeZone.getDefault());
  }
  myPrecision = thePrecision;
  myFractionalSeconds = "";
  if (theValue != null) {
    long millis = theValue.getTime() % 1000;
    if (millis < 0) {
      // This is for times before 1970 (see bug #444)
      millis = 1000 + millis;
    }
    String fractionalSeconds = Integer.toString((int) millis);
    myFractionalSeconds = StringUtils.leftPad(fractionalSeconds, 3, '0');
  }
  super.setValue(theValue);
}
 

/**
 * Sets the value for this type using the given Java Date object as the time, and using the specified precision, as
 * well as the local timezone as determined by the local operating system. Both of
 * these properties may be modified in subsequent calls if neccesary.
 *
 * @param theValue
 *           The date value
 * @param thePrecision
 *           The precision
 * @throws DataFormatException
 */
public void setValue(Date theValue, TemporalPrecisionEnum thePrecision) throws DataFormatException {
  if (getTimeZone() == null) {
    setTimeZone(TimeZone.getDefault());
  }
  myPrecision = thePrecision;
  myFractionalSeconds = "";
  if (theValue != null) {
    long millis = theValue.getTime() % 1000;
    if (millis < 0) {
      // This is for times before 1970 (see bug #444)
      millis = 1000 + millis;
    }
    String fractionalSeconds = Integer.toString((int) millis);
    myFractionalSeconds = StringUtils.leftPad(fractionalSeconds, 3, '0');
  }
  super.setValue(theValue);
}
 

/**
 * Sets the value for this type using the given Java Date object as the time, and using the specified precision, as
 * well as the local timezone as determined by the local operating system. Both of
 * these properties may be modified in subsequent calls if neccesary.
 *
 * @param theValue
 *           The date value
 * @param thePrecision
 *           The precision
 * @throws DataFormatException
 */
public void setValue(Date theValue, TemporalPrecisionEnum thePrecision) throws DataFormatException {
	if (getTimeZone() == null) {
		setTimeZone(TimeZone.getDefault());
	}
	myPrecision = thePrecision;
	myFractionalSeconds = "";
	if (theValue != null) {
		long millis = theValue.getTime() % 1000;
		if (millis < 0) {
			// This is for times before 1970 (see bug #444)
			millis = 1000 + millis;
		}
		String fractionalSeconds = Integer.toString((int) millis);
		myFractionalSeconds = StringUtils.leftPad(fractionalSeconds, 3, '0');
	}
	super.setValue(theValue);
}
 

/**
 * Sets the precision for this datatype
 *
 * @throws DataFormatException
 */
public void setPrecision(TemporalPrecisionEnum thePrecision) throws DataFormatException {
  if (thePrecision == null) {
    throw new NullPointerException("Precision may not be null");
  }
  myPrecision = thePrecision;
  updateStringValue();
}
 

@Test
@DisplayName("Null String value creates non-null instance with null value.")
public void testNullInstance() throws DataFormatException {
  String v = null;
  Base64BinaryType b64 = new Base64BinaryType(v);
  Assertions.assertNotNull(b64);
  Assertions.assertNull(b64.getValue());
  Assertions.assertNull(b64.getValueAsString());
}
 

/**
 * Adds the given amount to the field specified by theField
 *
 * @param theField
 *           The field, uses constants from {@link Calendar} such as {@link Calendar#YEAR}
 * @param theValue
 *           The number to add (or subtract for a negative number)
 */
public void add(int theField, int theValue) {
  switch (theField) {
    case Calendar.YEAR:
      setValue(DateUtils.addYears(getValue(), theValue), getPrecision());
      break;
    case Calendar.MONTH:
      setValue(DateUtils.addMonths(getValue(), theValue), getPrecision());
      break;
    case Calendar.DATE:
      setValue(DateUtils.addDays(getValue(), theValue), getPrecision());
      break;
    case Calendar.HOUR:
      setValue(DateUtils.addHours(getValue(), theValue), getPrecision());
      break;
    case Calendar.MINUTE:
      setValue(DateUtils.addMinutes(getValue(), theValue), getPrecision());
      break;
    case Calendar.SECOND:
      setValue(DateUtils.addSeconds(getValue(), theValue), getPrecision());
      break;
    case Calendar.MILLISECOND:
      setValue(DateUtils.addMilliseconds(getValue(), theValue), getPrecision());
      break;
    default:
      throw new DataFormatException("Unknown field constant: " + theField);
  }
}
 

/**
 * Adds the given amount to the field specified by theField
 *
 * @param theField
 *           The field, uses constants from {@link Calendar} such as {@link Calendar#YEAR}
 * @param theValue
 *           The number to add (or subtract for a negative number)
 */
public void add(int theField, int theValue) {
	switch (theField) {
	case Calendar.YEAR:
		setValue(DateUtils.addYears(getValue(), theValue), getPrecision());
		break;
	case Calendar.MONTH:
		setValue(DateUtils.addMonths(getValue(), theValue), getPrecision());
		break;
	case Calendar.DATE:
		setValue(DateUtils.addDays(getValue(), theValue), getPrecision());
		break;
	case Calendar.HOUR:
		setValue(DateUtils.addHours(getValue(), theValue), getPrecision());
		break;
	case Calendar.MINUTE:
		setValue(DateUtils.addMinutes(getValue(), theValue), getPrecision());
		break;
	case Calendar.SECOND:
		setValue(DateUtils.addSeconds(getValue(), theValue), getPrecision());
		break;
	case Calendar.MILLISECOND:
		setValue(DateUtils.addMilliseconds(getValue(), theValue), getPrecision());
		break;
	default:
		throw new DataFormatException("Unknown field constant: " + theField);
	}
}
 

protected Boolean parse(String theValue) {
	String value = theValue.trim();
	if ("true".equals(value)) {
		return Boolean.TRUE;
	} else if ("false".equals(value)) {
		return Boolean.FALSE;
	} else {
		throw new DataFormatException("Invalid boolean string: '" + theValue + "'");
	}
}
 

@Test
@DisplayName("Null String value creates non-null instance with null value.")
public void testNullInstance() throws DataFormatException {
  String v = null;
  Base64BinaryType b64 = new Base64BinaryType(v);
  Assertions.assertNotNull(b64);
  Assertions.assertNull(b64.getValue());
  Assertions.assertNull(b64.getValueAsString());
}
 

/**
 * Constructor
 *
 * @throws DataFormatException
 *            If the specified precision is not allowed for this type
 */
public BaseDateTimeType(Date theDate, TemporalPrecisionEnum thePrecision) {
  setValue(theDate, thePrecision);
  if (isPrecisionAllowed(thePrecision) == false) {
    throw new DataFormatException("Invalid date/time string (datatype " + getClass().getSimpleName() + " does not support " + thePrecision + " precision): " + theDate);
  }
}
 

/**
 * Constructor
 *
 * @throws DataFormatException
 *            If the specified precision is not allowed for this type
 */
public BaseDateTimeType(String theString) {
  setValueAsString(theString);
  if (isPrecisionAllowed(getPrecision()) == false) {
    throw new DataFormatException("Invalid date/time string (datatype " + getClass().getSimpleName() + " does not support " + getPrecision() + " precision): " + theString);
  }
}
 

/**
 * Sets the precision for this datatype
 *
 * @throws DataFormatException
 */
public void setPrecision(TemporalPrecisionEnum thePrecision) throws DataFormatException {
  if (thePrecision == null) {
    throw new NullPointerException("Precision may not be null");
  }
  myPrecision = thePrecision;
  updateStringValue();
}
 

@Test
@DisplayName("Null String value creates non-null instance with null value.")
public void testNullInstance() throws DataFormatException {
  String v = null;
  Base64BinaryType b64 = new Base64BinaryType(v);
  Assertions.assertNotNull(b64);
  Assertions.assertNull(b64.getValue());
  Assertions.assertNull(b64.getValueAsString());
}
 

private DateTimeType conformanceDate() {
        IPrimitiveType<Date> buildDate = serverConfiguration.getConformanceDate();
        if (buildDate != null) {
            try {
                return new DateTimeType(buildDate.getValue());
            } catch (DataFormatException e) {
// fall through
            }
        }
        return DateTimeType.now();
    }
 

private DateTimeType conformanceDate() {
    IPrimitiveType<Date> buildDate = serverConfiguration.getConformanceDate();
    if (buildDate != null) {
        try {
            return new DateTimeType(buildDate.getValue());
        } catch (DataFormatException e) {
            // fall through
        }
    }
    return DateTimeType.now();
}
 

public static void saveResource(IBaseResource resource, IFinding finding)
	throws DataFormatException{
	if (resource != null) {
		String resourceJson = getJsonParser().encodeResourceToString(resource);
		finding.setRawContent(resourceJson);
	}
}
 

/**
 * Sets the precision for this datatype
 *
 * @throws DataFormatException
 */
public void setPrecision(TemporalPrecisionEnum thePrecision) throws DataFormatException {
	if (thePrecision == null) {
		throw new NullPointerException("Precision may not be null");
	}
	myPrecision = thePrecision;
	updateStringValue();
}
 

@Test
@DisplayName("Null String value creates non-null instance with null value.")
public void testNullInstance() throws DataFormatException {
  String v = null;
  Base64BinaryType b64 = new Base64BinaryType(v);
  Assertions.assertNotNull(b64);
  Assertions.assertNull(b64.getValue());
  Assertions.assertNull(b64.getValueAsString());
}
 

protected Boolean parse(String theValue) {
	String value = theValue.trim();
	if ("true".equals(value)) {
		return Boolean.TRUE;
	} else if ("false".equals(value)) {
		return Boolean.FALSE;
	} else {
		throw new DataFormatException("Invalid boolean string: '" + theValue + "'");
	}
}
 

@Test
@DisplayName("Null String value creates non-null instance with null value.")
public void testNullInstance() throws DataFormatException {
  String v = null;
  Base64BinaryType b64 = new Base64BinaryType(v);
  Assertions.assertNotNull(b64);
  Assertions.assertNull(b64.getValue());
  Assertions.assertNull(b64.getValueAsString());
}
 

/**
 * Adds the given amount to the field specified by theField
 *
 * @param theField
 *           The field, uses constants from {@link Calendar} such as {@link Calendar#YEAR}
 * @param theValue
 *           The number to add (or subtract for a negative number)
 */
public void add(int theField, int theValue) {
	switch (theField) {
	case Calendar.YEAR:
		setValue(DateUtils.addYears(getValue(), theValue), getPrecision());
		break;
	case Calendar.MONTH:
		setValue(DateUtils.addMonths(getValue(), theValue), getPrecision());
		break;
	case Calendar.DATE:
		setValue(DateUtils.addDays(getValue(), theValue), getPrecision());
		break;
	case Calendar.HOUR:
		setValue(DateUtils.addHours(getValue(), theValue), getPrecision());
		break;
	case Calendar.MINUTE:
		setValue(DateUtils.addMinutes(getValue(), theValue), getPrecision());
		break;
	case Calendar.SECOND:
		setValue(DateUtils.addSeconds(getValue(), theValue), getPrecision());
		break;
	case Calendar.MILLISECOND:
		setValue(DateUtils.addMilliseconds(getValue(), theValue), getPrecision());
		break;
	default:
		throw new DataFormatException("Unknown field constant: " + theField);
	}
}
 

/**
 * Sets the precision for this datatype
 *
 * @throws DataFormatException
 */
public void setPrecision(TemporalPrecisionEnum thePrecision) throws DataFormatException {
	if (thePrecision == null) {
		throw new NullPointerException("Precision may not be null");
	}
	myPrecision = thePrecision;
	updateStringValue();
}
 

@Override
public void setValueAsString(String theValue) throws DataFormatException {
	clearTimeZone();
	super.setValueAsString(theValue);
}
 

@Override
public void setValueAsString(String theValue) throws DataFormatException {
	clearTimeZone();
	super.setValueAsString(theValue);
}
 

private void throwBadDateFormat(String theValue) {
	throw new DataFormatException("Invalid date/time format: \"" + theValue + "\"");
}
 

private void throwBadDateFormat(String theValue, String theMesssage) {
	throw new DataFormatException("Invalid date/time format: \"" + theValue + "\": " + theMesssage);
}