object HashSetCodec : Codec<HashSet<Any?>> {

    override suspend fun WriteContext.encode(value: HashSet<Any?>) {
        writeCollectionCheckingForCircularElements(value)
    }

    override suspend fun ReadContext.decode(): HashSet<Any?> =
        readCollectionCheckingForCircularElementsInto(::LinkedHashSet)
}


private
suspend fun WriteContext.writeCollectionCheckingForCircularElements(collection: Collection<Any?>) {

        write(value.componentIdentifier)
        value.publishArtifact.run {
            write(ImmutablePublishArtifact(name, extension, type, classifier, file))
        }
    }

    override suspend fun ReadContext.decode(): PublishArtifactLocalArtifactMetadata {
        val componentId = read() as ComponentIdentifier
        val publishArtifact = read() as ImmutablePublishArtifact

                write(value.get())
            } else {
                writeBoolean(false)
                write(value.supplier)
            }
        }
    }

    override suspend fun ReadContext.decode(): CalculatedValueContainer<Any, ValueCalculator<Any>>? {
        return decodePreservingSharedIdentity {
            val available = readBoolean()
            if (available) {
                val value = read()

                }
            }
        }

        writeCollection(value.removals) { removal ->
            writeString(removal.key)
        }
    }

    override suspend fun ReadContext.decode(): ConfigurationCacheEnvironmentChangeTracker.CachedEnvironmentState {
        val cleared = readBoolean()
        val updates = readList {
            val clazz = readClass()
            val key = read() as Any

        val isTaskFromSameProject = delegate is Task && delegate.project == value.project

        return isTaskReferencesAllowed && isTaskFromSameProject
    }

    override suspend fun ReadContext.decode(): Task? = when (readEnum<ReferenceType>()) {
        ReferenceType.SELF_REF ->
            isolate.owner.delegate as Task

        ReferenceType.TASK_REF -> {
            val taskName = readString()

        write(value.artifact.id.componentIdentifier)
        write(value.artifact.file)
        write(unpackTransformSteps(value.transformSteps))
    }

    override suspend fun ReadContext.decode(): TransformingAsyncArtifactListener.TransformedArtifact {
        val variantName = readNonNull<DisplayName>()
        val target = readNonNull<ImmutableAttributes>()

					return
				}
			}
			if strings.Contains(errStr, "unexpected EOF") {
				return
			}
			if errStr == "invalid bytes after =" && badSoftRx.MatchString(s) {
				return
			}
			t.Errorf("decode(%q) = %v", s, err)
			return
		}
		if *useQprint {
			cmd := exec.Command("qprint", "-d")
			cmd.Stdin = strings.NewReader(s)
			stderr, err := cmd.StderrPipe()
			if err != nil {
				panic(err)
			}

 *
 * @see [org.gradle.internal.serialize.beans.services.unsupportedFieldDeclaredTypes]
 */
object SerializedLambdaParametersCheckingCodec : Codec<SerializedLambda> {
    override suspend fun ReadContext.decode(): SerializedLambda {
        return decodeBean() as SerializedLambda
    }

    override suspend fun WriteContext.encode(value: SerializedLambda) {
        checkLambdaCapturedArgTypesAreSupported(value)

        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
        token_data = TokenData(username=username)

        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
        token_data = TokenData(username=username)