text:
#include <aws/mediaconvert/model/H264Settings.h>
#include <aws/core/utils/json/JsonSerializer.h>

#include <utility>

using namespace Aws::Utils::Json;
using namespace Aws::Utils;

namespace Aws
{
namespace MediaConvert
{
namespace Model
{

H264Settings::H264Settings() :
    m_adaptiveQuantization(H264AdaptiveQuantization::NOT_SET),
    m_adaptiveQuantizationHasBeenSet(false),
    m_bitrate(0),
    m_bitrateHasBeenSet(false),
    m_codecLevel(H264CodecLevel::NOT_SET),
    m_codecLevelHasBeenSet(false),
    m_codecProfile(H264CodecProfile::NOT_SET),
    m_codecProfileHasBeenSet(false),
    m_dynamicSubGop(H264DynamicSubGop::NOT_SET),
    m_dynamicSubGopHasBeenSet(false),
    m_entropyEncoding(H264EntropyEncoding::NOT_SET),
    m_entropyEncodingHasBeenSet(false),
    m_fieldEncoding(H264FieldEncoding::NOT_SET),
    m_fieldEncodingHasBeenSet(false),
    m_flickerAdaptiveQuantization(H264FlickerAdaptiveQuantization::NOT_SET),
    m_flickerAdaptiveQuantizationHasBeenSet(false),
    m_framerateControl(H264FramerateControl::NOT_SET),
    m_framerateControlHasBeenSet(false),
    m_framerateConversionAlgorithm(H264FramerateConversionAlgorithm::NOT_SET),
    m_framerateConversionAlgorithmHasBeenSet(false),
    m_framerateDenominator(0),
    m_framerateDenominatorHasBeenSet(false),
    m_framerateNumerator(0),
    m_framerateNumeratorHasBeenSet(false),
    m_gopBReference(H264GopBReference::NOT_SET),
    m_gopBReferenceHasBeenSet(false),
    m_gopClosedCadence(0),
    m_gopClosedCadenceHasBeenSet(false),
    m_gopSize(0.0),
    m_gopSizeHasBeenSet(false),
    m_gopSizeUnits(H264GopSizeUnits::NOT_SET),
    m_gopSizeUnitsHasBeenSet(false),
    m_hrdBufferInitialFillPercentage(0),
    m_hrdBufferInitialFillPercentageHasBeenSet(false),
    m_hrdBufferSize(0),
    m_hrdBufferSizeHasBeenSet(false),
    m_interlaceMode(H264InterlaceMode::NOT_SET),
    m_interlaceModeHasBeenSet(false),
    m_maxBitrate(0),
    m_maxBitrateHasBeenSet(false),
    m_minIInterval(0),
    m_minIIntervalHasBeenSet(false),
    m_numberBFramesBetweenReferenceFrames(0),
    m_numberBFramesBetweenReferenceFramesHasBeenSet(false),
    m_numberReferenceFrames(0),
    m_numberReferenceFramesHasBeenSet(false),
    m_parControl(H264ParControl::NOT_SET),
    m_parControlHasBeenSet(false),
    m_parDenominator(0),
    m_parDenominatorHasBeenSet(false),
    m_parNumerator(0),
    m_parNumeratorHasBeenSet(false),
    m_qualityTuningLevel(H264QualityTuningLevel::NOT_SET),
    m_qualityTuningLevelHasBeenSet(false),
    m_qvbrSettingsHasBeenSet(false),
    m_rateControlMode(H264RateControlMode::NOT_SET),
    m_rateControlModeHasBeenSet(false),
    m_repeatPps(H264RepeatPps::NOT_SET),
    m_repeatPpsHasBeenSet(false),
    m_scanTypeConversionMode(H264ScanTypeConversionMode::NOT_SET),
    m_scanTypeConversionModeHasBeenSet(false),
    m_sceneChangeDetect(H264SceneChangeDetect::NOT_SET),
    m_sceneChangeDetectHasBeenSet(false),
    m_slices(0),
    m_slicesHasBeenSet(false),
    m_slowPal(H264SlowPal::NOT_SET),
    m_slowPalHasBeenSet(false),
    m_softness(0),
    m_softnessHasBeenSet(false),
    m_spatialAdaptiveQuantization(H264SpatialAdaptiveQuantization::NOT_SET),
    m_spatialAdaptiveQuantizationHasBeenSet(false),
    m_syntax(H264Syntax::NOT_SET),
    m_syntaxHasBeenSet(false),
    m_telecine(H264Telecine::NOT_SET),
    m_telecineHasBeenSet(false),
    m_temporalAdaptiveQuantization(H264TemporalAdaptiveQuantization::NOT_SET),
    m_temporalAdaptiveQuantizationHasBeenSet(false),
    m_unregisteredSeiTimecode(H264UnregisteredSeiTimecode::NOT_SET),
    m_unregisteredSeiTimecodeHasBeenSet(false)
{
}

H264Settings::H264Settings(JsonView jsonValue) :
    m_adaptiveQuantization(H264AdaptiveQuantization::NOT_SET),
    m_adaptiveQuantizationHasBeenSet(false),
    m_bitrate(0),
    m_bitrateHasBeenSet(false),
    m_codecLevel(H264CodecLevel::NOT_SET),
    m_codecLevelHasBeenSet(false),
    m_codecProfile(H264CodecProfile::NOT_SET),
    m_codecProfileHasBeenSet(false),
    m_dynamicSubGop(H264DynamicSubGop::NOT_SET),
    m_dynamicSubGopHasBeenSet(false),
    m_entropyEncoding(H264EntropyEncoding::NOT_SET),
    m_entropyEncodingHasBeenSet(false),
    m_fieldEncoding(H264FieldEncoding::NOT_SET),
    m_fieldEncodingHasBeenSet(false),
    m_flickerAdaptiveQuantization(H264FlickerAdaptiveQuantization::NOT_SET),
    m_flickerAdaptiveQuantizationHasBeenSet(false),
    m_framerateControl(H264FramerateControl::NOT_SET),
    m_framerateControlHasBeenSet(false),
    m_framerateConversionAlgorithm(H264FramerateConversionAlgorithm::NOT_SET),
    m_framerateConversionAlgorithmHasBeenSet(false),
    m_framerateDenominator(0),
    m_framerateDenominatorHasBeenSet(false),
    m_framerateNumerator(0),
    m_framerateNumeratorHasBeenSet(false),
    m_gopBReference(H264GopBReference::NOT_SET),
    m_gopBReferenceHasBeenSet(false),
    m_gopClosedCadence(0),
    m_gopClosedCadenceHasBeenSet(false),
    m_gopSize(0.0),
    m_gopSizeHasBeenSet(false),
    m_gopSizeUnits(H264GopSizeUnits::NOT_SET),
    m_gopSizeUnitsHasBeenSet(false),
    m_hrdBufferInitialFillPercentage(0),
    m_hrdBufferInitialFillPercentageHasBeenSet(false),
    m_hrdBufferSize(0),
    m_hrdBufferSizeHasBeenSet(false),
    m_interlaceMode(H264InterlaceMode::NOT_SET),
    m_interlaceModeHasBeenSet(false),
    m_maxBitrate(0),
    m_maxBitrateHasBeenSet(false),
    m_minIInterval(0),
    m_minIIntervalHasBeenSet(false),
    m_numberBFramesBetweenReferenceFrames(0),
    m_numberBFramesBetweenReferenceFramesHasBeenSet(false),
    m_numberReferenceFrames(0),
    m_numberReferenceFramesHasBeenSet(false),
    m_parControl(H264ParControl::NOT_SET),
    m_parControlHasBeenSet(false),
    m_parDenominator(0),
    m_parDenominatorHasBeenSet(false),
    m_parNumerator(0),
    m_parNumeratorHasBeenSet(false),
    m_qualityTuningLevel(H264QualityTuningLevel::NOT_SET),
    m_qualityTuningLevelHasBeenSet(false),
    m_qvbrSettingsHasBeenSet(false),
    m_rateControlMode(H264RateControlMode::NOT_SET),
    m_rateControlModeHasBeenSet(false),
    m_repeatPps(H264RepeatPps::NOT_SET),
    m_repeatPpsHasBeenSet(false),
    m_scanTypeConversionMode(H264ScanTypeConversionMode::NOT_SET),
    m_scanTypeConversionModeHasBeenSet(false),
    m_sceneChangeDetect(H264SceneChangeDetect::NOT_SET),
    m_sceneChangeDetectHasBeenSet(false),
    m_slices(0),
    m_slicesHasBeenSet(false),
    m_slowPal(H264SlowPal::NOT_SET),
    m_slowPalHasBeenSet(false),
    m_softness(0),
    m_softnessHasBeenSet(false),
    m_spatialAdaptiveQuantization(H264SpatialAdaptiveQuantization::NOT_SET),
    m_spatialAdaptiveQuantizationHasBeenSet(false),
    m_syntax(H264Syntax::NOT_SET),
    m_syntaxHasBeenSet(false),
    m_telecine(H264Telecine::NOT_SET),
    m_telecineHasBeenSet(false),
    m_temporalAdaptiveQuantization(H264TemporalAdaptiveQuantization::NOT_SET),
    m_temporalAdaptiveQuantizationHasBeenSet(false),
    m_unregisteredSeiTimecode(H264UnregisteredSeiTimecode::NOT_SET),
    m_unregisteredSeiTimecodeHasBeenSet(false)
{
  *this = jsonValue;
}

H264Settings& H264Settings::operator =(JsonView jsonValue)
{
  if(jsonValue.ValueExists("adaptiveQuantization"))
  {
    m_adaptiveQuantization = H264AdaptiveQuantizationMapper::GetH264AdaptiveQuantizationForName(jsonValue.GetString("adaptiveQuantization"));

    m_adaptiveQuantizationHasBeenSet = true;
  }

  if(jsonValue.ValueExists("bitrate"))
  {
    m_bitrate = jsonValue.GetInteger("bitrate");

    m_bitrateHasBeenSet = true;
  }

  if(jsonValue.ValueExists("codecLevel"))
  {
    m_codecLevel = H264CodecLevelMapper::GetH264CodecLevelForName(jsonValue.GetString("codecLevel"));

    m_codecLevelHasBeenSet = true;
  }

  if(jsonValue.ValueExists("codecProfile"))
  {
    m_codecProfile = H264CodecProfileMapper::GetH264CodecProfileForName(jsonValue.GetString("codecProfile"));

    m_codecProfileHasBeenSet = true;
  }

  if(jsonValue.ValueExists("dynamicSubGop"))
  {
    m_dynamicSubGop = H264DynamicSubGopMapper::GetH264DynamicSubGopForName(jsonValue.GetString("dynamicSubGop"));

    m_dynamicSubGopHasBeenSet = true;
  }

  if(jsonValue.ValueExists("entropyEncoding"))
  {
    m_entropyEncoding = H264EntropyEncodingMapper::GetH264EntropyEncodingForName(jsonValue.GetString("entropyEncoding"));

    m_entropyEncodingHasBeenSet = true;
  }

  if(jsonValue.ValueExists("fieldEncoding"))
  {
    m_fieldEncoding = H264FieldEncodingMapper::GetH264FieldEncodingForName(jsonValue.GetString("fieldEncoding"));

    m_fieldEncodingHasBeenSet = true;
  }

  if(jsonValue.ValueExists("flickerAdaptiveQuantization"))
  {
    m_flickerAdaptiveQuantization = H264FlickerAdaptiveQuantizationMapper::GetH264FlickerAdaptiveQuantizationForName(jsonValue.GetString("flickerAdaptiveQuantization"));

    m_flickerAdaptiveQuantizationHasBeenSet = true;
  }

  if(jsonValue.ValueExists("framerateControl"))
  {
    m_framerateControl = H264FramerateControlMapper::GetH264FramerateControlForName(jsonValue.GetString("framerateControl"));

    m_framerateControlHasBeenSet = true;
  }

  if(jsonValue.ValueExists("framerateConversionAlgorithm"))
  {
    m_framerateConversionAlgorithm = H264FramerateConversionAlgorithmMapper::GetH264FramerateConversionAlgorithmForName(jsonValue.GetString("framerateConversionAlgorithm"));

    m_framerateConversionAlgorithmHasBeenSet = true;
  }

  if(jsonValue.ValueExists("framerateDenominator"))
  {
    m_framerateDenominator = jsonValue.GetInteger("framerateDenominator");

    m_framerateDenominatorHasBeenSet = true;
  }

  if(jsonValue.ValueExists("framerateNumerator"))
  {
    m_framerateNumerator = jsonValue.GetInteger("framerateNumerator");

    m_framerateNumeratorHasBeenSet = true;
  }

  if(jsonValue.ValueExists("gopBReference"))
  {
    m_gopBReference = H264GopBReferenceMapper::GetH264GopBReferenceForName(jsonValue.GetString("gopBReference"));

    m_gopBReferenceHasBeenSet = true;
  }

  if(jsonValue.ValueExists("gopClosedCadence"))
  {
    m_gopClosedCadence = jsonValue.GetInteger("gopClosedCadence");

    m_gopClosedCadenceHasBeenSet = true;
  }

  if(jsonValue.ValueExists("gopSize"))
  {
    m_gopSize = jsonValue.GetDouble("gopSize");

    m_gopSizeHasBeenSet = true;
  }

  if(jsonValue.ValueExists("gopSizeUnits"))
  {
    m_gopSizeUnits = H264GopSizeUnitsMapper::GetH264GopSizeUnitsForName(jsonValue.GetString("gopSizeUnits"));

    m_gopSizeUnitsHasBeenSet = true;
  }

  if(jsonValue.ValueExists("hrdBufferInitialFillPercentage"))
  {
    m_hrdBufferInitialFillPercentage = jsonValue.GetInteger("hrdBufferInitialFillPercentage");

    m_hrdBufferInitialFillPercentageHasBeenSet = true;
  }

  if(jsonValue.ValueExists("hrdBufferSize"))
  {
    m_hrdBufferSize = jsonValue.GetInteger("hrdBufferSize");

    m_hrdBufferSizeHasBeenSet = true;
  }

  if(jsonValue.ValueExists("interlaceMode"))
  {
    m_interlaceMode = H264InterlaceModeMapper::GetH264InterlaceModeForName(jsonValue.GetString("interlaceMode"));

    m_interlaceModeHasBeenSet = true;
  }

  if(jsonValue.ValueExists("maxBitrate"))
  {
    m_maxBitrate = jsonValue.GetInteger("maxBitrate");

    m_maxBitrateHasBeenSet = true;
  }

  if(jsonValue.ValueExists("minIInterval"))
  {
    m_minIInterval = jsonValue.GetInteger("minIInterval");

    m_minIIntervalHasBeenSet = true;
  }

  if(jsonValue.ValueExists("numberBFramesBetweenReferenceFrames"))
  {
    m_numberBFramesBetweenReferenceFrames = jsonValue.GetInteger("numberBFramesBetweenReferenceFrames");

    m_numberBFramesBetweenReferenceFramesHasBeenSet = true;
  }

  if(jsonValue.ValueExists("numberReferenceFrames"))
  {
    m_numberReferenceFrames = jsonValue.GetInteger("numberReferenceFrames");

    m_numberReferenceFramesHasBeenSet = true;
  }

  if(jsonValue.ValueExists("parControl"))
  {
    m_parControl = H264ParControlMapper::GetH264ParControlForName(jsonValue.GetString("parControl"));

    m_parControlHasBeenSet = true;
  }

  if(jsonValue.ValueExists("parDenominator"))
  {
    m_parDenominator = jsonValue.GetInteger("parDenominator");

    m_parDenominatorHasBeenSet = true;
  }

  if(jsonValue.ValueExists("parNumerator"))
  {
    m_parNumerator = jsonValue.GetInteger("parNumerator");

    m_parNumeratorHasBeenSet = true;
  }

  if(jsonValue.ValueExists("qualityTuningLevel"))
  {
    m_qualityTuningLevel = H264QualityTuningLevelMapper::GetH264QualityTuningLevelForName(jsonValue.GetString("qualityTuningLevel"));

    m_qualityTuningLevelHasBeenSet = true;
  }

  if(jsonValue.ValueExists("qvbrSettings"))
  {
    m_qvbrSettings = jsonValue.GetObject("qvbrSettings");

    m_qvbrSettingsHasBeenSet = true;
  }

  if(jsonValue.ValueExists("rateControlMode"))
  {
    m_rateControlMode = H264RateControlModeMapper::GetH264RateControlModeForName(jsonValue.GetString("rateControlMode"));

    m_rateControlModeHasBeenSet = true;
  }

  if(jsonValue.ValueExists("repeatPps"))
  {
    m_repeatPps = H264RepeatPpsMapper::GetH264RepeatPpsForName(jsonValue.GetString("repeatPps"));

    m_repeatPpsHasBeenSet = true;
  }

  if(jsonValue.ValueExists("scanTypeConversionMode"))
  {
    m_scanTypeConversionMode = H264ScanTypeConversionModeMapper::GetH264ScanTypeConversionModeForName(jsonValue.GetString("scanTypeConversionMode"));

    m_scanTypeConversionModeHasBeenSet = true;
  }

  if(jsonValue.ValueExists("sceneChangeDetect"))
  {
    m_sceneChangeDetect = H264SceneChangeDetectMapper::GetH264SceneChangeDetectForName(jsonValue.GetString("sceneChangeDetect"));

    m_sceneChangeDetectHasBeenSet = true;
  }

  if(jsonValue.ValueExists("slices"))
  {
    m_slices = jsonValue.GetInteger("slices");

    m_slicesHasBeenSet = true;
  }

  if(jsonValue.ValueExists("slowPal"))
  {
    m_slowPal = H264SlowPalMapper::GetH264SlowPalForName(jsonValue.GetString("slowPal"));

    m_slowPalHasBeenSet = true;
  }

  if(jsonValue.ValueExists("softness"))
  {
    m_softness = jsonValue.GetInteger("softness");

    m_softnessHasBeenSet = true;
  }

  if(jsonValue.ValueExists("spatialAdaptiveQuantization"))
  {
    m_spatialAdaptiveQuantization = H264SpatialAdaptiveQuantizationMapper::GetH264SpatialAdaptiveQuantizationForName(jsonValue.GetString("spatialAdaptiveQuantization"));

    m_spatialAdaptiveQuantizationHasBeenSet = true;
  }

  if(jsonValue.ValueExists("syntax"))
  {
    m_syntax = H264SyntaxMapper::GetH264SyntaxForName(jsonValue.GetString("syntax"));

    m_syntaxHasBeenSet = true;
  }

  if(jsonValue.ValueExists("telecine"))
  {
    m_telecine = H264TelecineMapper::GetH264TelecineForName(jsonValue.GetString("telecine"));

    m_telecineHasBeenSet = true;
  }

  if(jsonValue.ValueExists("temporalAdaptiveQuantization"))
  {
    m_temporalAdaptiveQuantization = H264TemporalAdaptiveQuantizationMapper::GetH264TemporalAdaptiveQuantizationForName(jsonValue.GetString("temporalAdaptiveQuantization"));

    m_temporalAdaptiveQuantizationHasBeenSet = true;
  }

  if(jsonValue.ValueExists("unregisteredSeiTimecode"))
  {
    m_unregisteredSeiTimecode = H264UnregisteredSeiTimecodeMapper::GetH264UnregisteredSeiTimecodeForName(jsonValue.GetString("unregisteredSeiTimecode"));

    m_unregisteredSeiTimecodeHasBeenSet = true;
  }

  return *this;
}

JsonValue H264Settings::Jsonize() const
{
  JsonValue payload;

  if(m_adaptiveQuantizationHasBeenSet)
  {
   payload.WithString("adaptiveQuantization", H264AdaptiveQuantizationMapper::GetNameForH264AdaptiveQuantization(m_adaptiveQuantization));
  }

  if(m_bitrateHasBeenSet)
  {
   payload.WithInteger("bitrate", m_bitrate);

  }

  if(m_codecLevelHasBeenSet)
  {
   payload.WithString("codecLevel", H264CodecLevelMapper::GetNameForH264CodecLevel(m_codecLevel));
  }

  if(m_codecProfileHasBeenSet)
  {
   payload.WithString("codecProfile", H264CodecProfileMapper::GetNameForH264CodecProfile(m_codecProfile));
  }

  if(m_dynamicSubGopHasBeenSet)
  {
   payload.WithString("dynamicSubGop", H264DynamicSubGopMapper::GetNameForH264DynamicSubGop(m_dynamicSubGop));
  }

  if(m_entropyEncodingHasBeenSet)
  {
   payload.WithString("entropyEncoding", H264EntropyEncodingMapper::GetNameForH264EntropyEncoding(m_entropyEncoding));
  }

  if(m_fieldEncodingHasBeenSet)
  {
   payload.WithString("fieldEncoding", H264FieldEncodingMapper::GetNameForH264FieldEncoding(m_fieldEncoding));
  }

  if(m_flickerAdaptiveQuantizationHasBeenSet)
  {
   payload.WithString("flickerAdaptiveQuantization", H264FlickerAdaptiveQuantizationMapper::GetNameForH264FlickerAdaptiveQuantization(m_flickerAdaptiveQuantization));
  }

  if(m_framerateControlHasBeenSet)
  {
   payload.WithString("framerateControl", H264FramerateControlMapper::GetNameForH264FramerateControl(m_framerateControl));
  }

  if(m_framerateConversionAlgorithmHasBeenSet)
  {
   payload.WithString("framerateConversionAlgorithm", H264FramerateConversionAlgorithmMapper::GetNameForH264FramerateConversionAlgorithm(m_framerateConversionAlgorithm));
  }

  if(m_framerateDenominatorHasBeenSet)
  {
   payload.WithInteger("framerateDenominator", m_framerateDenominator);

  }

  if(m_framerateNumeratorHasBeenSet)
  {
   payload.WithInteger("framerateNumerator", m_framerateNumerator);

  }

  if(m_gopBReferenceHasBeenSet)
  {
   payload.WithString("gopBReference", H264GopBReferenceMapper::GetNameForH264GopBReference(m_gopBReference));
  }

  if(m_gopClosedCadenceHasBeenSet)
  {
   payload.WithInteger("gopClosedCadence", m_gopClosedCadence);

  }

  if(m_gopSizeHasBeenSet)
  {
   payload.WithDouble("gopSize", m_gopSize);

  }

  if(m_gopSizeUnitsHasBeenSet)
  {
   payload.WithString("gopSizeUnits", H264GopSizeUnitsMapper::GetNameForH264GopSizeUnits(m_gopSizeUnits));
  }

  if(m_hrdBufferInitialFillPercentageHasBeenSet)
  {
   payload.WithInteger("hrdBufferInitialFillPercentage", m_hrdBufferInitialFillPercentage);

  }

  if(m_hrdBufferSizeHasBeenSet)
  {
   payload.WithInteger("hrdBufferSize", m_hrdBufferSize);

  }

  if(m_interlaceModeHasBeenSet)
  {
   payload.WithString("interlaceMode", H264InterlaceModeMapper::GetNameForH264InterlaceMode(m_interlaceMode));
  }

  if(m_maxBitrateHasBeenSet)
  {
   payload.WithInteger("maxBitrate", m_maxBitrate);

  }

  if(m_minIIntervalHasBeenSet)
  {
   payload.WithInteger("minIInterval", m_minIInterval);

  }

  if(m_numberBFramesBetweenReferenceFramesHasBeenSet)
  {
   payload.WithInteger("numberBFramesBetweenReferenceFrames", m_numberBFramesBetweenReferenceFrames);

  }

  if(m_numberReferenceFramesHasBeenSet)
  {
   payload.WithInteger("numberReferenceFrames", m_numberReferenceFrames);

  }

  if(m_parControlHasBeenSet)
  {
   payload.WithString("parControl", H264ParControlMapper::GetNameForH264ParControl(m_parControl));
  }

  if(m_parDenominatorHasBeenSet)
  {
   payload.WithInteger("parDenominator", m_parDenominator);

  }

  if(m_parNumeratorHasBeenSet)
  {
   payload.WithInteger("parNumerator", m_parNumerator);

  }

  if(m_qualityTuningLevelHasBeenSet)
  {
   payload.WithString("qualityTuningLevel", H264QualityTuningLevelMapper::GetNameForH264QualityTuningLevel(m_qualityTuningLevel));
  }

  if(m_qvbrSettingsHasBeenSet)
  {
   payload.WithObject("qvbrSettings", m_qvbrSettings.Jsonize());

  }

  if(m_rateControlModeHasBeenSet)
  {
   payload.WithString("rateControlMode", H264RateControlModeMapper::GetNameForH264RateControlMode(m_rateControlMode));
  }

  if(m_repeatPpsHasBeenSet)
  {
   payload.WithString("repeatPps", H264RepeatPpsMapper::GetNameForH264RepeatPps(m_repeatPps));
  }

  if(m_scanTypeConversionModeHasBeenSet)
  {
   payload.WithString("scanTypeConversionMode", H264ScanTypeConversionModeMapper::GetNameForH264ScanTypeConversionMode(m_scanTypeConversionMode));
  }

  if(m_sceneChangeDetectHasBeenSet)
  {
   payload.WithString("sceneChangeDetect", H264SceneChangeDetectMapper::GetNameForH264SceneChangeDetect(m_sceneChangeDetect));
  }

  if(m_slicesHasBeenSet)
  {
   payload.WithInteger("slices", m_slices);

  }

  if(m_slowPalHasBeenSet)
  {
   payload.WithString("slowPal", H264SlowPalMapper::GetNameForH264SlowPal(m_slowPal));
  }

  if(m_softnessHasBeenSet)
  {
   payload.WithInteger("softness", m_softness);

  }

  if(m_spatialAdaptiveQuantizationHasBeenSet)
  {
   payload.WithString("spatialAdaptiveQuantization", H264SpatialAdaptiveQuantizationMapper::GetNameForH264SpatialAdaptiveQuantization(m_spatialAdaptiveQuantization));
  }

  if(m_syntaxHasBeenSet)
  {
   payload.WithString("syntax", H264SyntaxMapper::GetNameForH264Syntax(m_syntax));
  }

  if(m_telecineHasBeenSet)
  {
   payload.WithString("telecine", H264TelecineMapper::GetNameForH264Telecine(m_telecine));
  }

  if(m_temporalAdaptiveQuantizationHasBeenSet)
  {
   payload.WithString("temporalAdaptiveQuantization", H264TemporalAdaptiveQuantizationMapper::GetNameForH264TemporalAdaptiveQuantization(m_temporalAdaptiveQuantization));
  }

  if(m_unregisteredSeiTimecodeHasBeenSet)
  {
   payload.WithString("unregisteredSeiTimecode", H264UnregisteredSeiTimecodeMapper::GetNameForH264UnregisteredSeiTimecode(m_unregisteredSeiTimecode));
  }

  return payload;
}

} // namespace Model
} // namespace MediaConvert
} // namespace Aws


