remove(key);
      return true;
    }
    return false;
  }

  @Override
  public boolean replace(K key, V oldValue, V newValue) {
    if (oldValue.equals(get(key))) {
      alertListenerIfPresent(key, oldValue, RemovalCause.REPLACED);
      put(key, newValue);
      return true;
    }
    return false;
  }

  @Override

                    }
                    return result;
                default:
                    return 0;
            }
        }

        public StringItem getStringPart() {
            return stringPart;
        }

        public Item getDigitPart() {
            return digitPart;
        }

        @Override
        public int getType() {
            return COMBINATION_ITEM;
        }

		return
	}
	err = en.WriteTime(z.Queued)
	if err != nil {
		err = msgp.WrapError(err, "Queued")
		return
	}
	// write "BitrotScan"
	err = en.Append(0xaa, 0x42, 0x69, 0x74, 0x72, 0x6f, 0x74, 0x53, 0x63, 0x61, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteBool(z.BitrotScan)
	if err != nil {
		err = msgp.WrapError(err, "BitrotScan")
		return
	}
	return
}

        // because some comparator might throw NPE (e.g. the natural ordering).
        return false;
      }
    }
    try {
      return sortedDelegate.containsAll(targets);
    } catch (ClassCastException e) {
      return false;
    }
  }

  @Override
  public E first() {
    return sortedDelegate.first();
  }

  @Override
  public ImmutableSortedSet<E> headSet(E toElement) {

        return ComponentUtil.getRequestManager();
    }

    /**
     * Gets the current time as a Date object.
     *
     * @return The current time.
     */
    public Date getCurrentTime() {
        return new Date(getCurrentTimeAsLong());
    }

    /**
     * Gets the current time in milliseconds.
     *
     * @return The current time in milliseconds.
     */

        if (isApiRequest) {
            return ComponentUtil.getComponent(AccessTokenService.class).getPermissions(request).map(p -> {
                p.forEach(roleSet::add);
                return true;
            }).orElse(false);
        }
        return false;
    }

    /**
     * Processes the request parameter.
     * @param request The HTTP request.

	return c.with(func(db *DB) *DB {
		return db.Where(query, args...)
	})
}

func (c chainG[T]) Not(query interface{}, args ...interface{}) ChainInterface[T] {
	return c.with(func(db *DB) *DB {
		return db.Not(query, args...)
	})
}

func (c chainG[T]) Or(query interface{}, args ...interface{}) ChainInterface[T] {
	return c.with(func(db *DB) *DB {
		return db.Or(query, args...)
	})
}

		if err != nil {
			return nil, err
		}
		// Check if we have a response ready or a filler byte.
		switch b {
		case 0:
			return reader, nil
		case 1:
			errorText, err := io.ReadAll(reader)
			if err != nil {
				return nil, err
			}
			return nil, errors.New(string(errorText))
		case 32:
			continue
		default:
			return nil, fmt.Errorf("unexpected filler byte: %d", b)
		}

    }

    @TestSubtype
    public Mall<Outdoor>.Shop<Electronics> innerTypeDoesNotMatch_subtypeWithWildcard(
        Mall<Outdoor>.Shop<? extends Electronics> shop) {
      return notSubtype(shop);
    }

    @TestSubtype
    public Mall<Outdoor>.Shop<? extends Electronics> innerTypeDoesNotMatch_supertypeWithWildcard(
        Mall<Outdoor>.Shop<Grocery> shop) {
      return notSubtype(shop);
    }

  }

  protected Collection<Method> suppressForHashMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForHashtable() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedHashMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForTreeMapNatural() {
    return emptySet();
  }