this.trustedPgpKeys = ImmutableSet.copyOf(trustedPgpKeys);
        this.ignoredPgpKeys = ImmutableSet.copyOf(ignoredPgpKeys);
        this.hashCode = computeHashCode();
    }

    @Override
    public String getArtifactName() {
        return artifactName;
    }

    @Override
    public List<Checksum> getChecksums() {
        return checksums;
    }

    @Override
    public Set<String> getTrustedPgpKeys() {

        return targetAttributes;
    }

    @Override
    public List<? extends Capability> getCapabilities() {
        return capabilities;
    }

    @Override
    public String getArtifactName() {
        return artifactName;
    }

    @Override
    public ConfigurationIdentity getDependenciesConfigurationIdentity() {
        return dependenciesConfigurationIdentity;
    }

        context.add(buildDependencies);
        if (resolvedArtifactDependency != null) {
            context.add(resolvedArtifactDependency);
        }
    }

    @Override
    public IvyArtifactName getArtifactName() {
        return artifact;
    }

    @Override
    public ComponentArtifactIdentifier getId() {
        return artifactId;
    }

    @Override
    public boolean equals(Object obj) {

        artifact.getConfigurations().addAll(configurations);
    }

    private Artifact findOrCreate(IvyArtifactName artifactName) {
        for (Artifact existingArtifact : artifacts) {
            if (existingArtifact.getArtifactName().equals(artifactName)) {
                return existingArtifact;
            }
        }
        Artifact newArtifact = new Artifact(artifactName);
        artifacts.add(newArtifact);
        return newArtifact;

    }

    private List<IvyArtifactName> fromIvyDescriptor(IvyDependencyDescriptor descriptor) {
        List<Artifact> artifacts = descriptor.getDependencyArtifacts();
        return artifacts.stream().map(Artifact::getArtifactName).collect(Collectors.toList());
    }

    private List<IvyArtifactName> fromMavenDescriptor(MavenDependencyDescriptor descriptor) {
        IvyArtifactName artifact = descriptor.getDependencyArtifact();

        }
    }

    private static void writeMetadata(InstrumentationArtifactMetadata metadata, KryoBackedEncoder encoder) {
        encoder.writeString(metadata.getArtifactName());
        encoder.writeString(metadata.getArtifactHash());
    }

    private static void writeTypesMap(Map<String, Set<String>> typesMap, Encoder encoder, HierarchicalNameSerializer nameSerializer) throws Exception {

     */
    public File getOriginalFile(long contextId, InstrumentationArtifactMetadata metadata) {
        String hash = metadata.getArtifactHash();
        String artifactName = metadata.getArtifactName();
        return checkNotNull(getResolutionData(contextId).getOriginalFile(metadata.getArtifactHash()),
            "Original file for artifact with name '%s' and hash '%s' does not exist! " +

            Set<String> artifactConfigurations = depArtifact.getConfigurations();
            if (include(artifactConfigurations, includedConfigurations)) {
                IvyArtifactName ivyArtifactName = depArtifact.getArtifactName();
                artifacts.add(ivyArtifactName);
            }
        }
        return artifacts.build();
    }

            consumerBuildPath,
            consumerProjectPath,
            componentId,
            sourceAttributes,
            targetAttributes,
            capabilities,
            artifact.getArtifactName().getDisplayName(),
            upstreamDependencies.getConfigurationIdentity(),
            transformStepNodeId
        );
    }

            return ComponentToOperationConverter.convertComponentIdentifier(componentIdentifier);
        }

        @Override
        public String getArtifactName() {
            return inputArtifact.getName();
        }

        @Override
        public Class<?> getTransformActionClass() {
            return transform.getImplementationClass();
        }