text:
export function createResizeHandle(element) {
  var handle = document.createElement('div');
  var isDragging = { x: 0 };

  handle.className = 'es-resize-handle';
  handle.onmousedown = (event) => {
    isDragging.x = event.x;

    document.addEventListener("mousemove", handleMouseMove);
    document.addEventListener("mouseup", handleMouseUp);
  };

  element.appendChild(handle);

  //INTERNAL event handling functions
  function handleMouseUp(event) {
    document.removeEventListener("mousemove", handleMouseMove);
    document.removeEventListener("mouseup", handleMouseUp);
  }

  function handleMouseMove(event) {
    let width =Number((element.style.width || "200px").slice(0, -2));
    width += isDragging.x - event.x;
    element.style.width = `${width}px`;

    isDragging.x = event.x;
  }
}

redpajama_set_name: RedPajamaGithub


text:
namespace gfx {
class Canvas;
class Font;
}

namespace views {

class FocusableBorder;
class MenuRunner;

// A views/skia only implementation of NativeComboboxWrapper.
// No platform specific code is used.
class NativeComboboxViews : public views::View,
                            public NativeComboboxWrapper,
                            public views::MenuDelegate {
 public:
  static const char kViewClassName[];

  explicit NativeComboboxViews(Combobox* combobox);
  virtual ~NativeComboboxViews();

  // views::View overrides:
  virtual bool OnMousePressed(const views::MouseEvent& mouse_event) OVERRIDE;
  virtual bool OnMouseDragged(const views::MouseEvent& mouse_event) OVERRIDE;
  virtual ui::GestureStatus OnGestureEvent(
      const views::GestureEvent& gesture_event) OVERRIDE;
  virtual bool OnKeyPressed(const views::KeyEvent& key_event) OVERRIDE;
  virtual bool OnKeyReleased(const views::KeyEvent& key_event) OVERRIDE;
  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
  virtual void OnFocus() OVERRIDE;
  virtual void OnBlur() OVERRIDE;

  // NativeComboboxWrapper overrides:
  virtual void UpdateFromModel() OVERRIDE;
  virtual void UpdateSelectedIndex() OVERRIDE;
  virtual void UpdateEnabled() OVERRIDE;
  virtual int GetSelectedIndex() const OVERRIDE;
  virtual bool IsDropdownOpen() const OVERRIDE;
  virtual gfx::Size GetPreferredSize() OVERRIDE;
  virtual View* GetView() OVERRIDE;
  virtual void SetFocus() OVERRIDE;
  virtual bool HandleKeyPressed(const views::KeyEvent& event) OVERRIDE;
  virtual bool HandleKeyReleased(const views::KeyEvent& event) OVERRIDE;
  virtual void HandleFocus() OVERRIDE;
  virtual void HandleBlur() OVERRIDE;
  virtual gfx::NativeView GetTestingHandle() const OVERRIDE;

  // MenuDelegate overrides:
  virtual bool IsItemChecked(int id) const OVERRIDE;
  virtual bool IsCommandEnabled(int id) const OVERRIDE;
  virtual void ExecuteCommand(int id) OVERRIDE;
  virtual bool GetAccelerator(int id, ui::Accelerator* accelerator) OVERRIDE;

 private:
  // Given bounds within our View, this helper routine mirrors the bounds if
  // necessary.
  void AdjustBoundsForRTLUI(gfx::Rect* rect) const;

  // Draw the selected value of the drop down list
  void PaintText(gfx::Canvas* canvas);

  // Show the drop down list
  void ShowDropDownMenu();

  // The parent combobox, the owner of this object.
  Combobox* combobox_;

  // The reference to the border class. The object is owned by View::border_.
  FocusableBorder* text_border_;

  // The disclosure arrow next to the currently selected item from the list.
  const gfx::ImageSkia* disclosure_arrow_;

  // Responsible for showing the context menu.
  scoped_ptr<MenuRunner> dropdown_list_menu_runner_;

  // Is the drop down list showing
  bool dropdown_open_;

  // The selected index in the model. The default value is -1, which means no
  // selection.
  int selected_index_;

  // The maximum dimensions of the content in the dropdown
  int content_width_;
  int content_height_;

  DISALLOW_COPY_AND_ASSIGN(NativeComboboxViews);
};

}  // namespace views

