org.ovirt.engine.sdk4.internal.containers.VmContainer 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.lang.String;
import java.util.Date;
import java.util.List;
import org.ovirt.engine.sdk4.types.AffinityLabel;
import org.ovirt.engine.sdk4.types.Application;
import org.ovirt.engine.sdk4.types.Cdrom;
import org.ovirt.engine.sdk4.types.DiskAttachment;
import org.ovirt.engine.sdk4.types.ExternalHostProvider;
import org.ovirt.engine.sdk4.types.Floppy;
import org.ovirt.engine.sdk4.types.GraphicsConsole;
import org.ovirt.engine.sdk4.types.GuestOperatingSystem;
import org.ovirt.engine.sdk4.types.Host;
import org.ovirt.engine.sdk4.types.HostDevice;
import org.ovirt.engine.sdk4.types.InstanceType;
import org.ovirt.engine.sdk4.types.KatelloErratum;
import org.ovirt.engine.sdk4.types.Nic;
import org.ovirt.engine.sdk4.types.NumaNode;
import org.ovirt.engine.sdk4.types.NumaTuneMode;
import org.ovirt.engine.sdk4.types.Payload;
import org.ovirt.engine.sdk4.types.Permission;
import org.ovirt.engine.sdk4.types.ReportedDevice;
import org.ovirt.engine.sdk4.types.Session;
import org.ovirt.engine.sdk4.types.Snapshot;
import org.ovirt.engine.sdk4.types.Statistic;
import org.ovirt.engine.sdk4.types.Tag;
import org.ovirt.engine.sdk4.types.Template;
import org.ovirt.engine.sdk4.types.TimeZone;
import org.ovirt.engine.sdk4.types.Vm;
import org.ovirt.engine.sdk4.types.VmPlacementPolicy;
import org.ovirt.engine.sdk4.types.VmPool;
import org.ovirt.engine.sdk4.types.VmStatus;
import org.ovirt.engine.sdk4.types.Watchdog;

public class VmContainer extends VmBaseContainer implements Vm {
    private String fqdn;
    private GuestOperatingSystem guestOperatingSystem;
    private TimeZone guestTimeZone;
    private Boolean nextRunConfigurationExists;
    private NumaTuneMode numaTuneMode;
    private List payloads;
    private VmPlacementPolicy placementPolicy;
    private Boolean runOnce;
    private Date startTime;
    private VmStatus status;
    private String statusDetail;
    private String stopReason;
    private Date stopTime;
    private Boolean useLatestTemplateVersion;
    private List affinityLabels;
    private List applications;
    private List cdroms;
    private List diskAttachments;
    private ExternalHostProvider externalHostProvider;
    private List floppies;
    private List graphicsConsoles;
    private Host host;
    private List hostDevices;
    private InstanceType instanceType;
    private List katelloErrata;
    private List nics;
    private List numaNodes;
    private Template originalTemplate;
    private List permissions;
    private List reportedDevices;
    private List sessions;
    private List snapshots;
    private List statistics;
    private List tags;
    private Template template;
    private VmPool vmPool;
    private List watchdogs;
    
    public String fqdn() {
        return fqdn;
    }
    
    public void fqdn(String newFqdn) {
        fqdn = newFqdn;
    }
    
    public boolean fqdnPresent() {
        return fqdn != null;
    }
    
    public GuestOperatingSystem guestOperatingSystem() {
        return guestOperatingSystem;
    }
    
    public void guestOperatingSystem(GuestOperatingSystem newGuestOperatingSystem) {
        guestOperatingSystem = newGuestOperatingSystem;
    }
    
    public boolean guestOperatingSystemPresent() {
        return guestOperatingSystem != null;
    }
    
    public TimeZone guestTimeZone() {
        return guestTimeZone;
    }
    
    public void guestTimeZone(TimeZone newGuestTimeZone) {
        guestTimeZone = newGuestTimeZone;
    }
    
    public boolean guestTimeZonePresent() {
        return guestTimeZone != null;
    }
    
    public boolean nextRunConfigurationExists() {
        return nextRunConfigurationExists;
    }
    
    public void nextRunConfigurationExists(boolean newNextRunConfigurationExists) {
        nextRunConfigurationExists = Boolean.valueOf(newNextRunConfigurationExists);
    }
    
    public void nextRunConfigurationExists(Boolean newNextRunConfigurationExists) {
        nextRunConfigurationExists = newNextRunConfigurationExists;
    }
    
    public boolean nextRunConfigurationExistsPresent() {
        return nextRunConfigurationExists != null;
    }
    
    public NumaTuneMode numaTuneMode() {
        return numaTuneMode;
    }
    
