# frozen_string_literal: true # #Kubernetes # # No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # # The version of the OpenAPI document: unversioned # # Generated by: https://openapi-generator.tech # OpenAPI Generator version: 6.5.0-SNAPSHOT # require 'date' require 'time' module Zilla # StatefulSetStatus represents the current state of a StatefulSet. class IoK8sApiAppsV1StatefulSetStatus # Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset. attr_accessor :available_replicas # collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. attr_accessor :collision_count # Represents the latest available observations of a statefulset's current state. attr_accessor :conditions # currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision. attr_accessor :current_replicas # currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas). attr_accessor :current_revision # observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server. attr_accessor :observed_generation # readyReplicas is the number of pods created for this StatefulSet with a Ready Condition. attr_accessor :ready_replicas # replicas is the number of Pods created by the StatefulSet controller. attr_accessor :replicas # updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas) attr_accessor :update_revision # updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision. attr_accessor :updated_replicas # Attribute mapping from ruby-style variable name to JSON key. def self.attribute_map { available_replicas: :availableReplicas, collision_count: :collisionCount, conditions: :conditions, current_replicas: :currentReplicas, current_revision: :currentRevision, observed_generation: :observedGeneration, ready_replicas: :readyReplicas, replicas: :replicas, update_revision: :updateRevision, updated_replicas: :updatedReplicas } end # Returns all the JSON keys this model knows about def self.acceptable_attributes attribute_map.values end # Attribute type mapping. def self.openapi_types { available_replicas: :Integer, collision_count: :Integer, conditions: :'Array<IoK8sApiAppsV1StatefulSetCondition>', current_replicas: :Integer, current_revision: :String, observed_generation: :Integer, ready_replicas: :Integer, replicas: :Integer, update_revision: :String, updated_replicas: :Integer } end # List of attributes with nullable: true def self.openapi_nullable Set.new([]) end # Initializes the object # @param [Hash] attributes Model attributes in the form of hash def initialize(attributes = {}) unless attributes.is_a?(Hash) raise ArgumentError, 'The input argument (attributes) must be a hash in `Zilla::IoK8sApiAppsV1StatefulSetStatus` initialize method' end # check to see if the attribute exists and convert string to symbol for hash key attributes = attributes.each_with_object({}) do |(k, v), h| unless self.class.attribute_map.key?(k.to_sym) raise ArgumentError, "`#{k}` is not a valid attribute in `Zilla::IoK8sApiAppsV1StatefulSetStatus`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect end h[k.to_sym] = v end self.available_replicas = attributes[:available_replicas] if attributes.key?(:available_replicas) self.collision_count = attributes[:collision_count] if attributes.key?(:collision_count) if attributes.key?(:conditions) && (value = attributes[:conditions]).is_a?(Array) self.conditions = value end self.current_replicas = attributes[:current_replicas] if attributes.key?(:current_replicas) self.current_revision = attributes[:current_revision] if attributes.key?(:current_revision) self.observed_generation = attributes[:observed_generation] if attributes.key?(:observed_generation) self.ready_replicas = attributes[:ready_replicas] if attributes.key?(:ready_replicas) self.replicas = attributes[:replicas] if attributes.key?(:replicas) self.update_revision = attributes[:update_revision] if attributes.key?(:update_revision) return unless attributes.key?(:updated_replicas) self.updated_replicas = attributes[:updated_replicas] end # Show invalid properties with the reasons. Usually used together with valid? # @return Array for valid properties with the reasons def list_invalid_properties invalid_properties = [] invalid_properties.push('invalid value for "replicas", replicas cannot be nil.') if @replicas.nil? invalid_properties end # Check to see if the all the properties in the model are valid # @return true if the model is valid def valid? return false if @replicas.nil? true end # Checks equality by comparing each attribute. # @param [Object] Object to be compared def ==(other) return true if equal?(other) self.class == other.class && available_replicas == other.available_replicas && collision_count == other.collision_count && conditions == other.conditions && current_replicas == other.current_replicas && current_revision == other.current_revision && observed_generation == other.observed_generation && ready_replicas == other.ready_replicas && replicas == other.replicas && update_revision == other.update_revision && updated_replicas == other.updated_replicas end # @see the `==` method # @param [Object] Object to be compared def eql?(other) self == other end # Calculates hash code according to all attributes. # @return [Integer] Hash code def hash [available_replicas, collision_count, conditions, current_replicas, current_revision, observed_generation, ready_replicas, replicas, update_revision, updated_replicas].hash end # Builds the object from hash # @param [Hash] attributes Model attributes in the form of hash # @return [Object] Returns the model itself def self.build_from_hash(attributes) new.build_from_hash(attributes) end # Builds the object from hash # @param [Hash] attributes Model attributes in the form of hash # @return [Object] Returns the model itself def build_from_hash(attributes) return nil unless attributes.is_a?(Hash) attributes = attributes.transform_keys(&:to_sym) self.class.openapi_types.each_pair do |key, type| if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key) send("#{key}=", nil) elsif type =~ /\AArray<(.*)>/i # check to ensure the input is an array given that the attribute # is documented as an array but the input is not if attributes[self.class.attribute_map[key]].is_a?(Array) send("#{key}=", attributes[self.class.attribute_map[key]].map do |v| _deserialize(::Regexp.last_match(1), v) end) end elsif !attributes[self.class.attribute_map[key]].nil? send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) end end self end # Deserializes the data based on type # @param string type Data type # @param string value Value to be deserialized # @return [Object] Deserialized data def _deserialize(type, value) case type.to_sym when :Time Time.parse(value) when :Date Date.parse(value) when :String value.to_s when :Integer value.to_i when :Float value.to_f when :Boolean if value.to_s =~ /\A(true|t|yes|y|1)\z/i true else false end when :Object # generic object (usually a Hash), return directly value when /\AArray<(?<inner_type>.+)>\z/ inner_type = Regexp.last_match[:inner_type] value.map { |v| _deserialize(inner_type, v) } when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/ k_type = Regexp.last_match[:k_type] v_type = Regexp.last_match[:v_type] {}.tap do |hash| value.each do |k, v| hash[_deserialize(k_type, k)] = _deserialize(v_type, v) end end else # model # models (e.g. Pet) or oneOf klass = Zilla.const_get(type) klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value) end end # Returns the string representation of the object # @return [String] String presentation of the object def to_s to_hash.to_s end # to_body is an alias to to_hash (backward compatibility) # @return [Hash] Returns the object in the form of hash def to_body to_hash end # Returns the object in the form of hash # @return [Hash] Returns the object in the form of hash def to_hash hash = {} self.class.attribute_map.each_pair do |attr, param| value = send(attr) if value.nil? is_nullable = self.class.openapi_nullable.include?(attr) next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) end hash[param] = _to_hash(value) end hash end # Outputs non-array value in the form of hash # For object, use to_hash. Otherwise, just return the value # @param [Object] value Any valid value # @return [Hash] Returns the value in the form of hash def _to_hash(value) if value.is_a?(Array) value.compact.map { |v| _to_hash(v) } elsif value.is_a?(Hash) {}.tap do |hash| value.each { |k, v| hash[k] = _to_hash(v) } end elsif value.respond_to? :to_hash value.to_hash else value end end end end