org.ovirt.engine.sdk4.internal.containers.NicContainer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sdk Show documentation
There is a newer version: 4.5.1
/*
Copyright (c) 2015 Red Hat, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package org.ovirt.engine.sdk4.internal.containers;

import java.lang.Boolean;
import java.util.List;
import org.ovirt.engine.sdk4.types.BootProtocol;
import org.ovirt.engine.sdk4.types.Mac;
import org.ovirt.engine.sdk4.types.Network;
import org.ovirt.engine.sdk4.types.NetworkAttachment;
import org.ovirt.engine.sdk4.types.NetworkLabel;
import org.ovirt.engine.sdk4.types.Nic;
import org.ovirt.engine.sdk4.types.NicInterface;
import org.ovirt.engine.sdk4.types.ReportedDevice;
import org.ovirt.engine.sdk4.types.Statistic;
import org.ovirt.engine.sdk4.types.VnicProfile;

public class NicContainer extends DeviceContainer implements Nic {
    private BootProtocol bootProtocol;
    private NicInterface interface_;
    private Boolean linked;
    private Mac mac;
    private Boolean onBoot;
    private Boolean plugged;
    private Network network;
    private List networkAttachments;
    private List networkLabels;
    private List reportedDevices;
    private List statistics;
    private List virtualFunctionAllowedLabels;
    private List virtualFunctionAllowedNetworks;
    private VnicProfile vnicProfile;
    
    public BootProtocol bootProtocol() {
        return bootProtocol;
    }
    
    public void bootProtocol(BootProtocol newBootProtocol) {
        bootProtocol = newBootProtocol;
    }
    
    public boolean bootProtocolPresent() {
        return bootProtocol != null;
    }
    
    public NicInterface interface_() {
        return interface_;
    }
    
    public void interface_(NicInterface newInterface) {
        interface_ = newInterface;
    }
    
    public boolean interface_Present() {
        return interface_ != null;
    }
    
    public boolean linked() {
        return linked;
    }
    
    public void linked(boolean newLinked) {
        linked = Boolean.valueOf(newLinked);
    }
    
    public void linked(Boolean newLinked) {
        linked = newLinked;
    }
    
    public boolean linkedPresent() {
        return linked != null;
    }
    
    public Mac mac() {
        return mac;
    }
    
    public void mac(Mac newMac) {
        mac = newMac;
    }
    
    public boolean macPresent() {
        return mac != null;
    }
    
    public boolean onBoot() {
        return onBoot;
    }
    
    public void onBoot(boolean newOnBoot) {
        onBoot = Boolean.valueOf(newOnBoot);
    }
    
    public void onBoot(Boolean newOnBoot) {
        onBoot = newOnBoot;
    }
    
    public boolean onBootPresent() {
        return onBoot != null;
    }
    
    public boolean plugged() {
        return plugged;
    }
    
    public void plugged(boolean newPlugged) {
        plugged = Boolean.valueOf(newPlugged);
    }
    
    public void plugged(Boolean newPlugged) {
        plugged = newPlugged;
    }
    
    public boolean pluggedPresent() {
        return plugged != null;
    }
    
    public Network network() {
        return network;
    }
    
    public void network(Network newNetwork) {
        network = newNetwork;
    }
    
    public boolean networkPresent() {
        return network != null;
    }
    
    public List networkAttachments() {
        return makeUnmodifiableList(networkAttachments);
    }
    
    public void networkAttachments(List newNetworkAttachments) {
        networkAttachments = makeArrayList(newNetworkAttachments);
    }
    
    public boolean networkAttachmentsPresent() {
        return networkAttachments != null && !networkAttachments.isEmpty();
    }
    
    public List networkLabels() {
        return makeUnmodifiableList(networkLabels);
    }
    
    public void networkLabels(List newNetworkLabels) {
        networkLabels = makeArrayList(newNetworkLabels);
    }
    
    public boolean networkLabelsPresent() {
        return networkLabels != null && !networkLabels.isEmpty();
    }
    
    public List reportedDevices() {
        return makeUnmodifiableList(reportedDevices);
    }
    
    public void reportedDevices(List newReportedDevices) {
        reportedDevices = makeArrayList(newReportedDevices);
    }
    
    public boolean reportedDevicesPresent() {
        return reportedDevices != null && !reportedDevices.isEmpty();
    }
    
    public List statistics() {
        return makeUnmodifiableList(statistics);
    }
    
    public void statistics(List newStatistics) {
        statistics = makeArrayList(newStatistics);
    }
    
    public boolean statisticsPresent() {
        return statistics != null && !statistics.isEmpty();
    }
    
    public List virtualFunctionAllowedLabels() {
        return makeUnmodifiableList(virtualFunctionAllowedLabels);
    }
    
    public void virtualFunctionAllowedLabels(List newVirtualFunctionAllowedLabels) {
        virtualFunctionAllowedLabels = makeArrayList(newVirtualFunctionAllowedLabels);
    }
    
    public boolean virtualFunctionAllowedLabelsPresent() {
        return virtualFunctionAllowedLabels != null && !virtualFunctionAllowedLabels.isEmpty();
    }
    
    public List virtualFunctionAllowedNetworks() {
        return makeUnmodifiableList(virtualFunctionAllowedNetworks);
    }
    
    public void virtualFunctionAllowedNetworks(List newVirtualFunctionAllowedNetworks) {
        virtualFunctionAllowedNetworks = makeArrayList(newVirtualFunctionAllowedNetworks);
    }
    
    public boolean virtualFunctionAllowedNetworksPresent() {
        return virtualFunctionAllowedNetworks != null && !virtualFunctionAllowedNetworks.isEmpty();
    }
    
    public VnicProfile vnicProfile() {
        return vnicProfile;
    }
    
    public void vnicProfile(VnicProfile newVnicProfile) {
        vnicProfile = newVnicProfile;
    }
    
    public boolean vnicProfilePresent() {
        return vnicProfile != null;
    }
    
}