code: public static synchronized ObjectMapper getLegacyMapperFor(@NonNull Class<?> clazz){
          if(!legacyMappers.containsKey(clazz)){
              ObjectMapper m = new ObjectMapper();
              configureMapper(m);
              m.setAnnotationIntrospector(new IgnoreJsonTypeInfoIntrospector(Collections.<Class>singletonList(clazz)));
              legacyMappers.put(clazz, m);
          }
          return legacyMappers.get(clazz);
      }
docs: Get the legacy JSON mapper for the specified class.<br>
  
  <b>NOTE</b>: This is intended for internal backward-compatibility use.
  
  Note to developers: The following JSON mappers are for handling legacy format JSON.
  Note that after 1.0.0-alpha, the JSON subtype format for Transforms, Filters, Conditions etc were changed from
  a wrapper object, to an "@class" field. However, to not break all saved transforms networks, these mappers are
  part of the solution.<br>
  <br>
  How legacy loading works (same pattern for all types - Transform, Filter, Condition etc)<br>
  1. Transforms etc JSON that has a "@class" field are deserialized as normal<br>
  2. Transforms JSON that don't have such a field are mapped (via Layer @JsonTypeInfo) to LegacyMappingHelper.TransformHelper<br>
  3. LegacyMappingHelper.TransformHelper has a @JsonDeserialize annotation - we use LegacyMappingHelper.LegacyTransformDeserializer to handle it<br>
  4. LegacyTransformDeserializer has a list of old names (present in the legacy format JSON) and the corresponding class names
  5. BaseLegacyDeserializer (that LegacyTransformDeserializer extends) does a lookup and handles the deserialization
  
  Now, as to why we have one ObjectMapper for each type: We can't use the default JSON mapper for the legacy format,
  as it'll fail due to not having the expected "@class" annotation.
  Consequently, we need to tell Jackson to ignore that specific annotation and deserialize to the specified
  class anyway. The ignoring is done via an annotation introspector, defined below in this class.
  However, we can't just use a single annotation introspector (and hence ObjectMapper) for loading legacy values of
  all types - if we did, then any nested types would fail (i.e., an Condition in a Transform - the Transform couldn't
  be deserialized correctly, as the annotation would be ignored).