jkawamoto/roadie

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
    "encoding/json"

    strfmt "github.com/go-openapi/strfmt"
    "github.com/go-openapi/swag"

    "github.com/go-openapi/errors"
    "github.com/go-openapi/validate"
)

// ImageOSDisk Describes an Operating System disk.
// swagger:model ImageOSDisk
type ImageOSDisk struct {

    // The Virtual Hard Disk.
    BlobURI string `json:"blobUri,omitempty"`

    // The caching type.
    Caching string `json:"caching,omitempty"`

    // The initial managed disk size in GB for blank data disks, and the new desired size for existing OS and Data disks.
    DiskSizeGB int32 `json:"diskSizeGB,omitempty"`

    // The managedDisk.
    ManagedDisk *SubResource `json:"managedDisk,omitempty"`

    // The OS State.
    // Required: true
    OsState *string `json:"osState"`

    // The Operating System type.
    // Required: true
    OsType *string `json:"osType"`

    // The snapshot.
    Snapshot *SubResource `json:"snapshot,omitempty"`
}

// Validate validates this image o s disk
func (m *ImageOSDisk) Validate(formats strfmt.Registry) error {
    var res []error

    if err := m.validateCaching(formats); err != nil {
        // prop
        res = append(res, err)
    }

    if err := m.validateManagedDisk(formats); err != nil {
        // prop
        res = append(res, err)
    }

    if err := m.validateOsState(formats); err != nil {
        // prop
        res = append(res, err)
    }

    if err := m.validateOsType(formats); err != nil {
        // prop
        res = append(res, err)
    }

    if err := m.validateSnapshot(formats); err != nil {
        // prop
        res = append(res, err)
    }

    if len(res) > 0 {
        return errors.CompositeValidationError(res...)
    }
    return nil
}

var imageOSDiskTypeCachingPropEnum []interface{}

func init() {
    var res []string
    if err := json.Unmarshal([]byte(`["None","ReadOnly","ReadWrite"]`), &res); err != nil {
        panic(err)
    }
    for _, v := range res {
        imageOSDiskTypeCachingPropEnum = append(imageOSDiskTypeCachingPropEnum, v)
    }
}

const (
    // ImageOSDiskCachingNone captures enum value "None"
    ImageOSDiskCachingNone string = "None"
    // ImageOSDiskCachingReadOnly captures enum value "ReadOnly"
    ImageOSDiskCachingReadOnly string = "ReadOnly"
    // ImageOSDiskCachingReadWrite captures enum value "ReadWrite"
    ImageOSDiskCachingReadWrite string = "ReadWrite"
)

// prop value enum
func (m *ImageOSDisk) validateCachingEnum(path, location string, value string) error {
    if err := validate.Enum(path, location, value, imageOSDiskTypeCachingPropEnum); err != nil {
        return err
    }
    return nil
}

func (m *ImageOSDisk) validateCaching(formats strfmt.Registry) error {

    if swag.IsZero(m.Caching) { // not required
        return nil
    }

    // value enum
    if err := m.validateCachingEnum("caching", "body", m.Caching); err != nil {
        return err
    }

    return nil
}

func (m *ImageOSDisk) validateManagedDisk(formats strfmt.Registry) error {

    if swag.IsZero(m.ManagedDisk) { // not required
        return nil
    }

    if m.ManagedDisk != nil {

        if err := m.ManagedDisk.Validate(formats); err != nil {
            return err
        }
    }

    return nil
}

var imageOSDiskTypeOsStatePropEnum []interface{}

func init() {
    var res []string
    if err := json.Unmarshal([]byte(`["Generalized","Specialized"]`), &res); err != nil {
        panic(err)
    }
    for _, v := range res {
        imageOSDiskTypeOsStatePropEnum = append(imageOSDiskTypeOsStatePropEnum, v)
    }
}

const (
    // ImageOSDiskOsStateGeneralized captures enum value "Generalized"
    ImageOSDiskOsStateGeneralized string = "Generalized"
    // ImageOSDiskOsStateSpecialized captures enum value "Specialized"
    ImageOSDiskOsStateSpecialized string = "Specialized"
)

// prop value enum
func (m *ImageOSDisk) validateOsStateEnum(path, location string, value string) error {
    if err := validate.Enum(path, location, value, imageOSDiskTypeOsStatePropEnum); err != nil {
        return err
    }
    return nil
}

func (m *ImageOSDisk) validateOsState(formats strfmt.Registry) error {

    if err := validate.Required("osState", "body", m.OsState); err != nil {
        return err
    }

    // value enum
    if err := m.validateOsStateEnum("osState", "body", *m.OsState); err != nil {
        return err
    }

    return nil
}

var imageOSDiskTypeOsTypePropEnum []interface{}

func init() {
    var res []string
    if err := json.Unmarshal([]byte(`["Windows","Linux"]`), &res); err != nil {
        panic(err)
    }
    for _, v := range res {
        imageOSDiskTypeOsTypePropEnum = append(imageOSDiskTypeOsTypePropEnum, v)
    }
}

const (
    // ImageOSDiskOsTypeWindows captures enum value "Windows"
    ImageOSDiskOsTypeWindows string = "Windows"
    // ImageOSDiskOsTypeLinux captures enum value "Linux"
    ImageOSDiskOsTypeLinux string = "Linux"
)

// prop value enum
func (m *ImageOSDisk) validateOsTypeEnum(path, location string, value string) error {
    if err := validate.Enum(path, location, value, imageOSDiskTypeOsTypePropEnum); err != nil {
        return err
    }
    return nil
}

func (m *ImageOSDisk) validateOsType(formats strfmt.Registry) error {

    if err := validate.Required("osType", "body", m.OsType); err != nil {
        return err
    }

    // value enum
    if err := m.validateOsTypeEnum("osType", "body", *m.OsType); err != nil {
        return err
    }

    return nil
}

func (m *ImageOSDisk) validateSnapshot(formats strfmt.Registry) error {

    if swag.IsZero(m.Snapshot) { // not required
        return nil
    }

    if m.Snapshot != nil {

        if err := m.Snapshot.Validate(formats); err != nil {
            return err
        }
    }

    return nil
}