private final long instanceId;
    private final T graphMetadata;
    private final AttributeDesugaring attributeDesugaring;

    public AbstractComponentGraphResolveState(long instanceId, T graphMetadata, AttributeDesugaring attributeDesugaring) {
        this.instanceId = instanceId;
        this.graphMetadata = graphMetadata;

    public DefaultIvyComponentGraphResolveState(long instanceId, IvyModuleResolveMetadata metadata, AttributeDesugaring attributeDesugaring, ComponentIdGenerator idGenerator) {
        super(instanceId, metadata, attributeDesugaring, idGenerator);
    }

    @Override
    public IvyComponentArtifactResolveMetadata getArtifactMetadata() {

    public DefaultModuleComponentGraphResolveState(long instanceId, M metadata, AttributeDesugaring attributeDesugaring, ComponentIdGenerator idGenerator) {
        super(instanceId, metadata, metadata, attributeDesugaring, idGenerator);
    }

    @Override
    public ModuleComponentIdentifier getId() {
        return getMetadata().getId();

    }

    private LenientPlatformGraphResolveState(long instanceId, LenientPlatformResolveMetadata metadata, ComponentIdGenerator componentIdGenerator, ResolveState resolveState) {
        super(instanceId, metadata, metadata, resolveState.getAttributeDesugaring(), componentIdGenerator);
        this.componentIdGenerator = componentIdGenerator;

	return newOption("nodeID", value)
}

func NodeType(value string) Instance {
	ntype := strings.Split(value, "~")[0]
	return newOption("nodeType", ntype)
}

func XdsType(value string) Instance {
	return newOption("xds_type", value)
}

func Region(value string) Instance {
	return newOptionOrSkipIfZero("region", value)
}

func Zone(value string) Instance {

			}
		}

		return outServices.Instances()
	}
}

func notRegularPods() Filter {
	return func(instances echo.Instances) echo.Instances {
		return match.NotRegularPod.GetMatches(instances)
	}
}

// FilterMatch returns a filter that simply applies the given matcher.
func FilterMatch(matcher match.Matcher) Filter {
	return func(instances echo.Instances) echo.Instances {
		return matcher.GetMatches(instances)

 *      interface Animal {}
 * </pre>
 * <p>
 * On the client-side we will be able to write code such as:
 * <pre>
 *      if (model instanceof Dog) {
 *          ((Dog) model).bark();
 *      } else if (model instanceof Cat) {
 *          ((Cat) model).meow();
 *      } else if (model instance of Bird) {
 *          // will never be true, Bird is not specified as a model contract type
 *      }
 * </pre>
 *
 * @since 8.9
 */

	return func(i echo.Instance) bool {
		return n == i.NamespacedName()
	}
}

// AnyServiceName matches instances if they have the same Service and Namespace as any of the provided instances.
func AnyServiceName(expected echo.NamespacedNames) Matcher {
	return func(instance echo.Instance) bool {
		serviceName := instance.NamespacedName()
		for _, expectedName := range expected {
			if serviceName == expectedName {

			continue
		}
		if _, f := s.instances[ikey]; !f {
			s.instances[ikey] = map[configKeyWithParent][]*model.ServiceInstance{}
		}
		s.instancesByHostAndPort.Insert(hostPort)
		s.instances[ikey][key] = append(s.instances[ikey][key], instance)
		if instance.Endpoint.Address != "" {
			s.ip2instance[instance.Endpoint.Address] = append(s.ip2instance[instance.Endpoint.Address], instance)
		}
	}
}

class WriteIdentities {

    private
    val instanceIds = IdentityHashMap<Any, Int>()

    fun getId(instance: Any) = instanceIds[instance]

    fun putInstance(instance: Any): Int {
        val id = instanceIds.size
        instanceIds[instance] = id
        return id
    }
}


class ReadIdentities {

    private
    val instanceIds = HashMap<Int, Any>()