    public void numaTuneMode(NumaTuneMode newNumaTuneMode) {
        numaTuneMode = newNumaTuneMode;
    }
    
    public boolean numaTuneModePresent() {
        return numaTuneMode != null;
    }
    
    public List payloads() {
        return makeUnmodifiableList(payloads);
    }
    
    public void payloads(List newPayloads) {
        payloads = makeArrayList(newPayloads);
    }
    
    public boolean payloadsPresent() {
        return payloads != null && !payloads.isEmpty();
    }
    
    public VmPlacementPolicy placementPolicy() {
        return placementPolicy;
    }
    
    public void placementPolicy(VmPlacementPolicy newPlacementPolicy) {
        placementPolicy = newPlacementPolicy;
    }
    
    public boolean placementPolicyPresent() {
        return placementPolicy != null;
    }
    
    public boolean runOnce() {
        return runOnce;
    }
    
    public void runOnce(boolean newRunOnce) {
        runOnce = Boolean.valueOf(newRunOnce);
    }
    
    public void runOnce(Boolean newRunOnce) {
        runOnce = newRunOnce;
    }
    
    public boolean runOncePresent() {
        return runOnce != null;
    }
    
    public Date startTime() {
        if (startTime == null) {
            return null;
        }
        else {
            return new Date(startTime.getTime());
        }
    }
    
    public void startTime(Date newStartTime) {
        if (newStartTime == null) {
            startTime = null;
        }
        else {
            startTime = new Date(newStartTime.getTime());
        }
    }
    
    public boolean startTimePresent() {
        return startTime != null;
    }
    
    public VmStatus status() {
        return status;
    }
    
    public void status(VmStatus newStatus) {
        status = newStatus;
    }
    
    public boolean statusPresent() {
        return status != null;
    }
    
    public String statusDetail() {
        return statusDetail;
    }
    
    public void statusDetail(String newStatusDetail) {
        statusDetail = newStatusDetail;
    }
    
    public boolean statusDetailPresent() {
        return statusDetail != null;
    }
    
    public String stopReason() {
        return stopReason;
    }
    
    public void stopReason(String newStopReason) {
        stopReason = newStopReason;
    }
    
    public boolean stopReasonPresent() {
        return stopReason != null;
    }
    
    public Date stopTime() {
        if (stopTime == null) {
            return null;
        }
        else {
            return new Date(stopTime.getTime());
        }
    }
    
    public void stopTime(Date newStopTime) {
        if (newStopTime == null) {
            stopTime = null;
        }
        else {
            stopTime = new Date(newStopTime.getTime());
        }
    }
    
    public boolean stopTimePresent() {
        return stopTime != null;
    }
    
    public boolean useLatestTemplateVersion() {
        return useLatestTemplateVersion;
    }
    
    public void useLatestTemplateVersion(boolean newUseLatestTemplateVersion) {
        useLatestTemplateVersion = Boolean.valueOf(newUseLatestTemplateVersion);
    }
    
    public void useLatestTemplateVersion(Boolean newUseLatestTemplateVersion) {
        useLatestTemplateVersion = newUseLatestTemplateVersion;
    }
    
    public boolean useLatestTemplateVersionPresent() {
        return useLatestTemplateVersion != null;
    }
    
    public List affinityLabels() {
        return makeUnmodifiableList(affinityLabels);
    }
    
    public void affinityLabels(List newAffinityLabels) {
        affinityLabels = makeArrayList(newAffinityLabels);
    }
    
    public boolean affinityLabelsPresent() {
        return affinityLabels != null && !affinityLabels.isEmpty();
    }
    
    public List applications() {
        return makeUnmodifiableList(applications);
    }
    
    public void applications(List newApplications) {
        applications = makeArrayList(newApplications);
    }
    
    public boolean applicationsPresent() {
        return applications != null && !applications.isEmpty();
    }
    
    public List cdroms() {
        return makeUnmodifiableList(cdroms);
    }
    
    public void cdroms(List newCdroms) {
        cdroms = makeArrayList(newCdroms);
    }
    
    public boolean cdromsPresent() {
        return cdroms != null && !cdroms.isEmpty();
    }
    
    public List diskAttachments() {
        return makeUnmodifiableList(diskAttachments);
    }
    
    public void diskAttachments(List newDiskAttachments) {
        diskAttachments = makeArrayList(newDiskAttachments);
    }
    
    public boolean diskAttachmentsPresent() {
        return diskAttachments != null && !diskAttachments.isEmpty();
    }
    
    public ExternalHostProvider externalHostProvider() {
        return externalHostProvider;
    }
    
