Custom attribute writer method checking allowed values (enum).
 @param [Object] h264_profile Object to be assigned
12924
def h264_profile=(h264_profile)
      validator = EnumAttributeValidator.new('String', ["baseline", "main", "high", "high10", "high422", "high444"])
      unless validator.valid?(h264_profile)
        fail ArgumentError, "invalid value for 'h264_profile', must be one of #{validator.allowable_values}."
      end
      @h264_profile = h264_profile
    end
90862
def audio_channels_layout=(audio_channels_layout)
      validator = EnumAttributeValidator.new('String', ["1.0", "2.0", "2.1", "3.0", "3.0(back)", "3.1", "4.0", "4.1", "quad", "5.0", "5.0(side)", "5.1(side)", "6.0", "6.1", "7.0", "7.1", "mono", "stereo"])
      unless validator.valid?(audio_channels_layout)
        fail ArgumentError, "invalid value for 'audio_channels_layout', must be one of #{validator.allowable_values}."
      end
      @audio_channels_layout = audio_channels_layout
    end
877296
def object_type=(object_type)
      validator = EnumAttributeValidator.new('String', ["ITEM", "DISCOUNT", "CATEGORY", "PLACEHOLDER"])
      unless validator.valid?(object_type)
        fail ArgumentError, "invalid value for 'object_type', must be one of #{validator.allowable_values}."
      end
      @object_type = object_type
    end
582202
function(id, profileKey) {
    if (!profiles.hasOwnProperty("definitions")) {
        throw ("\"profiles\" dictionary is badly formed, no \"definitions\" key");
    }
    if (!profiles.definitions.hasOwnProperty(profileKey)) {
        if (!profiles.definitions.hasOwnProperty("default")) {
            throw ("\"" + profileKey + "\" is not a registred SLURM profile AND no default profile is defined");
        } else {
            profileKey = "default";
        }
    }
    var string = _preprocessorDump(id, profiles.definitions[profileKey]);
    return string;
}
747158
def writers
      doc.css("h4:contains('Writing')").first.next_element.css('a[@href^="/name/nm"]').map { |w|
        profile = w['href'].match(/\/name\/nm([0-9]+)/)[1] rescue nil
        IMDB::Person.new(profile) unless profile.nil?
      }
    end
194419
def match_type=(match_type)
      validator = EnumAttributeValidator.new('String', ["Exact", "StartsWith", "EndsWith", "Contains"])
      if match_type.to_i == 0
        unless validator.valid?(match_type)
          raise ArgumentError, "invalid value for 'match_type', must be one of #{validator.allowable_values}."
        end
        @match_type = match_type
      else
        @match_type = validator.allowable_values[match_type.to_i]
      end
    end
180190
def audio_format=(audio_format)
      validator = EnumAttributeValidator.new('String', ["pcm_s24le", "pcm_s16le"])
      unless validator.valid?(audio_format)
        fail ArgumentError, "invalid value for 'audio_format', must be one of #{validator.allowable_values}."
      end
      @audio_format = audio_format
    end
1029452
def deinterlace=(deinterlace)
      validator = EnumAttributeValidator.new('String', ["keep_fps", "double_fps"])
      unless validator.valid?(deinterlace)
        fail ArgumentError, "invalid value for 'deinterlace', must be one of #{validator.allowable_values}."
      end
      @deinterlace = deinterlace
    end
563419
def validate_enum_attribute(fully_qualified_name: str, spec: Dict[str, Any], attribute: str,
                            candidates: Set[Union[str, int, float]]) -> Optional[InvalidValueError]:
    

    if attribute not in spec:
        return

    if spec[attribute] not in candidates:
        return InvalidValueError(fully_qualified_name, spec, attribute, candidates)
1126886
def eac3_lt_rt_center_mix_level=(eac3_lt_rt_center_mix_level)
      validator = EnumAttributeValidator.new('String', ["c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7"])
      unless validator.valid?(eac3_lt_rt_center_mix_level)
        fail ArgumentError, "invalid value for 'eac3_lt_rt_center_mix_level', must be one of #{validator.allowable_values}."
      end
      @eac3_lt_rt_center_mix_level = eac3_lt_rt_center_mix_level
    end
628933
def valid?
      return false if @name.nil?
      acl_validator = EnumAttributeValidator.new('String', ["public", "private"])
      return false unless acl_validator.valid?(@acl)
      return true
    end
1144568
def modifier=(modifier)
      validator = EnumAttributeValidator.new('String', ["exclude", "include"])
      unless validator.valid?(modifier)
        fail ArgumentError, "invalid value for 'modifier', must be one of #{validator.allowable_values}."
      end
      @modifier = modifier
    end
1090900
def profile_name
      # allow user to specify the path also
      if @options[:profile] && File.exist?(@options[:profile])
        filename_profile = File.basename(@options[:profile], '.yml')
      end

      name = derandomize(@name)
      if File.exist?(profile_file(name))
        name_profile = name
      end

      filename_profile ||
      @options[:profile] ||
      name_profile || # conventional profile is the name of the elb
      "default"
    end
778702
private boolean isProfilingHeader(final String confidentialData, final ILoggingEvent event) {
        if (!LOGGING_FILTER_NAME.equals(event.getLoggerName())) {
            return false;
        }

        for (final ProfilingFeatureType profileType : ProfilingFeatureType.values()) {
            // See ProfilingDataItem#getKey
            if (confidentialData.startsWith("\"" + profileType.name() + ":")) {
                return true;
            }
        }
        return false;
    }
7924
def valid?
      return false if @status.nil?
      status_validator = EnumAttributeValidator.new('String', ['error'])
      return false unless status_validator.valid?(@status)
      return false if @errors.nil?
      true
    end
1275708
def account_type=(account_type)
      validator = EnumAttributeValidator.new('String', ["LOCATION", "BUSINESS"])
      unless validator.valid?(account_type)
        fail ArgumentError, "invalid value for 'account_type', must be one of #{validator.allowable_values}."
      end
      @account_type = account_type
    end
144510
def action_category=(action_category)
      validator = EnumAttributeValidator.new('String', ['notification', 'file_upload'])
      unless validator.valid?(action_category)
        fail ArgumentError, 'invalid value for "action_category", must be one of #{validator.allowable_values}.'
      end
      @action_category = action_category
    end