#endif  // UI_VIEWS_CONTROLS_COMBOBOX_NATIVE_COMBOBOX_VIEWS_H_


text:
title=Call for papers
date=2017-10-25
type=page
status=published
~~~~~~
Call for Papers JConf Guatemala 2019
====================================

**We are looking for you as speaker in 2019!**

**JConf Guatemala is the biggest Java conference in Central America**, since 2011 we've constructed an exchange hub for software developers, architects, and enthusiasts around Java technologies in Guatemala.

JConf will be hosted at Guatemala City on **november 9**, being a conference by and for the developer community.

Speak at JConf 2019!
====================
The Guatemala Java Users group -[GuateJUG](http://www.guate-jug.net)- is pleased to invite all the people interested in sharing knowledge with **talks and workshops for beginners and senior developers**.

Do you have something interesting to share with the community? Innovations made with Java?, Java success stories?. **We and the JConf Attendees wanna know about you**.

We've divided the conference in different tracks, being:

Java Platform
-------------

Any topic related with the JVM as development platform including, Java Core, certifications, JVM internals, Java language, OpenJDK.

Alternative languages
---------------------

Considering the Java Virtual Machine as a polyglot execution environment, this space is specially designed for presentations related with GraalVM, Scala, Kotlin, Groovy, JavaScript and beyond.

Server side development
-----------------------

Our most popular track. Main track focus is presentations about Java as enterprise development platform. Java EE, Spring, Akka, Spark, Kafka, MicroProfile, RxJava, etc. Every Java framework, library and standard is welcome.

Client side development
-----------------------

Interested in client side development?, all presentations related with JavaFX, HTML5+CSS+JS, Krazo, Vaadin, JSF, UI/UX, go here.

Small and not so small Java
---------------------------

SmartCards, Java Embedded, iOT, Java Me, Java TV, Android, Arduino, Rasberry Pi and related activities. Java was born here.

Big (Data with) Java
----------------------------------

A new track for this year. We recognize the importance of the JVM in the Data Engineering space, hence this year we will be receiving proposals for topics like Kafka, Hadoop, Spark, Beam, Storm. It doesn't matter if you execute your queries with Scala, Java, Pig, Python, R, in the end all roads converge to the JVM.

Tools, architecture and strategies
----------------------------------

There is no wizard without a magic wand. This section includes all technologies and strategies to improve Java code quality. IDEs, CI/CD, DevOps, Docker, Kubernets, Blockchain, Hyperledger, and any other buzzword.

Startups with Java
------------------

This space will present success stories, academic papers, market tendencies and startups implementing Java as its main platform.

Proposals reception
===================

Proposals will be received through papercall.io:

[https://www.papercall.io/jconf-guatemala-2019](https://www.papercall.io/jconf-guatemala-2019)

It is important to consider:

* By historical reasons, JConf is a free for all, 110% community event. Hence we reserve the right to accept presentation with the only objective to promote a commercial product. We also have sponsorship opportunities that could fit better for this.

* The speaker declares that presentation will be created in a "shareable" format with a proper license (we suggest [CC-BY-SA 3.0 GT](http://creativecommons.org/licenses/by-sa/3.0/gt/)).

* There is no limit for proposals per speaker.

Important dates
===============

CFP opens: **24/06/2019**

CFP ends: **24/07/2019**

Proposals approval announcement and final schedule: **01/08/2019**

Thank you again for contributing with the Java World!


text:
layout: post
title: Haryana PSC Engineer recruitment last date 16th Dec-2015
date: 2015-11-18 16:36
comments: true
tags:  Engineer Haryana Online PSC
archive: false
---
Haryana Public Service Commission invites online applications from eligible candidates for to the following posts for Public Health Engineering Department (PHED),  Haryana Government :

Advertisement No. 4/2015 - Pay Scale : Rs. 15600-39100 grade pay Rs. 5400/-,  Age : 20-42 years as 01/01/2015

- Assistant Executive Engineer (Civil) : 16 posts
- Assistant Executive Engineer (Mechanical) : 01 post

Advertisement No. 5/2015 - Pay Scale : Rs. 9300-34800 grade pay Rs. 5400/-,  Age : 20-42 years as 01/08/2015

- Assistant  Engineer (Civil) : 27 posts
- Assistant Executive Engineer (Mechanical) : 02 post

Application Fee : Rs. 1000/- (Rs.250/- for SC/BC/ESM and all Female candidates, No fee for PWD candidates)  to be payable  at  all  branches  of  State Bank of Patiala & State Bank of India through payment challan.

**How to Apply** : Apply Online at Haryana PSC website <http://hpsc.gov.in> OR  <http://www.hpsconline.in> on or before 16/12/2015. Send hard copy with photocopies of certificates and 2 passport size photo at Commission office on or before 04/01/2016.

For details and instructions etc., please visit <http://hpsc.gov.in/Advertisement.aspx>


text:
[![Tidelift](https://tidelift.com/badges/github/doctrine/orm)](https://tidelift.com/subscription/pkg/packagist-doctrine-orm?utm_source=packagist-doctrine-orm&utm_medium=referral&utm_campaign=readme)

| [Master][Master] | [2.8][2.8] | [2.7][2.7] |
|:----------------:|:----------:|:----------:|
| [![Build status][Master image]][Master] | [![Build status][2.8 image]][2.8] | [![Build status][2.7 image]][2.7] |
| [![Coverage Status][Master coverage image]][Master coverage] | [![Coverage Status][2.8 coverage image]][2.8 coverage] | [![Coverage Status][2.7 coverage image]][2.7 coverage] |

 ##### :warning: You are browsing the code of upcoming Doctrine 3.0.
 ##### Things changed a lot here and major code changes should be expected. If you are rather looking for a stable version, refer to the [2.7 branch][2.7] for the current stable release or [2.8 branch][2.8] for the upcoming release. If you are submitting a pull request, please see the _[Which branch should I choose?](#which-branch-should-i-choose)_ section below.

-----

Doctrine 3 is an object-relational mapper (ORM) for PHP 7.2+ that provides transparent persistence
for PHP objects. It sits on top of a powerful database abstraction layer (DBAL). One of its key features
is the option to write database queries in a proprietary object oriented SQL dialect called Doctrine Query Language (DQL),
inspired by Hibernate's HQL. This provides developers with a powerful alternative to SQL that maintains flexibility
without requiring unnecessary code duplication.

-----

### Which branch should I choose?

Please see [Choosing the branch](CONTRIBUTING.md#choosing-the-branch) to get more information about which branch
you should target your pull request at.

## Doctrine ORM for enterprise

Available as part of the Tidelift Subscription.

The maintainers of Doctrine ORM and thousands of other packages are working with Tidelift to deliver commercial support
and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve
code health, while paying the maintainers of the exact dependencies you use.
[Learn more.](https://tidelift.com/subscription/pkg/packagist-doctrine-orm?utm_source=packagist-doctrine-orm&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

## More resources:

* [Website](http://www.doctrine-project.org)
* [Documentation](http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/index.html)

  [Master image]: https://img.shields.io/travis/doctrine/orm/master.svg?style=flat-square
  [Master]: https://travis-ci.org/doctrine/orm
  [Master coverage image]: https://img.shields.io/scrutinizer/coverage/g/doctrine/orm/master.svg?style=flat-square
  [Master coverage]: https://scrutinizer-ci.com/g/doctrine/orm/?branch=master
  [2.8 image]: https://img.shields.io/travis/doctrine/orm/2.8.x.svg?style=flat-square
  [2.8]: https://github.com/doctrine/orm/tree/2.8.x
  [2.8 coverage image]: https://img.shields.io/scrutinizer/coverage/g/doctrine/orm/2.8.x.svg?style=flat-square
  [2.8 coverage]: https://scrutinizer-ci.com/g/doctrine/orm/?branch=2.8.x
  [2.7 image]: https://img.shields.io/travis/doctrine/orm/2.7.svg?style=flat-square
  [2.7]: https://github.com/doctrine/orm/tree/2.7
  [2.7 coverage image]: https://img.shields.io/scrutinizer/coverage/g/doctrine/orm/2.7.svg?style=flat-square
  [2.7 coverage]: https://scrutinizer-ci.com/g/doctrine/orm/?branch=2.7


text:
{% extends "!layout.html" %}

{%- block extrahead %}
{{ super() }}
<script type="text/javascript">
  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', 'UA-48426035-1']);
  _gaq.push(['_trackPageview']);
</script>
{% endblock %}

{% block footer %}
{{ super() }}
<div class="footer">
<script type="text/javascript">
  (function() {
    var ga = document.createElement('script');
    ga.src = ('https:' == document.location.protocol ?
              'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    ga.setAttribute('async', 'true');
    document.documentElement.firstChild.appendChild(ga);
  })();
</script>
</div>
{% endblock %}


text:
$(document).ready(function() {
  var url =
    '/idm/users/' + window.location.pathname.split('/')[3] + '/applications';
  load_applications(url);

  function load_applications(url, panel) {
    $('#spinner_applications').show('open');
    $.get(url, function(data, status) {
      if (data.applications.length > 0) {
        applications_pagination(data.applications_number);
        create_applications_row(
          data.applications,
          $('#auth_applications_content')
        );
      } else {
        $('#auth_applications_content')
          .find('.alert')
          .show('open');
      }
      $('#spinner_applications').hide('close');
    });
  }

  function create_applications_row(applications, table) {
    for (var i = 0; i < applications.length; i++) {
      var application_row = $('#application_row_template').html();
      application_row = application_row.replace(
        /application_id/g,
        applications[i].id
      );
      application_row = application_row.replace(
        /application_image/g,
        applications[i].image
      );
      application_row = application_row.replace(
        /application_url/g,
        applications[i].url
      );
      application_row = application_row.replace(
        /application_name/g,
        htmlEntities(applications[i].name)
      );

      table.append(application_row);
    }
  }

  var typingTimerApplications;
  var doneTypingInterval = 500;

  $('#auth_applications')
    .find('.form-control')
    .bind('keyup input', function(e) {
      $('#spinner_applications').show('open');
      clearTimeout(typingTimerApplications);
      typingTimerApplications = setTimeout(
        send_filter_request,
        doneTypingInterval
      );
    });

  function send_filter_request() {
    $.get(
      url +
        '?key=' +
        $('#auth_applications')
          .find('.form-control')
          .val()
          .toUpperCase(),
      function(data, status) {
        $('#auth_applications_content')
          .children('.list-group-item')
          .remove();
        $('#spinner_applications').hide('close');
        if (data.applications.length > 0) {
          $('#auth_applications_content')
            .find('.alert')
            .hide();
          applications_pagination(data.applications_number);
          create_applications_row(
            data.applications,
            $('#auth_applications_content')
          );
        } else {
          $('#auth_applications_pagination_container').empty();
          $('#auth_applications_content')
            .find('.alert')
            .show();
        }
      }
    );
  }

  function htmlEntities(str) {
    return String(str)
      .replace(/&/g, '&')
      .replace(/</g, '<')
      .replace(/>/g, '>')
      .replace(/"/g, '"');
  }

  function applications_pagination(max) {
    $('#auth_applications_pagination_container')
      .bootpag({
        total: Math.ceil(max / 5),
        page: 1,
        maxVisible: 5,
        leaps: true,
        firstLastUse: true,
        first: navigation.first,
        last: navigation.last,
        wrapClass: 'pagination',
        activeClass: 'active',
        disabledClass: 'disabled',
        nextClass: 'next',
        prevClass: 'prev',
        lastClass: 'last',
        firstClass: 'first',
      })
      .on('page', function(event, num) {
        $.get(url + '?page=' + num, function(data, status) {
          $('#auth_applications_content')
            .children('.list-group-item')
            .remove();
          create_applications_row(
            data.applications,
            $('#auth_applications_content')
          );
          $('#auth_applications_content')
            .find('.alert')
            .hide();
        });
      });
  }
});


text:
package jerryController;

import java.text.SimpleDateFormat;
import java.util.Date;

import javax.swing.JApplet;

import messageManager.LogFileManager;

/**
 * Main class that calls to create a frame and runs it on a new thread.
 * @author Jackson Wilson
 */
public class Jerry extends JApplet implements Runnable {
	private static final long serialVersionUID = 1L;
	private static boolean firstLogMessage = true;
	public static String OS = getOperatingSystem();

	/**
	 * Runs the application by calling run() in a new thread
	 * @param args
	 */
	public static void main(final String[] args) {
		if (OS.equals("Mac")) {
			System.setProperty("com.apple.mrj.application.apple.menu.about.name", "Jerry Controller");
		}
		(new Thread(new Jerry())).start();
	}

	/**
	 * Calls to create a new MainFrame and sets the properties of the new frame
	 */
	public void run() {
		new JerryFrame("Jerry Controller", OS);
		createOpenLog();
	}

	/**
	 * Creates a new log to mark the launch of the program
	 */
	public void createOpenLog() {
		final Date today = new Date();
		final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("MMM/dd/yy hh:mm:ss a");
		final String time = DATE_FORMAT.format(today);
		new LogFileManager("+++++++++++++++ Program opened at [" + time + "] +++++++++++++++");
	}

	/**
	 * Returns if a log will be the first message displayed.
	 * @return
	 */
	public static boolean isFirstLogMessage() {
		return firstLogMessage;
	}

	/**
	 * Sets if a log will be the first message displayed.
	 * @param firstLogMessage
	 */
	public static void setFirstLogMessage(final boolean firstLogMessage) {
		Jerry.firstLogMessage = firstLogMessage;
	}

	/**
	 * Returns the operating system of the system running the program
	 * @return String of operating system
	 */
	public static String getOperatingSystem() {
		final String system = System.getProperty("os.name").toLowerCase();
		if (system.indexOf("win") >= 0) {
			return("Windows");
		} else if (system.indexOf("mac") >= 0) {
			return("Mac");
		} else {
			return("Default");
		}
	}
}


text:
In order to work, this project needs an api key from [football-data](http://api.football-data.org/index).
You must put it in the gradle.properties file (located at the root of this project) with the key `FOOTBALL_SCORES_API_TOKEN`

    FOOTBALL_SCORES_API_TOKEN="Your API key here"


text:
import { ApproxStructure, Assertions } from '@ephox/agar';
import { describe, it } from '@ephox/bedrock-client';
import { TinyHooks, TinyUiActions } from '@ephox/wrap-mcagar';

import Editor from 'tinymce/core/api/Editor';

describe('browser.tinymce.themes.silver.editor.MenuGroupHeadingTest', () => {
  const hook = TinyHooks.bddSetupLight<Editor>({
    base_url: '/project/tinymce/js/tinymce',
    toolbar: 'styles',
    style_formats: [
      { title: 'Bold text', inline: 'b' },
      { title: 'Table styles' },
      { title: 'Table row 1', selector: 'tr', classes: 'tablerow1' }
    ]
  }, []);

  it('TINY-2226: Menu should contain a group heading with the correct classes and text', async () => {
    const editor = hook.editor();
    TinyUiActions.clickOnToolbar(editor, 'button');
    const menu = await TinyUiActions.pWaitForUi(editor, '.tox-menu.tox-collection');
    Assertions.assertStructure(
      'Container structure',
      ApproxStructure.build((s, str, arr) => s.element('div', {
        classes: [ arr.has('tox-menu'), arr.has('tox-collection'), arr.has('tox-collection--list'), arr.has('tox-selected-menu') ],
        children: [
          s.element('div', {
            classes: [ arr.has('tox-collection__group') ],
            children: [
              s.element('div', {
                classes: [ arr.has('tox-menu-nav__js'), arr.has('tox-collection__item') ]
              })
            ]
          }),
          s.element('div', {
            classes: [ arr.has('tox-collection__group') ],
            children: [
              s.element('div', {
                classes: [ arr.has('tox-collection__item'), arr.has('tox-collection__group-heading') ],
                children: [ s.text(str.is('Table styles')) ]
              }),
              s.element('div', {
                classes: [ arr.has('tox-menu-nav__js'), arr.has('tox-collection__item') ]
              })
            ]
          })
        ]
      })),
      menu
    );
  });
});