    public void externalHostProvider(ExternalHostProvider newExternalHostProvider) {
        externalHostProvider = newExternalHostProvider;
    }
    
    public boolean externalHostProviderPresent() {
        return externalHostProvider != null;
    }
    
    public List floppies() {
        return makeUnmodifiableList(floppies);
    }
    
    public void floppies(List newFloppies) {
        floppies = makeArrayList(newFloppies);
    }
    
    public boolean floppiesPresent() {
        return floppies != null && !floppies.isEmpty();
    }
    
    public List graphicsConsoles() {
        return makeUnmodifiableList(graphicsConsoles);
    }
    
    public void graphicsConsoles(List newGraphicsConsoles) {
        graphicsConsoles = makeArrayList(newGraphicsConsoles);
    }
    
    public boolean graphicsConsolesPresent() {
        return graphicsConsoles != null && !graphicsConsoles.isEmpty();
    }
    
    public Host host() {
        return host;
    }
    
    public void host(Host newHost) {
        host = newHost;
    }
    
    public boolean hostPresent() {
        return host != null;
    }
    
    public List hostDevices() {
        return makeUnmodifiableList(hostDevices);
    }
    
    public void hostDevices(List newHostDevices) {
        hostDevices = makeArrayList(newHostDevices);
    }
    
    public boolean hostDevicesPresent() {
        return hostDevices != null && !hostDevices.isEmpty();
    }
    
    public InstanceType instanceType() {
        return instanceType;
    }
    
    public void instanceType(InstanceType newInstanceType) {
        instanceType = newInstanceType;
    }
    
    public boolean instanceTypePresent() {
        return instanceType != null;
    }
    
    public List katelloErrata() {
        return makeUnmodifiableList(katelloErrata);
    }
    
    public void katelloErrata(List newKatelloErrata) {
        katelloErrata = makeArrayList(newKatelloErrata);
    }
    
    public boolean katelloErrataPresent() {
        return katelloErrata != null && !katelloErrata.isEmpty();
    }
    
    public List nics() {
        return makeUnmodifiableList(nics);
    }
    
    public void nics(List newNics) {
        nics = makeArrayList(newNics);
    }
    
    public boolean nicsPresent() {
        return nics != null && !nics.isEmpty();
    }
    
    public List numaNodes() {
        return makeUnmodifiableList(numaNodes);
    }
    
    public void numaNodes(List newNumaNodes) {
        numaNodes = makeArrayList(newNumaNodes);
    }
    
    public boolean numaNodesPresent() {
        return numaNodes != null && !numaNodes.isEmpty();
    }
    
    public Template originalTemplate() {
        return originalTemplate;
    }
    
    public void originalTemplate(Template newOriginalTemplate) {
        originalTemplate = newOriginalTemplate;
    }
    
    public boolean originalTemplatePresent() {
        return originalTemplate != null;
    }
    
    public List permissions() {
        return makeUnmodifiableList(permissions);
    }
    
    public void permissions(List newPermissions) {
        permissions = makeArrayList(newPermissions);
    }
    
    public boolean permissionsPresent() {
        return permissions != null && !permissions.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 sessions() {
        return makeUnmodifiableList(sessions);
    }
    
    public void sessions(List newSessions) {
        sessions = makeArrayList(newSessions);
    }
    
    public boolean sessionsPresent() {
        return sessions != null && !sessions.isEmpty();
    }
    
    public List snapshots() {
        return makeUnmodifiableList(snapshots);
    }
    
    public void snapshots(List newSnapshots) {
        snapshots = makeArrayList(newSnapshots);
    }
    
    public boolean snapshotsPresent() {
        return snapshots != null && !snapshots.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 tags() {
        return makeUnmodifiableList(tags);
    }
    
    public void tags(List newTags) {
        tags = makeArrayList(newTags);
    }
    
    public boolean tagsPresent() {
        return tags != null && !tags.isEmpty();
    }
    
    public Template template() {
        return template;
    }
    
    public void template(Template newTemplate) {
        template = newTemplate;
    }
    
    public boolean templatePresent() {
        return template != null;
    }
    
    public VmPool vmPool() {
        return vmPool;
    }
    
    public void vmPool(VmPool newVmPool) {
        vmPool = newVmPool;
    }
    
    public boolean vmPoolPresent() {
        return vmPool != null;
    }
    
    public List watchdogs() {
        return makeUnmodifiableList(watchdogs);
    }
    
    public void watchdogs(List newWatchdogs) {
        watchdogs = makeArrayList(newWatchdogs);
    }
    
    public boolean watchdogsPresent() {
        return watchdogs != null && !watchdogs.isEmpty();
    }
    
}