Convenience method to convert a regular StorableProperty into a
JDBCStorableProperty.

@throws UnsupportedOperationException if JDBCStorableProperty is not supported
773218
<S extends Storable> JDBCStorableProperty<S>
        getJDBCStorableProperty(StorableProperty<S> property)
        throws RepositoryException, SupportException
    {
        JDBCStorableInfo<S> info = examineStorable(property.getEnclosingType());
        JDBCStorableProperty<S> jProperty = info.getAllProperties().get(property.getName());
        if (!jProperty.isSupported()) {
            throw new UnsupportedOperationException
                ("Property is not supported: " + property.getName());
        }
        return jProperty;
    }
324202
private static HashMap<String, ? super Serializable> convertToSerializable(Map<String, Object> objectMap) {
        HashMap<String, ? super Serializable> serializableMap = new HashMap<>(objectMap.size());
        for (Map.Entry<String, Object> objectEntry : objectMap.entrySet()) {
            if (objectEntry.getValue() == null) {
                serializableMap.put(objectEntry.getKey(), (String) null);
            } else if (objectEntry.getValue() instanceof Serializable) {
                serializableMap.put(objectEntry.getKey(), (Serializable) objectEntry.getValue());
            } else {
                serializableMap.put(objectEntry.getKey(), objectEntry.getValue().toString());
            }
        }
        return serializableMap;
    }
313394
private boolean isAlwaysInserted(JDBCStorableProperty<?> property) {
        return property.isVersion() ? (mVersioning == Versioning.AUTO) : !property.isAutomatic();
    }
1018015
public static boolean canFormat(ConfigurablePropertyAccessor bw,
			Object obj, String prop) {
		String key = obj.getClass().getName() + "_" + prop;

		if (!cache.containsKey(key)) {
			cache.put(key, false);

			TypeDescriptor td = bw.getPropertyTypeDescriptor(prop);
			if (td != null) {
				WinletDefaultFormattingConversionService wcs = get();
				if (wcs != null
						&& wcs.hasFmtAnnotation(td)
						&& wcs.canConvert(td,
								TypeDescriptor.valueOf(String.class)))
					cache.put(key, true);
			}
		}

		return cache.get(key);
	}
1246468
public ClassFileBuilder prepare() throws SupportException {
        if (mPrimaryKey == null) {
            throw new IllegalStateException("Primary key not defined");
        }

        // Clear the cached result, if any
        mStorableClass = null;

        mClassFileGenerator = new StorableClassFileBuilder(
             mClassNameProvider,
             mLoader,
             SyntheticStorableBuilder.class,
             mEvolvable);
        ClassFile cf = mClassFileGenerator.getClassFile();

        for (SyntheticProperty prop : mPropertyList) {
            definePropertyBeanMethods(cf, prop);
        }

        definePrimaryKey(cf);
        defineAlternateKeys(cf);
        defineIndexes(cf);

        return mClassFileGenerator;
    }
208485
@SuppressWarnings("unchecked")
    protected StorableProperty<S>[] gatherAllProperties() {
        Map<String, ? extends StorableProperty<S>> map =
            StorableIntrospector.examine(mType).getAllProperties();

        List<StorableProperty<S>> list = new ArrayList<StorableProperty<S>>(map.size());

        for (StorableProperty<S> property : map.values()) {
            if (!property.isJoin() && !property.isDerived()) {
                list.add(property);
            }
        }

        return list.toArray(new StorableProperty[list.size()]);
    }
220153
private Object initializeLazyPropertiesFromCache(
			final String fieldName,
			final Object entity,
			final SharedSessionContractImplementor session,
			final EntityEntry entry,
			final CacheEntry cacheEntry
	) {
		throw new NotSupportedException( "OGM-9", "Lazy properties not supported in OGM" );
	}
1224763
public static DatabaseProtocolFrontendEngine newInstance(final DatabaseType databaseType) {
        for (DatabaseProtocolFrontendEngine each : NewInstanceServiceLoader.newServiceInstances(DatabaseProtocolFrontendEngine.class)) {
            if (DatabaseType.valueFrom(each.getDatabaseType()) == databaseType) {
                return each;
            }
        }
        throw new UnsupportedOperationException(String.format("Cannot support database type '%s'", databaseType));
    }
713356
private ObjectMapper createObjectMapperWithRootUnWrap() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
        mapper.addHandler(new CustomDeserializationProblemHandler());
       
        
        mapper.registerModule(new JodaModule());
        return mapper;
    }
44385
private void unsetVersionProperty(CodeBuilder b) throws SupportException {
        StorableProperty<?> property = mInfo.getVersionProperty();

        // Set the property state to uninitialized.
        {
            String stateFieldName =
                StorableGenerator.PROPERTY_STATE_FIELD_NAME + (property.getNumber() >> 4);
            b.loadThis();
            b.loadThis();
            b.loadField(stateFieldName, TypeDesc.INT);
            int shift = (property.getNumber() & 0xf) * 2;
            b.loadConstant(~(StorableGenerator.PROPERTY_STATE_MASK << shift));
            b.math(Opcode.IAND);
            b.storeField(stateFieldName, TypeDesc.INT);
        }

        // Zero the property value.
        TypeDesc type = TypeDesc.forClass(property.getType());
        b.loadThis();
        CodeBuilderUtil.blankValue(b, type);
        b.storeField(property.getName(), type);
    }
