eval  func(*State) (bool, error)
	usage CondUsage
}

func (c *funcCond) Usage() *CondUsage { return &c.usage }

func (c *funcCond) Eval(s *State, suffix string) (bool, error) {
	if suffix != "" {
		return false, ErrUsage
	}
	return c.eval(s)
}

// PrefixCondition returns a Cond with the given summary and evaluation function.
func PrefixCondition(summary string, eval func(*State, string) (bool, error)) Cond {

        this.timestamp = timestamp;
        this.usage = usage;
        this.count = count;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public MemoryUsage getUsage() {
        return usage;
    }

    public long getCount() {
        return count;
    }

            class MySoftwareComponent implements org.gradle.api.internal.component.SoftwareComponentInternal {
                String name = 'comp'
                Set<org.gradle.api.internal.component.UsageContext> getUsages() {
                    return Collections.emptySet()
                }
            }
            class MyComponentWithUsages extends MySoftwareComponent {
                static PublishArtifact publishedArtifact

import org.gradle.api.internal.attributes.ImmutableAttributes;

import java.util.Collections;
import java.util.Set;

/**
 * This extends {@link UsageContext} so that we can use it in {@link SoftwareComponentInternal#getUsages()}.
 * Once we remove {@link UsageContext}, this should implement {@link SoftwareComponentVariant} instead.
 */
public abstract class AbstractSoftwareComponentVariant implements UsageContext {

                if (memoryPoolMXBean.getType() == MemoryType.NON_HEAP && poolName.equals(nonHeapMemoryPool)) {
                    nonHeapEvents.slideAndInsert(new GarbageCollectionEvent(clock.getCurrentTime(), memoryPoolMXBean.getUsage(), -1));
                }
            }
        } catch (Throwable t) {
            // this class is used as task in a scheduled executor service, so it must not throw any throwable,

        return variants;
    }

    public void addVariant(SoftwareComponent variant) {
        variants.add(variant);
    }

    @Override
    public Set<? extends UsageContext> getUsages() {
        return ImmutableSet.of();
    }

    }

    @Override
    public String getName() {
        return "web";
    }

    @Override
    public Set<UsageContext> getUsages() {
        return Collections.singleton(variant);
    }

     * <p>
     * This method and {@link UsageContext} should both be deprecated in favor of a new public API.
     */
    Set<? extends UsageContext> getUsages();

        }
        variants.get(outgoingConfiguration).addAction(action);
    }

    @Override
    public Set<? extends UsageContext> getUsages() {
        if (cachedVariants == null) {
            ImmutableSet.Builder<UsageContext> builder = new ImmutableSet.Builder<>();
            for (ConfigurationVariantMapping variant : variants.values()) {

    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Set<? extends UsageContext> getUsages() {
        return ImmutableSet.of(new ConfigurationSoftwareComponentVariant(name, attributeContainer, artifacts, dependencies));
    }

    @Override
    public Set<? extends SoftwareComponent> getVariants() {