ModelSchemaAspectExtractionResult result = strategy.extract(extractionContext, propertyResults);
            if (result != null) {
                aspects.add(result.getAspect());
            }
        }
        return aspects;
    }

    private final ModelSchemaAspect aspect;

    public ModelSchemaAspectExtractionResult(ModelSchemaAspect aspect) {
        this.aspect = aspect;
    }

    public ModelSchemaAspect getAspect() {
        return aspect;
    }

    Set<WeaklyTypeReferencingMethod<?, ?>> getAllMethods();

    boolean hasAspect(Class<? extends ModelSchemaAspect> aspectType);

    <A extends ModelSchemaAspect> A getAspect(Class<A> aspectType);

    Collection<ModelSchemaAspect> getAspects();

        return aspects.containsKey(aspectType);
    }

    @Override
    public <A extends ModelSchemaAspect> A getAspect(Class<A> aspectType) {
        return Cast.uncheckedCast(aspects.get(aspectType));
    }

    @Override
    public Collection<ModelSchemaAspect> getAspects() {
        return aspects.values();
    }

        if (!(schema instanceof StructSchema)) {
            return;
        }
        Map<String, Object> variants = new TreeMap<>();
        VariantAspect variantAspect = ((StructSchema<?>) schema).getAspect(VariantAspect.class);
        if (variantAspect != null) {
            for (ModelProperty<?> property : variantAspect.getDimensions()) {
                variants.put(property.getName(), property.getPropertyValue(binary));

        when:
        def resultSchema = store.getSchema(MyTypeOfAspect)

        then:
        assert resultSchema instanceof StructSchema
        resultSchema.hasAspect(MyAspect)
        resultSchema.getAspect(MyAspect) == aspect

        1 * aspectExtractionStrategy.extract(_, _) >> { ModelSchemaExtractionContext<?> extractionContext, List<ModelPropertyExtractionResult> propertyResults ->

        }

        if (classLoaderStructure.getSpec() instanceof FilteringClassLoader.Spec) {
            encoder.writeByte(FILTERING_SPEC);
            filteringClassLoaderSpecSerializer.write(encoder, (FilteringClassLoader.Spec) classLoaderStructure.getSpec());
        } else if (classLoaderStructure.getSpec() instanceof VisitableURLClassLoader.Spec) {

type IstioKind struct {
	metav1.TypeMeta
	metav1.ObjectMeta `json:"metadata"`
	Spec              json.RawMessage  `json:"spec"`
	Status            *json.RawMessage `json:"status,omitempty"`
}

// GetSpec from a wrapper
func (in *IstioKind) GetSpec() json.RawMessage {
	return in.Spec
}

// GetStatus from a wrapper
func (in *IstioKind) GetStatus() *json.RawMessage {
	return in.Status
}

// GetObjectMeta from a wrapper

	"istio.io/istio/pkg/ptr"
)

func TestKind(t *testing.T) {
	obj := crd.IstioKind{}

	spec := json.RawMessage(`{"a":"b"}`)
	obj.Spec = spec
	if got := obj.GetSpec(); !reflect.DeepEqual(spec, got) {
		t.Errorf("GetSpec() => got %v, want %v", got, spec)
	}

	status := ptr.Of(json.RawMessage(`{"c":"d"}`))
	obj.Status = status
	if got := obj.GetStatus(); !reflect.DeepEqual(status, got) {

 * limitations under the License.
 */

package org.gradle.workers.internal;

import org.gradle.internal.classloader.ClassLoaderSpec;

public interface ClassLoaderStructure {
    ClassLoaderSpec getSpec();

    ClassLoaderStructure getParent();