1302510
@Deprecated
  @Override
  public boolean putAll(final R rowKey, final C columnKey, final Iterable<? extends V> values) {
    throw new UnsupportedOperationException();
  }
770856
public void populate(Map<String, String[]> map)
    {
        for (Entry<String, String[]> entry : map.entrySet())
        {
            String property = entry.getKey();
            if (model.typeMap.containsKey(property))
            {
                String[] values = entry.getValue();
                if (values.length > 1)
                {
                    throw new UnsupportedOperationException(property + " has multivalue " + values);
                }
                if (values.length == 1)
                {
                    set(property, values[0]);
                }
            }
        }
    }
1165715
public Object readObject(DatabaseReadable pReadable) throws SQLException {
        return readObject(pReadable.getId(), pReadable.getClass(), 
                          pReadable.getMapping());
    }
745942
private void generateImmutableToBuilder() {
        if (data.isBuilderGenerated()) {
            if (data.isConstructable()) {
                List<PropertyGen> nonDerived = nonDerivedProperties();
                if (nonDerived.size() > 0 || !data.isTypeFinal()) {
                    addLine(1, "/**");
                    addLine(1, " * Returns a builder that allows this bean to be mutated.");
                    addLine(1, " * @return the mutable builder, not null");
                    addLine(1, " */");
                    if (data.isRootClass() == false) {
                        addLine(1, "@Override");
                    }
                    addLine(1, data.getEffectiveBuilderScope() + "Builder" + data.getTypeGenericName(true) + " toBuilder() {");
                    addLine(2, "return new Builder" + data.getTypeGenericDiamond() + "(this);");
                    addLine(1, "}");
                    addBlankLine();
                }
            } else {
                addLine(1, "/**");
                addLine(1, " * Returns a builder that allows this bean to be mutated.");
                addLine(1, " * @return the mutable builder, not null");
                addLine(1, " */");
                if (data.isRootClass() == false) {
                    addLine(1, "@Override");
                }
                addLine(1, "public abstract Builder" + data.getTypeGenericName(true) + " toBuilder();");
                addBlankLine();
            }
        }
    }
1018542
@Override
    public Object beforeDelete(S storable) throws PersistException {
        S existing = (S) storable.copy();
        try {
            if (!existing.tryLoad()) {
                existing = null;
            }
            return existing;
        } catch (FetchException e) {
            throw e.toPersistException();
        }
    }
898890
function toStorableUnusableRecordState(unusableRecordState, unusableRecord, context) {
  if (!unusableRecordState) {
    context.warn(`Skipping save of state for unusable record, since it has no state - record (${JSON.stringify(unusableRecord)})`);
    return undefined;
  }

  // Convert the record's state into a safely storable object to get a clean, simplified version of its state
  const state = dynamoDBUtils.toStorableObject(unusableRecordState);

  // If state has no record identifier then have no way to identify the unusable record ... so attach a safely storable
  // copy of its original user record or record (if any) (without its legacy state, if any) for later matching!
  if (!hasUnusableRecordIdentifier(unusableRecordState)) {
    unusableRecord = unusableRecord || unusableRecordState.unusableRecord;

    if (unusableRecord) {
      // Make a storable copy of the unusable record & attach it to the storable state
      state.unusableRecord = dynamoDBUtils.toStorableObject(unusableRecord);
      // Remove the unusable record copy's LEGACY state (if any) to get back to the original unusable record
      tracking.deleteLegacyState(unusableRecord, context);
    }
    if (unusableRecordState.userRecord) {
      // Make a storable copy of the unusable record's user record & attach it to the storable state
      state.userRecord = dynamoDBUtils.toStorableObject(unusableRecordState.userRecord);
      // Remove the unusable record's user record copy's LEGACY state (if any) to get back to the original user record
      tracking.deleteLegacyState(state.userRecord, context);
    }
    else if (unusableRecordState.record) {
      // Make a storable copy of the unusable record's record & attach it to the storable state
      state.record = dynamoDBUtils.toStorableObject(unusableRecordState.record);
      // remove the unusable record's record copy's LEGACY state (if any) to get back to the original record
      tracking.deleteLegacyState(state.record, context);
    }
  }
  return state;
}
1340155
public static JsonElementConverter getConvertor(String fieldName, String fieldType, JsonObject schemaNode,
      WorkUnitState state, boolean nullable)
      throws UnsupportedDateTypeException {
    if (!schemaNode.has(COLUMN_NAME_KEY)) {
      schemaNode.addProperty(COLUMN_NAME_KEY, fieldName);
    }
    if (!schemaNode.has(DATA_TYPE_KEY)) {
      schemaNode.add(DATA_TYPE_KEY, new JsonObject());
    }
    JsonObject dataType = schemaNode.get(DATA_TYPE_KEY).getAsJsonObject();
    if (!dataType.has(TYPE_KEY)) {
      dataType.addProperty(TYPE_KEY, fieldType);
    }
    if (!schemaNode.has(IS_NULLABLE_KEY)) {
      schemaNode.addProperty(IS_NULLABLE_KEY, nullable);
    }
    JsonSchema schema = new JsonSchema(schemaNode);
    return getConvertor(schema, null, state);
  }