code: protected Serializer<?> createVia(SerializerResolver<?> resolver, Type type, Annotation... hints)
  	{
  		Set<Type> s = stack.get();
  
  		// Only expose the hints that the resolver has declared
  		Set<Class<? extends Annotation>> hintsUsed = resolver.getHints();
  		List<Annotation> hintsActive;
  		if(hintsUsed == null || hints == null || hints.length == 0)
  		{
  			hintsActive = Collections.emptyList();
  		}
  		else
  		{
  			hintsActive = new ArrayList<>();
  			for(Annotation a : hints)
  			{
  				if(hintsUsed.contains(a.annotationType()))
  				{
  					hintsActive.add(a);
  				}
  			}
  		}
  
  		// Check if we have already built a serializer for this type
  		CacheKey key = new CacheKey(type, hintsActive.toArray());
  		Serializer<?> serializer = serializers.get(key);
  		if(serializer != null)
  		{
  			return serializer;
  		}
  
  		// Stack to keep track of circular dependencies
  		if(s == null)
  		{
  			s = new HashSet<Type>();
  			stack.set(s);
  		}
  
  		try
  		{
  			s.add(type);
  
  			// Find a serializer to use
  			TypeEncounterImpl encounter = new TypeEncounterImpl(this, type, hintsActive);
  
  			serializer = resolver.find(encounter);
  			if(serializer == null)
  			{
  				throw new SerializationException("Unable to find serializer for " + type + " using " + resolver.getClass());
  			}
  
  			registerIfNamed(type.getErasedType(), serializer);
  
  			// Store the found serializer in the cache
  			serializers.put(key, serializer);
  			return serializer;
  		}
  		finally
  		{
  			s.remove(type);
  
  			if(s.isEmpty())
  			{
  				stack.remove();
  			}
  		}
  	}
docs: Create a new {@link Serializer} for the given type and hints via a
  specific {@link SerializerResolver resolver} instance.
  
  @param resolver
  @param type
  @param hints
  @return