• Home
• org.ovirt.engine.api
• sdk
• 4.4.0
• source code
• GlusterVolumeContainer.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

/*
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.math.BigInteger;
import java.util.List;
import org.ovirt.engine.sdk4.types.Cluster;
import org.ovirt.engine.sdk4.types.GlusterBrick;
import org.ovirt.engine.sdk4.types.GlusterVolume;
import org.ovirt.engine.sdk4.types.GlusterVolumeStatus;
import org.ovirt.engine.sdk4.types.GlusterVolumeType;
import org.ovirt.engine.sdk4.types.Option;
import org.ovirt.engine.sdk4.types.Statistic;
import org.ovirt.engine.sdk4.types.TransportType;

public class GlusterVolumeContainer extends IdentifiedContainer implements GlusterVolume {
    private BigInteger disperseCount;
    private List options;
    private BigInteger redundancyCount;
    private BigInteger replicaCount;
    private GlusterVolumeStatus status;
    private BigInteger stripeCount;
    private List transportTypes;
    private GlusterVolumeType volumeType;
    private List bricks;
    private Cluster cluster;
    private List statistics;
    
    public BigInteger disperseCount() {
        return disperseCount;
    }
    
    public Byte disperseCountAsByte() {
        return asByte("GlusterVolume", "disperseCount", disperseCount);
    }
    
    public Short disperseCountAsShort() {
        return asShort("GlusterVolume", "disperseCount", disperseCount);
    }
    
    public Integer disperseCountAsInteger() {
        return asInteger("GlusterVolume", "disperseCount", disperseCount);
    }
    
    public Long disperseCountAsLong() {
        return asLong("GlusterVolume", "disperseCount", disperseCount);
    }
    
    public void disperseCount(BigInteger newDisperseCount) {
        disperseCount = newDisperseCount;
    }
    
    public boolean disperseCountPresent() {
        return disperseCount != null;
    }
    
    public List options() {
        return makeUnmodifiableList(options);
    }
    
    public void options(List newOptions) {
        options = makeArrayList(newOptions);
    }
    
    public boolean optionsPresent() {
        return options != null && !options.isEmpty();
    }
    
    public BigInteger redundancyCount() {
        return redundancyCount;
    }
    
    public Byte redundancyCountAsByte() {
        return asByte("GlusterVolume", "redundancyCount", redundancyCount);
    }
    
    public Short redundancyCountAsShort() {
        return asShort("GlusterVolume", "redundancyCount", redundancyCount);
    }
    
    public Integer redundancyCountAsInteger() {
        return asInteger("GlusterVolume", "redundancyCount", redundancyCount);
    }
    
    public Long redundancyCountAsLong() {
        return asLong("GlusterVolume", "redundancyCount", redundancyCount);
    }
    
    public void redundancyCount(BigInteger newRedundancyCount) {
        redundancyCount = newRedundancyCount;
    }
    
    public boolean redundancyCountPresent() {
        return redundancyCount != null;
    }
    
    public BigInteger replicaCount() {
        return replicaCount;
    }
    
    public Byte replicaCountAsByte() {
        return asByte("GlusterVolume", "replicaCount", replicaCount);
    }
    
    public Short replicaCountAsShort() {
        return asShort("GlusterVolume", "replicaCount", replicaCount);
    }
    
    public Integer replicaCountAsInteger() {
        return asInteger("GlusterVolume", "replicaCount", replicaCount);
    }
    
    public Long replicaCountAsLong() {
        return asLong("GlusterVolume", "replicaCount", replicaCount);
    }
    
    public void replicaCount(BigInteger newReplicaCount) {
        replicaCount = newReplicaCount;
    }
    
    public boolean replicaCountPresent() {
        return replicaCount != null;
    }
    
    public GlusterVolumeStatus status() {
        return status;
    }
    
    public void status(GlusterVolumeStatus newStatus) {
        status = newStatus;
    }
    
    public boolean statusPresent() {
        return status != null;
    }
    
    public BigInteger stripeCount() {
        return stripeCount;
    }
    
    public Byte stripeCountAsByte() {
        return asByte("GlusterVolume", "stripeCount", stripeCount);
    }
    
    public Short stripeCountAsShort() {
        return asShort("GlusterVolume", "stripeCount", stripeCount);
    }
    
    public Integer stripeCountAsInteger() {
        return asInteger("GlusterVolume", "stripeCount", stripeCount);
    }
    
    public Long stripeCountAsLong() {
        return asLong("GlusterVolume", "stripeCount", stripeCount);
    }
    
    public void stripeCount(BigInteger newStripeCount) {
        stripeCount = newStripeCount;
    }
    
    public boolean stripeCountPresent() {
        return stripeCount != null;
    }
    
    public List transportTypes() {
        return makeUnmodifiableList(transportTypes);
    }
    
    public void transportTypes(List newTransportTypes) {
        transportTypes = makeArrayList(newTransportTypes);
    }
    
    public boolean transportTypesPresent() {
        return transportTypes != null && !transportTypes.isEmpty();
    }
    
    public GlusterVolumeType volumeType() {
        return volumeType;
    }
    
    public void volumeType(GlusterVolumeType newVolumeType) {
        volumeType = newVolumeType;
    }
    
    public boolean volumeTypePresent() {
        return volumeType != null;
    }
    
    public List bricks() {
        return makeUnmodifiableList(bricks);
    }
    
    public void bricks(List newBricks) {
        bricks = makeArrayList(newBricks);
    }
    
    public boolean bricksPresent() {
        return bricks != null && !bricks.isEmpty();
    }
    
    public Cluster cluster() {
        return cluster;
    }
    
    public void cluster(Cluster newCluster) {
        cluster = newCluster;
    }
    
    public boolean clusterPresent() {
        return cluster != null;
    }
    
    public List statistics() {
        return makeUnmodifiableList(statistics);
    }
    
    public void statistics(List newStatistics) {
        statistics = makeArrayList(newStatistics);
    }
    
    public boolean statisticsPresent() {
        return statistics != null && !statistics.isEmpty();
    }
    
}