Determine whether or not a given serializedr is "AVRO" based

@param serializerName
@return
502293
public static boolean isAvroSchema(String serializerName) {
        if(serializerName.equals(AVRO_GENERIC_VERSIONED_TYPE_NAME)
           || serializerName.equals(AVRO_GENERIC_TYPE_NAME)
           || serializerName.equals(AVRO_REFLECTIVE_TYPE_NAME)
           || serializerName.equals(AVRO_SPECIFIC_TYPE_NAME)) {
            return true;
        } else {
            return false;
        }
    }
820927
def get_serializer(name, **options):
    '''
'''
    if name in _serializers:
        serializer = _serializers[name]
        return serializer(**options)
    else:
        raise ValueError('Unknown serializer {0}.'.format(name))
751090
private <T extends Serializable> Serializer getSerializer(QName xmlType, Class<T> clazz)
      throws SecurityException,
      NoSuchMethodException,
      IllegalArgumentException,
      IllegalAccessException,
      InvocationTargetException {
    Method getSerializer = clazz.getMethod("getSerializer", String.class, Class.class, QName.class);
    return (Serializer) getSerializer.invoke(null, null, clazz, xmlType);
  }
465291
def _is_json_serialized_jws(self, json_jws):
        
        json_ser_keys = {"payload", "signatures"}
        flattened_json_ser_keys = {"payload", "signature"}
        if not json_ser_keys.issubset(
                json_jws.keys()) and not flattened_json_ser_keys.issubset(
                json_jws.keys()):
            return False
        return True
1333992
public static <T> boolean checkIfNullSupported(@Nonnull TypeSerializer<T> serializer) {
		int length = serializer.getLength() > 0 ? serializer.getLength() : 1;
		DataOutputSerializer dos = new DataOutputSerializer(length);
		try {
			serializer.serialize(null, dos);
		}
		catch (IOException | RuntimeException e) {
			return false;
		}
		checkArgument(
			serializer.getLength() < 0 || serializer.getLength() == dos.getCopyOfBuffer().length,
			"The serialized form of the null value should have the same length " +
				"as any other if the length is fixed in the serializer");
		DataInputDeserializer dis = new DataInputDeserializer(dos.getSharedBuffer());
		try {
			checkArgument(serializer.deserialize(dis) == null);
		}
		catch (IOException e) {
			throw new RuntimeException(
				String.format("Unexpected failure to deserialize just serialized null value with %s",
					serializer.getClass().getName()), e);
		}
		checkArgument(
			serializer.copy(null) == null,
			"Serializer %s has to be able properly copy null value if it can serialize it",
			serializer.getClass().getName());
		return true;
	}
394210
def register_serializer(name, serializer):
    '''
'''
    if not isclass(serializer):
        serializer = serializer.__class__
    _serializers[name] = serializer
1312807
function Serializer () {
  var self = this, args = fun(arguments);

  self.klass = self.klass || Serializer;

  self.options = Object.merge(self.klass.defaults.options, args.objects()[0] || {}, true);
  self.engine = null;
  self.binary = false;
}
1014850
def get_serializer(serializer_format):
    
    if serializer_format == Format.JSON:
        return _serialize_json
    if serializer_format == Format.PICKLE:
        return _serialize_pickle
852448
@SuppressWarnings("unchecked")
    public static <T> Serializer<T> unsafeGetSerializer(SerializerFactory serializerFactory,
                                                        SerializerDefinition serializerDefinition) {
        return (Serializer<T>) serializerFactory.getSerializer(serializerDefinition);
    }
86998
private SerializerWrapper getSerializerWrapper(Class cls) {
    SerializerWrapper w = serializers.get(cls);
    if (w != null) {
      return w;
    } else {
      // Try with interfaces implemented
      for (Class c : cls.getInterfaces()) {
        w = serializers.get(c);
        if (w != null) {
          return w;
        }
      }
    }
    return null;
  }
300153
public synchronized void registerSerializer(Serializer serializer) {
    Class objClass = getSerializerType(serializer);
    if (!serializers.containsKey(objClass)) {
      int index = COUNTER.getAndIncrement();
      serializers.put(objClass, new SerializerWrapper(index, serializer));
      if (serializersArray.length <= index) {
        serializersArray = Arrays.copyOf(serializersArray, index + 1);
      }
      serializersArray[index] = serializer;

      LOGGER.info(String
          .format("Registered new serializer '%s' %n  for '%s' at index %d", serializer.getClass().getName(),
              objClass.getName(), index));
    }
  }
11017
public static <T> T readAvroEntity(Decoder decoder, DatumReader<T> reader) {
    try {
      return reader.read(null, decoder);
    } catch (IOException e) {
      throw new SerializationException("Could not deserialize Avro entity", e);
    }
  }
66397
public static Serializer getSerializer(byte type) {
        Serializer serializer = TYPE_SERIALIZER_MAP.get(type);
        if (serializer == null) {
            throw new SofaRpcRuntimeException("Serializer Not Found :\"" + type + "\"!");
        }
        return serializer;
    }
115625
Serializer getSerializer(int index) {
    if (index >= serializersArray.length) {
      throw new IllegalArgumentException(String.format("The serializer can't be found at index %d", index));
    }
    return serializersArray[index];
  }
277834
@Override
  public <T> ByteBuffer serialize(final Serializer<T> serializer, final T value)
    throws IOException {
    try (final BytesSerialWriter writer = writeBytes()) {
      serializer.serialize(writer, value);
      return writer.toByteBuffer();
    }
  }
941291
def _get_serializer(output):
    '''
    
    '''
    serializers = salt.loader.serializers(__opts__)
    try:
        return getattr(serializers, output)
    except AttributeError:
        raise CommandExecutionError(
            "Unknown serializer '{0}' found for output option".format(output)
        )
924607
@FFDCIgnore(Throwable.class)
    @Sensitive
    private byte[] serializeResult(Object result, ClassLoader loader) throws IOException {
        try {
            return persistentExecutor.serialize(result);
        } catch (Throwable x) {
            return persistentExecutor.serialize(new TaskFailure(x, loader, persistentExecutor, TaskFailure.NONSER_RESULT, result.getClass().getName()));
        }
    }