switch ( tagged.getTagNo() ) {
                case 0:
                    ASN1Enumerated enumerated = ASN1Enumerated.getInstance(tagged, true);
                    setResult(enumerated.getValue().intValue());
                    break;
                case 1:
                    setMechanism(ASN1ObjectIdentifier.getInstance(tagged, true));
                    break;
                case 2:

        if ( this.options != null ) {
            for ( Entry<String, Object> entry : this.options.entrySet() ) {
                ret += "," + entry.getKey() + "=" + entry.getValue();
            }
        }
        ret += "]";
        return ret;
    }

                    for (Object object : elements) {
                      Entry<Class, Impl> entry = (Entry<Class, Impl>) object;
                      map.putInstance(entry.getKey(), entry.getValue());
                    }
                    return (Map) map;
                  }
                })
            .named("MutableClassToInstanceMap")
            .withFeatures(

    @Override
    public void putAll(final Map<? extends String, ? extends V> map) {
        for (final Map.Entry<? extends String, ? extends V> entry : map.entrySet()) {
            put(convertKey(entry.getKey()), entry.getValue());
        }
    }

    @Override
    public final V remove(final Object key) {
        return super.remove(convertKey(key));
    }

    @Override
    public boolean containsKey(final Object key) {

    switch (map.size()) {
      case 0:
        return ImmutableMap.of();
      case 1:
        Entry<K, V> entry = getOnlyElement(map.entrySet());
        return ImmutableMap.of(entry.getKey(), entry.getValue());
      default:
        return new ImmutableEnumMap<>(map);
    }
  }

  private final transient EnumMap<K, V> delegate;

  private ImmutableEnumMap(EnumMap<K, V> delegate) {
    this.delegate = delegate;

        Directive matchedDirective = null;
        for (final Map.Entry<Pattern, Directive> entry : directiveMap.entrySet()) {
            if (entry.getKey().matcher(target).find()) {
                final Directive directive = entry.getValue();
                final String ua = directive.getUserAgent();
                int uaLength = 0;
                if (!ALL_BOTS.equals(ua)) {
                    uaLength = ua.length();
                }

        if (value instanceof Boolean) {
            return (Boolean) value;
        }

        return false;
    }

    public float getValue(final Map<String, Object> map) {
        if (map == null || map.isEmpty()) {
            return 0.0f;
        }

    protected int maxClientFactorySize = 10000;

    public synchronized void register(final CrawlerClientFactory crawlerClientFactory) {
        clientMap.entrySet().stream().forEach(e -> load(crawlerClientFactory, e.getKey(), e.getValue()));
        clientFactoryList.add(crawlerClientFactory);
        if (clientFactoryList.size() > maxClientFactorySize) {
            clientFactoryList.remove(0);
        }
    }

            if (profileProp != null) {
                ActivationProperty prop = new ActivationProperty();

                prop.setName(profileProp.getName());
                prop.setValue(profileProp.getValue());

                activation.setProperty(prop);
            }

            ActivationOS profileOs = profileActivation.getOs();

            if (profileOs != null) {

        "Should not contain null after unsupported putIfAbsent(present, null)");
  }

  @CanIgnoreReturnValue
  private V putIfAbsent(Entry<K, V> entry) {
    return getMap().putIfAbsent(entry.getKey(), entry.getValue());
  }