// cidr range allocator.
type CIDRAllocatorParams struct {
	// ClusterCIDRs is list of cluster cidrs.
	ClusterCIDRs []*net.IPNet
	// ServiceCIDR is primary service cidr for cluster.
	ServiceCIDR *net.IPNet
	// SecondaryServiceCIDR is secondary service cidr for cluster.
	SecondaryServiceCIDR *net.IPNet
	// NodeCIDRMaskSizes is list of node cidr mask sizes.
	NodeCIDRMaskSizes []int
}

// New creates a new CIDR range allocator.

			binary.BigEndian.PutUint64(ip[halfIPv6Len:], rightClusterIP)
		}
	}
	return &net.IPNet{
		IP:   ip,
		Mask: s.nodeMask,
	}
}

// AllocateNext allocates the next free CIDR range. This will set the range
// as occupied and return the allocated range.
func (s *CidrSet) AllocateNext() (*net.IPNet, error) {
	s.Lock()
	defer s.Unlock()

	if s.allocatedCIDRs == s.maxCIDRs {

	if err != nil {
		return ""
	}

	for _, address := range addrs {
		// check the address type and if it is not a loopback then return it
		if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
			if ipnet.IP.To4() != nil {
				return ipnet.IP.String()
			}
		}
	}
	return ""
}

type topic struct {
	Name string
	URL  string
}

func getTopics() []topic {

}

func createLegacyIPAM(
	ctx context.Context,
	ic *Controller,
	nodeInformer coreinformers.NodeInformer,
	cloud cloudprovider.Interface,
	kubeClient clientset.Interface,
	clusterCIDRs []*net.IPNet,
	serviceCIDR *net.IPNet,
	nodeCIDRMaskSizes []int,
) (*fakeController, error) {
	return nil, errors.New("Error trying to Init(): legacy cloud provider support disabled at build time")

        inputs.hasInputs
        !inputs.hasSourceFiles
    }

    def hasInputsWhenNonEmptyInputFilesRegistered() {
        when:
        inputs.files('a')

        then:
        inputs.hasInputs
        !inputs.hasSourceFiles
    }

    def hasInputsWhenInputPropertyRegistered() {
        when:
        inputs.property('a', 'value')

        then:
        inputs.hasInputs

    def "incremental task with NAME_ONLY inputs (matching file names and content) detects deleted file"() {
        def inputs = folderNames().collect { file("${it}/input.txt").createFile() }

        buildFile << incrementalTaskWithNameOnlyInputFiles(inputs)
        run INCREMENTAL_TASK_NAME

        when:
        inputs[1..2]*.delete()
        println "${inputs} exists: ${inputs*.exists()}"
        run INCREMENTAL_TASK_NAME, "--info"

    private final String[] inputs;

    private final String output;

    private String[] newInputs;

    private String newOutput;

    public CharMappingItem(final long id, final String[] inputs, final String output) {
        this.id = id;
        this.inputs = inputs;
        this.output = output == null ? null : output.replace("\n", " ");
        Arrays.sort(inputs);

        if (id == 0) {

		}
	}

	have4 := gaddr.IP.To4() != nil
	for _, addr := range addrs {
		if ipnet, ok := addr.(*IPNet); ok && (ipnet.IP.To4() != nil) == have4 {
			_, err = l.ctl.WriteString("addmulti " + ipnet.IP.String() + " " + gaddr.IP.String())
			if err != nil {
				return nil, &OpError{Op: "addmulti", Net: "", Source: nil, Addr: ipnet, Err: err}
			}
		}
	}
	l.data, err = os.OpenFile(l.dir+"/data", os.O_RDWR, 0)

    protected AbstractModelAction(ModelReference<T> subject, ModelRuleDescriptor descriptor, ModelReference<?>... inputs) {
        this(subject, descriptor, inputs == null ? EMPTY_MODEL_REF_LIST : Arrays.asList(inputs));
    }

    protected AbstractModelAction(ModelReference<T> subject, ModelRuleDescriptor descriptor, List<? extends ModelReference<?>> inputs) {

                action.execute(modelNode,
                    Cast.<I>uncheckedCast(inputs.get(0).getInstance()),
                    Cast.<J>uncheckedCast(inputs.get(1).getInstance())
                );
            }
        };
    }

    @Override
    public void execute(MutableModelNode modelNode, T view, List<ModelView<?>> inputs) {
        action.execute(modelNode, view, inputs);