* specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact.repository.metadata.io;

import java.io.IOException;

/**
 * Signals a failure to parse the metadata due to invalid syntax (e.g. non well formed XML or unknown elements).
 *
 */
public class MetadataParseException extends IOException {

    /**
     * The one-based index of the line containing the error.

    @get:OutputDirectory
    abstract val receiptFolder: DirectoryProperty

    fun buildTimestampFrom(provider: Provider<String>) {
        buildTimestamp = provider.map { buildTimestampString -> timestampFormat.parse(buildTimestampString) }
    }

    @TaskAction
    fun generate() {
        if (promotionBuild.get()) {
            logger.logBuildVersion()
        }

                                .collect(Collectors.toList());
                    } catch (final Exception e) {
                        logger.warn("Failed to parse passwords for " + url, e);
                        list = Collections.emptyList();
                    }
                    configPasswordMap.put(value, list);
                }

def apiChangesJsonDirectory = layout.projectDirectory.dir("src/changes/accepted-changes")
def mainApiChangesJsonFile = apiChangesJsonDirectory.file("accepted-public-api-changes.json")
def acceptedViolations = AcceptedApiChanges.parse(apiChangesJsonDirectory.asFile.listFiles()
    .findAll { it.name.endsWith(".json") }
    .collect { providers.fileContents(apiChangesJsonDirectory.file(it.name)).asText.get() }
)

      else -> false
    }

val Response.commonCacheControl: CacheControl
  get() {
    var result = lazyCacheControl
    if (result == null) {
      result = CacheControl.parse(headers)
      lazyCacheControl = result
    }
    return result
  }

fun Response.commonClose() {
  body.close()
}

// It _doesn't_ connect to the remote endpoint. See Call method to see when the
// connect happens.
func newClient(endpoint string) NetLocker {
	u, err := url.Parse(endpoint)
	if err != nil {
		panic(err)
	}

	tr := &http.Transport{
		Proxy:                 http.ProxyFromEnvironment,
		MaxIdleConnsPerHost:   1024,

  // trustBundle contains the individual X.509 trust anchors for this
  // bundle, as PEM bundle of PEM-wrapped, DER-formatted X.509 certificates.
  //
  // The data must consist only of PEM certificate blocks that parse as valid
  // X.509 certificates.  Each certificate must include a basic constraints
  // extension with the CA bit set.  The API server will reject objects that
  // contain duplicate certificates, or that use PEM block headers.

     * @throws IOException If an error occurs while parsing the material.
     */
    public Type2Message(byte[] material) throws IOException {
        parse(material);
    }

    /**
     * Returns the challenge for this message.
     *
     * @return A <code>byte[]</code> containing the challenge.
     */
    public byte[] getChallenge() {

			}

			vwhObject, _, err := deserializer.Decode([]byte(webhookYAML), nil, &admitv1.ValidatingWebhookConfiguration{})
			if err != nil {
				t.Fatalf("could not parse webhook from generated YAML: %s", vwhObject)
			}
			wh := vwhObject.(*admitv1.ValidatingWebhookConfiguration)

			if tc.userManaged {

                } catch (XmlPullParserException e) {
                    throw new ExpressionDocumentationException(
                            "Failed to parse documentation for expression root: " + root, e);
                }
            }
        }

        return expressionDocumentation;
    }

    /**
     * <expressions>
     * <expression>