text: /**
   * PowerMeter API
   * API
   *
   * The version of the OpenAPI document: 2021.4.1
   *
   * NOTE: This class is auto generated by OpenAPI-Generator 4.3.1.
   * https://openapi-generator.tech
   * Do not edit the class manually.
   */
  
  
  
  #include "Package.h"
  
  namespace powermeter {
  namespace model {
  
  
  
  
  Package::Package()
  {
      m_Id = 0;
      m_IdIsSet = false;
      m_Name = utility::conversions::to_string_t("");
      m_NameIsSet = false;
      m_Descr = utility::conversions::to_string_t("");
      m_DescrIsSet = false;
      m_Editable = false;
      m_EditableIsSet = false;
      m_Current_version = 0;
      m_Current_versionIsSet = false;
      m_VersionIsSet = false;
      m_Width = 0.0;
      m_WidthIsSet = false;
      m_Height = 0.0;
      m_HeightIsSet = false;
      m_Die_width_min = 0.0;
      m_Die_width_minIsSet = false;
      m_Die_width_max = 0.0;
      m_Die_width_maxIsSet = false;
      m_Die_height_min = 0.0;
      m_Die_height_minIsSet = false;
      m_Die_height_max = 0.0;
      m_Die_height_maxIsSet = false;
      m_Heatspreader_samesize = false;
      m_Heatspreader_samesizeIsSet = false;
      m_Heatspreader_width = 0.0;
      m_Heatspreader_widthIsSet = false;
      m_Heatspreader_height = 0.0;
      m_Heatspreader_heightIsSet = false;
      m_Heatspreader_thickness = 0.0;
      m_Heatspreader_thicknessIsSet = false;
      m_Heatspreader_conductivity = 0.0;
      m_Heatspreader_conductivityIsSet = false;
      m_Heatspreader_heatcapacity = 0.0;
      m_Heatspreader_heatcapacityIsSet = false;
      m_Tim_thickness = 0.0;
      m_Tim_thicknessIsSet = false;
      m_Tim_conductivity = 0.0;
      m_Tim_conductivityIsSet = false;
      m_Tim_heatcapacity = 0.0;
      m_Tim_heatcapacityIsSet = false;
      m_Underfill_thickness = 0.0;
      m_Underfill_thicknessIsSet = false;
      m_C4_width = 0.0;
      m_C4_widthIsSet = false;
      m_C4_number = 0;
      m_C4_numberIsSet = false;
      m_C4_conductivity = 0.0;
      m_C4_conductivityIsSet = false;
      m_C4_heatcapacity = 0.0;
      m_C4_heatcapacityIsSet = false;
      m_Substrate_samesize = false;
      m_Substrate_samesizeIsSet = false;
      m_Substrate_width = 0.0;
      m_Substrate_widthIsSet = false;
      m_Substrate_height = 0.0;
      m_Substrate_heightIsSet = false;
      m_Substrate_thickness = 0.0;
      m_Substrate_thicknessIsSet = false;
      m_Substrate_conductivity = 0.0;
      m_Substrate_conductivityIsSet = false;
      m_Substrate_heatcapacity = 0.0;
      m_Substrate_heatcapacityIsSet = false;
      m_Solderball_samesize = false;
      m_Solderball_samesizeIsSet = false;
      m_Solderball_width = 0.0;
      m_Solderball_widthIsSet = false;
      m_Solderball_height = 0.0;
      m_Solderball_heightIsSet = false;
      m_Solderball_thickness = 0.0;
      m_Solderball_thicknessIsSet = false;
      m_Solderball_conductivity = 0.0;
      m_Solderball_conductivityIsSet = false;
      m_Solderball_heatcapacity = 0.0;
      m_Solderball_heatcapacityIsSet = false;
  }
  
  Package::~Package()
  {
  }
  
  void Package::validate()
  {
      // TODO: implement validation
  }
  
  web::json::value Package::toJson() const
  {
  
      web::json::value val = web::json::value::object();
      
      if(m_IdIsSet)
      {
          val[utility::conversions::to_string_t("id")] = ModelBase::toJson(m_Id);
      }
      if(m_NameIsSet)
      {
          val[utility::conversions::to_string_t("name")] = ModelBase::toJson(m_Name);
      }
      if(m_DescrIsSet)
      {
          val[utility::conversions::to_string_t("descr")] = ModelBase::toJson(m_Descr);
      }
      if(m_EditableIsSet)
      {
          val[utility::conversions::to_string_t("editable")] = ModelBase::toJson(m_Editable);
      }
      if(m_Current_versionIsSet)
      {
          val[utility::conversions::to_string_t("current_version")] = ModelBase::toJson(m_Current_version);
      }
      if(m_VersionIsSet)
      {
          val[utility::conversions::to_string_t("version")] = ModelBase::toJson(m_Version);
      }
      if(m_WidthIsSet)
      {
          val[utility::conversions::to_string_t("width")] = ModelBase::toJson(m_Width);
      }
      if(m_HeightIsSet)
      {
          val[utility::conversions::to_string_t("height")] = ModelBase::toJson(m_Height);
      }
      if(m_Die_width_minIsSet)
      {
          val[utility::conversions::to_string_t("die_width_min")] = ModelBase::toJson(m_Die_width_min);
      }
      if(m_Die_width_maxIsSet)
      {
          val[utility::conversions::to_string_t("die_width_max")] = ModelBase::toJson(m_Die_width_max);
      }
      if(m_Die_height_minIsSet)
      {
          val[utility::conversions::to_string_t("die_height_min")] = ModelBase::toJson(m_Die_height_min);
      }
      if(m_Die_height_maxIsSet)
      {
          val[utility::conversions::to_string_t("die_height_max")] = ModelBase::toJson(m_Die_height_max);
      }
      if(m_Heatspreader_samesizeIsSet)
      {
          val[utility::conversions::to_string_t("heatspreader_samesize")] = ModelBase::toJson(m_Heatspreader_samesize);
      }
      if(m_Heatspreader_widthIsSet)
      {
          val[utility::conversions::to_string_t("heatspreader_width")] = ModelBase::toJson(m_Heatspreader_width);
      }
      if(m_Heatspreader_heightIsSet)
      {
          val[utility::conversions::to_string_t("heatspreader_height")] = ModelBase::toJson(m_Heatspreader_height);
      }
      if(m_Heatspreader_thicknessIsSet)
      {
          val[utility::conversions::to_string_t("heatspreader_thickness")] = ModelBase::toJson(m_Heatspreader_thickness);
      }
      if(m_Heatspreader_conductivityIsSet)
      {
          val[utility::conversions::to_string_t("heatspreader_conductivity")] = ModelBase::toJson(m_Heatspreader_conductivity);
      }
      if(m_Heatspreader_heatcapacityIsSet)
      {
          val[utility::conversions::to_string_t("heatspreader_heatcapacity")] = ModelBase::toJson(m_Heatspreader_heatcapacity);
      }
      if(m_Tim_thicknessIsSet)
      {
          val[utility::conversions::to_string_t("tim_thickness")] = ModelBase::toJson(m_Tim_thickness);
      }
      if(m_Tim_conductivityIsSet)
      {
          val[utility::conversions::to_string_t("tim_conductivity")] = ModelBase::toJson(m_Tim_conductivity);
      }
      if(m_Tim_heatcapacityIsSet)
      {
          val[utility::conversions::to_string_t("tim_heatcapacity")] = ModelBase::toJson(m_Tim_heatcapacity);
      }
      if(m_Underfill_thicknessIsSet)
      {
          val[utility::conversions::to_string_t("underfill_thickness")] = ModelBase::toJson(m_Underfill_thickness);
      }
      if(m_C4_widthIsSet)
      {
          val[utility::conversions::to_string_t("c4_width")] = ModelBase::toJson(m_C4_width);
      }
      if(m_C4_numberIsSet)
      {
          val[utility::conversions::to_string_t("c4_number")] = ModelBase::toJson(m_C4_number);
      }
      if(m_C4_conductivityIsSet)
      {
          val[utility::conversions::to_string_t("c4_conductivity")] = ModelBase::toJson(m_C4_conductivity);
      }
      if(m_C4_heatcapacityIsSet)
      {
          val[utility::conversions::to_string_t("c4_heatcapacity")] = ModelBase::toJson(m_C4_heatcapacity);
      }
      if(m_Substrate_samesizeIsSet)
      {
          val[utility::conversions::to_string_t("substrate_samesize")] = ModelBase::toJson(m_Substrate_samesize);
      }
      if(m_Substrate_widthIsSet)
      {
          val[utility::conversions::to_string_t("substrate_width")] = ModelBase::toJson(m_Substrate_width);
      }
      if(m_Substrate_heightIsSet)
      {
          val[utility::conversions::to_string_t("substrate_height")] = ModelBase::toJson(m_Substrate_height);
      }
      if(m_Substrate_thicknessIsSet)
      {
          val[utility::conversions::to_string_t("substrate_thickness")] = ModelBase::toJson(m_Substrate_thickness);
      }
      if(m_Substrate_conductivityIsSet)
      {
          val[utility::conversions::to_string_t("substrate_conductivity")] = ModelBase::toJson(m_Substrate_conductivity);
      }
      if(m_Substrate_heatcapacityIsSet)
      {
          val[utility::conversions::to_string_t("substrate_heatcapacity")] = ModelBase::toJson(m_Substrate_heatcapacity);
      }
      if(m_Solderball_samesizeIsSet)
      {
          val[utility::conversions::to_string_t("solderball_samesize")] = ModelBase::toJson(m_Solderball_samesize);
      }
      if(m_Solderball_widthIsSet)
      {
          val[utility::conversions::to_string_t("solderball_width")] = ModelBase::toJson(m_Solderball_width);
      }
      if(m_Solderball_heightIsSet)
      {
          val[utility::conversions::to_string_t("solderball_height")] = ModelBase::toJson(m_Solderball_height);
      }
      if(m_Solderball_thicknessIsSet)
      {
          val[utility::conversions::to_string_t("solderball_thickness")] = ModelBase::toJson(m_Solderball_thickness);
      }
      if(m_Solderball_conductivityIsSet)
      {
          val[utility::conversions::to_string_t("solderball_conductivity")] = ModelBase::toJson(m_Solderball_conductivity);
      }
      if(m_Solderball_heatcapacityIsSet)
      {
          val[utility::conversions::to_string_t("solderball_heatcapacity")] = ModelBase::toJson(m_Solderball_heatcapacity);
      }
  
      return val;
  }
  
  bool Package::fromJson(const web::json::value& val)
  {
      bool ok = true;
      
      if(val.has_field(utility::conversions::to_string_t("id")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("id"));
          if(!fieldValue.is_null())
          {
              int32_t refVal_id;
              ok &= ModelBase::fromJson(fieldValue, refVal_id);
              setId(refVal_id);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("name")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("name"));
          if(!fieldValue.is_null())
          {
              utility::string_t refVal_name;
              ok &= ModelBase::fromJson(fieldValue, refVal_name);
              setName(refVal_name);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("descr")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("descr"));
          if(!fieldValue.is_null())
          {
              utility::string_t refVal_descr;
              ok &= ModelBase::fromJson(fieldValue, refVal_descr);
              setDescr(refVal_descr);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("editable")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("editable"));
          if(!fieldValue.is_null())
          {
              bool refVal_editable;
              ok &= ModelBase::fromJson(fieldValue, refVal_editable);
              setEditable(refVal_editable);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("current_version")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("current_version"));
          if(!fieldValue.is_null())
          {
              int32_t refVal_current_version;
              ok &= ModelBase::fromJson(fieldValue, refVal_current_version);
              setCurrentVersion(refVal_current_version);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("version")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("version"));
          if(!fieldValue.is_null())
          {
              std::shared_ptr<PackageVersion> refVal_version;
              ok &= ModelBase::fromJson(fieldValue, refVal_version);
              setVersion(refVal_version);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("width")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("width"));
          if(!fieldValue.is_null())
          {
              double refVal_width;
              ok &= ModelBase::fromJson(fieldValue, refVal_width);
              setWidth(refVal_width);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("height")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("height"));
          if(!fieldValue.is_null())
          {
              double refVal_height;
              ok &= ModelBase::fromJson(fieldValue, refVal_height);
              setHeight(refVal_height);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("die_width_min")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("die_width_min"));
          if(!fieldValue.is_null())
          {
              double refVal_die_width_min;
              ok &= ModelBase::fromJson(fieldValue, refVal_die_width_min);
              setDieWidthMin(refVal_die_width_min);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("die_width_max")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("die_width_max"));
          if(!fieldValue.is_null())
          {
              double refVal_die_width_max;
              ok &= ModelBase::fromJson(fieldValue, refVal_die_width_max);
              setDieWidthMax(refVal_die_width_max);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("die_height_min")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("die_height_min"));
          if(!fieldValue.is_null())
          {
              double refVal_die_height_min;
              ok &= ModelBase::fromJson(fieldValue, refVal_die_height_min);
              setDieHeightMin(refVal_die_height_min);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("die_height_max")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("die_height_max"));
          if(!fieldValue.is_null())
          {
              double refVal_die_height_max;
              ok &= ModelBase::fromJson(fieldValue, refVal_die_height_max);
              setDieHeightMax(refVal_die_height_max);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("heatspreader_samesize")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("heatspreader_samesize"));
          if(!fieldValue.is_null())
          {
              bool refVal_heatspreader_samesize;
              ok &= ModelBase::fromJson(fieldValue, refVal_heatspreader_samesize);
              setHeatspreaderSamesize(refVal_heatspreader_samesize);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("heatspreader_width")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("heatspreader_width"));
          if(!fieldValue.is_null())
          {
              double refVal_heatspreader_width;
              ok &= ModelBase::fromJson(fieldValue, refVal_heatspreader_width);
              setHeatspreaderWidth(refVal_heatspreader_width);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("heatspreader_height")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("heatspreader_height"));
          if(!fieldValue.is_null())
          {
              double refVal_heatspreader_height;
              ok &= ModelBase::fromJson(fieldValue, refVal_heatspreader_height);
              setHeatspreaderHeight(refVal_heatspreader_height);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("heatspreader_thickness")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("heatspreader_thickness"));
          if(!fieldValue.is_null())
          {
              double refVal_heatspreader_thickness;
              ok &= ModelBase::fromJson(fieldValue, refVal_heatspreader_thickness);
              setHeatspreaderThickness(refVal_heatspreader_thickness);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("heatspreader_conductivity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("heatspreader_conductivity"));
          if(!fieldValue.is_null())
          {
              double refVal_heatspreader_conductivity;
              ok &= ModelBase::fromJson(fieldValue, refVal_heatspreader_conductivity);
              setHeatspreaderConductivity(refVal_heatspreader_conductivity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("heatspreader_heatcapacity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("heatspreader_heatcapacity"));
          if(!fieldValue.is_null())
          {
              double refVal_heatspreader_heatcapacity;
              ok &= ModelBase::fromJson(fieldValue, refVal_heatspreader_heatcapacity);
              setHeatspreaderHeatcapacity(refVal_heatspreader_heatcapacity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("tim_thickness")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("tim_thickness"));
          if(!fieldValue.is_null())
          {
              double refVal_tim_thickness;
              ok &= ModelBase::fromJson(fieldValue, refVal_tim_thickness);
              setTimThickness(refVal_tim_thickness);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("tim_conductivity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("tim_conductivity"));
          if(!fieldValue.is_null())
          {
              double refVal_tim_conductivity;
              ok &= ModelBase::fromJson(fieldValue, refVal_tim_conductivity);
              setTimConductivity(refVal_tim_conductivity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("tim_heatcapacity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("tim_heatcapacity"));
          if(!fieldValue.is_null())
          {
              double refVal_tim_heatcapacity;
              ok &= ModelBase::fromJson(fieldValue, refVal_tim_heatcapacity);
              setTimHeatcapacity(refVal_tim_heatcapacity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("underfill_thickness")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("underfill_thickness"));
          if(!fieldValue.is_null())
          {
              double refVal_underfill_thickness;
              ok &= ModelBase::fromJson(fieldValue, refVal_underfill_thickness);
              setUnderfillThickness(refVal_underfill_thickness);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("c4_width")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("c4_width"));
          if(!fieldValue.is_null())
          {
              double refVal_c4_width;
              ok &= ModelBase::fromJson(fieldValue, refVal_c4_width);
              setC4Width(refVal_c4_width);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("c4_number")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("c4_number"));
          if(!fieldValue.is_null())
          {
              int32_t refVal_c4_number;
              ok &= ModelBase::fromJson(fieldValue, refVal_c4_number);
              setC4Number(refVal_c4_number);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("c4_conductivity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("c4_conductivity"));
          if(!fieldValue.is_null())
          {
              double refVal_c4_conductivity;
              ok &= ModelBase::fromJson(fieldValue, refVal_c4_conductivity);
              setC4Conductivity(refVal_c4_conductivity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("c4_heatcapacity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("c4_heatcapacity"));
          if(!fieldValue.is_null())
          {
              double refVal_c4_heatcapacity;
              ok &= ModelBase::fromJson(fieldValue, refVal_c4_heatcapacity);
              setC4Heatcapacity(refVal_c4_heatcapacity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("substrate_samesize")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("substrate_samesize"));
          if(!fieldValue.is_null())
          {
              bool refVal_substrate_samesize;
              ok &= ModelBase::fromJson(fieldValue, refVal_substrate_samesize);
              setSubstrateSamesize(refVal_substrate_samesize);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("substrate_width")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("substrate_width"));
          if(!fieldValue.is_null())
          {
              double refVal_substrate_width;
              ok &= ModelBase::fromJson(fieldValue, refVal_substrate_width);
              setSubstrateWidth(refVal_substrate_width);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("substrate_height")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("substrate_height"));
          if(!fieldValue.is_null())
          {
              double refVal_substrate_height;
              ok &= ModelBase::fromJson(fieldValue, refVal_substrate_height);
              setSubstrateHeight(refVal_substrate_height);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("substrate_thickness")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("substrate_thickness"));
          if(!fieldValue.is_null())
          {
              double refVal_substrate_thickness;
              ok &= ModelBase::fromJson(fieldValue, refVal_substrate_thickness);
              setSubstrateThickness(refVal_substrate_thickness);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("substrate_conductivity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("substrate_conductivity"));
          if(!fieldValue.is_null())
          {
              double refVal_substrate_conductivity;
              ok &= ModelBase::fromJson(fieldValue, refVal_substrate_conductivity);
              setSubstrateConductivity(refVal_substrate_conductivity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("substrate_heatcapacity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("substrate_heatcapacity"));
          if(!fieldValue.is_null())
          {
              double refVal_substrate_heatcapacity;
              ok &= ModelBase::fromJson(fieldValue, refVal_substrate_heatcapacity);
              setSubstrateHeatcapacity(refVal_substrate_heatcapacity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("solderball_samesize")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("solderball_samesize"));
          if(!fieldValue.is_null())
          {
              bool refVal_solderball_samesize;
              ok &= ModelBase::fromJson(fieldValue, refVal_solderball_samesize);
              setSolderballSamesize(refVal_solderball_samesize);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("solderball_width")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("solderball_width"));
          if(!fieldValue.is_null())
          {
              double refVal_solderball_width;
              ok &= ModelBase::fromJson(fieldValue, refVal_solderball_width);
              setSolderballWidth(refVal_solderball_width);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("solderball_height")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("solderball_height"));
          if(!fieldValue.is_null())
          {
              double refVal_solderball_height;
              ok &= ModelBase::fromJson(fieldValue, refVal_solderball_height);
              setSolderballHeight(refVal_solderball_height);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("solderball_thickness")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("solderball_thickness"));
          if(!fieldValue.is_null())
          {
              double refVal_solderball_thickness;
              ok &= ModelBase::fromJson(fieldValue, refVal_solderball_thickness);
              setSolderballThickness(refVal_solderball_thickness);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("solderball_conductivity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("solderball_conductivity"));
          if(!fieldValue.is_null())
          {
              double refVal_solderball_conductivity;
              ok &= ModelBase::fromJson(fieldValue, refVal_solderball_conductivity);
              setSolderballConductivity(refVal_solderball_conductivity);
          }
      }
      if(val.has_field(utility::conversions::to_string_t("solderball_heatcapacity")))
      {
          const web::json::value& fieldValue = val.at(utility::conversions::to_string_t("solderball_heatcapacity"));
          if(!fieldValue.is_null())
          {
              double refVal_solderball_heatcapacity;
              ok &= ModelBase::fromJson(fieldValue, refVal_solderball_heatcapacity);
              setSolderballHeatcapacity(refVal_solderball_heatcapacity);
          }
      }
      return ok;
  }
  
  void Package::toMultipart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& prefix) const
  {
      utility::string_t namePrefix = prefix;
      if(namePrefix.size() > 0 && namePrefix.substr(namePrefix.size() - 1) != utility::conversions::to_string_t("."))
      {
          namePrefix += utility::conversions::to_string_t(".");
      }
      if(m_IdIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("id"), m_Id));
      }
      if(m_NameIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("name"), m_Name));
      }
      if(m_DescrIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("descr"), m_Descr));
      }
      if(m_EditableIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("editable"), m_Editable));
      }
      if(m_Current_versionIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("current_version"), m_Current_version));
      }
      if(m_VersionIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("version"), m_Version));
      }
      if(m_WidthIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("width"), m_Width));
      }
      if(m_HeightIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("height"), m_Height));
      }
      if(m_Die_width_minIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("die_width_min"), m_Die_width_min));
      }
      if(m_Die_width_maxIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("die_width_max"), m_Die_width_max));
      }
      if(m_Die_height_minIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("die_height_min"), m_Die_height_min));
      }
      if(m_Die_height_maxIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("die_height_max"), m_Die_height_max));
      }
      if(m_Heatspreader_samesizeIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("heatspreader_samesize"), m_Heatspreader_samesize));
      }
      if(m_Heatspreader_widthIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("heatspreader_width"), m_Heatspreader_width));
      }
      if(m_Heatspreader_heightIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("heatspreader_height"), m_Heatspreader_height));
      }
      if(m_Heatspreader_thicknessIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("heatspreader_thickness"), m_Heatspreader_thickness));
      }
      if(m_Heatspreader_conductivityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("heatspreader_conductivity"), m_Heatspreader_conductivity));
      }
      if(m_Heatspreader_heatcapacityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("heatspreader_heatcapacity"), m_Heatspreader_heatcapacity));
      }
      if(m_Tim_thicknessIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("tim_thickness"), m_Tim_thickness));
      }
      if(m_Tim_conductivityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("tim_conductivity"), m_Tim_conductivity));
      }
      if(m_Tim_heatcapacityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("tim_heatcapacity"), m_Tim_heatcapacity));
      }
      if(m_Underfill_thicknessIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("underfill_thickness"), m_Underfill_thickness));
      }
      if(m_C4_widthIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("c4_width"), m_C4_width));
      }
      if(m_C4_numberIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("c4_number"), m_C4_number));
      }
      if(m_C4_conductivityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("c4_conductivity"), m_C4_conductivity));
      }
      if(m_C4_heatcapacityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("c4_heatcapacity"), m_C4_heatcapacity));
      }
      if(m_Substrate_samesizeIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("substrate_samesize"), m_Substrate_samesize));
      }
      if(m_Substrate_widthIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("substrate_width"), m_Substrate_width));
      }
      if(m_Substrate_heightIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("substrate_height"), m_Substrate_height));
      }
      if(m_Substrate_thicknessIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("substrate_thickness"), m_Substrate_thickness));
      }
      if(m_Substrate_conductivityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("substrate_conductivity"), m_Substrate_conductivity));
      }
      if(m_Substrate_heatcapacityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("substrate_heatcapacity"), m_Substrate_heatcapacity));
      }
      if(m_Solderball_samesizeIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("solderball_samesize"), m_Solderball_samesize));
      }
      if(m_Solderball_widthIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("solderball_width"), m_Solderball_width));
      }
      if(m_Solderball_heightIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("solderball_height"), m_Solderball_height));
      }
      if(m_Solderball_thicknessIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("solderball_thickness"), m_Solderball_thickness));
      }
      if(m_Solderball_conductivityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("solderball_conductivity"), m_Solderball_conductivity));
      }
      if(m_Solderball_heatcapacityIsSet)
      {
          multipart->add(ModelBase::toHttpContent(namePrefix + utility::conversions::to_string_t("solderball_heatcapacity"), m_Solderball_heatcapacity));
      }
  }
  
  bool Package::fromMultiPart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& prefix)
  {
      bool ok = true;
      utility::string_t namePrefix = prefix;
      if(namePrefix.size() > 0 && namePrefix.substr(namePrefix.size() - 1) != utility::conversions::to_string_t("."))
      {
          namePrefix += utility::conversions::to_string_t(".");
      }
  
      if(multipart->hasContent(utility::conversions::to_string_t("id")))
      {
          int32_t refVal_id;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("id")), refVal_id );
          setId(refVal_id);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("name")))
      {
          utility::string_t refVal_name;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("name")), refVal_name );
          setName(refVal_name);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("descr")))
      {
          utility::string_t refVal_descr;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("descr")), refVal_descr );
          setDescr(refVal_descr);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("editable")))
      {
          bool refVal_editable;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("editable")), refVal_editable );
          setEditable(refVal_editable);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("current_version")))
      {
          int32_t refVal_current_version;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("current_version")), refVal_current_version );
          setCurrentVersion(refVal_current_version);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("version")))
      {
          std::shared_ptr<PackageVersion> refVal_version;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("version")), refVal_version );
          setVersion(refVal_version);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("width")))
      {
          double refVal_width;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("width")), refVal_width );
          setWidth(refVal_width);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("height")))
      {
          double refVal_height;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("height")), refVal_height );
          setHeight(refVal_height);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("die_width_min")))
      {
          double refVal_die_width_min;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("die_width_min")), refVal_die_width_min );
          setDieWidthMin(refVal_die_width_min);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("die_width_max")))
      {
          double refVal_die_width_max;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("die_width_max")), refVal_die_width_max );
          setDieWidthMax(refVal_die_width_max);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("die_height_min")))
      {
          double refVal_die_height_min;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("die_height_min")), refVal_die_height_min );
          setDieHeightMin(refVal_die_height_min);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("die_height_max")))
      {
          double refVal_die_height_max;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("die_height_max")), refVal_die_height_max );
          setDieHeightMax(refVal_die_height_max);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("heatspreader_samesize")))
      {
          bool refVal_heatspreader_samesize;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("heatspreader_samesize")), refVal_heatspreader_samesize );
          setHeatspreaderSamesize(refVal_heatspreader_samesize);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("heatspreader_width")))
      {
          double refVal_heatspreader_width;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("heatspreader_width")), refVal_heatspreader_width );
          setHeatspreaderWidth(refVal_heatspreader_width);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("heatspreader_height")))
      {
          double refVal_heatspreader_height;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("heatspreader_height")), refVal_heatspreader_height );
          setHeatspreaderHeight(refVal_heatspreader_height);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("heatspreader_thickness")))
      {
          double refVal_heatspreader_thickness;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("heatspreader_thickness")), refVal_heatspreader_thickness );
          setHeatspreaderThickness(refVal_heatspreader_thickness);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("heatspreader_conductivity")))
      {
          double refVal_heatspreader_conductivity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("heatspreader_conductivity")), refVal_heatspreader_conductivity );
          setHeatspreaderConductivity(refVal_heatspreader_conductivity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("heatspreader_heatcapacity")))
      {
          double refVal_heatspreader_heatcapacity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("heatspreader_heatcapacity")), refVal_heatspreader_heatcapacity );
          setHeatspreaderHeatcapacity(refVal_heatspreader_heatcapacity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("tim_thickness")))
      {
          double refVal_tim_thickness;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("tim_thickness")), refVal_tim_thickness );
          setTimThickness(refVal_tim_thickness);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("tim_conductivity")))
      {
          double refVal_tim_conductivity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("tim_conductivity")), refVal_tim_conductivity );
          setTimConductivity(refVal_tim_conductivity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("tim_heatcapacity")))
      {
          double refVal_tim_heatcapacity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("tim_heatcapacity")), refVal_tim_heatcapacity );
          setTimHeatcapacity(refVal_tim_heatcapacity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("underfill_thickness")))
      {
          double refVal_underfill_thickness;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("underfill_thickness")), refVal_underfill_thickness );
          setUnderfillThickness(refVal_underfill_thickness);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("c4_width")))
      {
          double refVal_c4_width;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("c4_width")), refVal_c4_width );
          setC4Width(refVal_c4_width);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("c4_number")))
      {
          int32_t refVal_c4_number;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("c4_number")), refVal_c4_number );
          setC4Number(refVal_c4_number);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("c4_conductivity")))
      {
          double refVal_c4_conductivity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("c4_conductivity")), refVal_c4_conductivity );
          setC4Conductivity(refVal_c4_conductivity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("c4_heatcapacity")))
      {
          double refVal_c4_heatcapacity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("c4_heatcapacity")), refVal_c4_heatcapacity );
          setC4Heatcapacity(refVal_c4_heatcapacity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("substrate_samesize")))
      {
          bool refVal_substrate_samesize;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("substrate_samesize")), refVal_substrate_samesize );
          setSubstrateSamesize(refVal_substrate_samesize);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("substrate_width")))
      {
          double refVal_substrate_width;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("substrate_width")), refVal_substrate_width );
          setSubstrateWidth(refVal_substrate_width);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("substrate_height")))
      {
          double refVal_substrate_height;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("substrate_height")), refVal_substrate_height );
          setSubstrateHeight(refVal_substrate_height);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("substrate_thickness")))
      {
          double refVal_substrate_thickness;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("substrate_thickness")), refVal_substrate_thickness );
          setSubstrateThickness(refVal_substrate_thickness);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("substrate_conductivity")))
      {
          double refVal_substrate_conductivity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("substrate_conductivity")), refVal_substrate_conductivity );
          setSubstrateConductivity(refVal_substrate_conductivity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("substrate_heatcapacity")))
      {
          double refVal_substrate_heatcapacity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("substrate_heatcapacity")), refVal_substrate_heatcapacity );
          setSubstrateHeatcapacity(refVal_substrate_heatcapacity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("solderball_samesize")))
      {
          bool refVal_solderball_samesize;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("solderball_samesize")), refVal_solderball_samesize );
          setSolderballSamesize(refVal_solderball_samesize);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("solderball_width")))
      {
          double refVal_solderball_width;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("solderball_width")), refVal_solderball_width );
          setSolderballWidth(refVal_solderball_width);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("solderball_height")))
      {
          double refVal_solderball_height;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("solderball_height")), refVal_solderball_height );
          setSolderballHeight(refVal_solderball_height);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("solderball_thickness")))
      {
          double refVal_solderball_thickness;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("solderball_thickness")), refVal_solderball_thickness );
          setSolderballThickness(refVal_solderball_thickness);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("solderball_conductivity")))
      {
          double refVal_solderball_conductivity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("solderball_conductivity")), refVal_solderball_conductivity );
          setSolderballConductivity(refVal_solderball_conductivity);
      }
      if(multipart->hasContent(utility::conversions::to_string_t("solderball_heatcapacity")))
      {
          double refVal_solderball_heatcapacity;
          ok &= ModelBase::fromHttpContent(multipart->getContent(utility::conversions::to_string_t("solderball_heatcapacity")), refVal_solderball_heatcapacity );
          setSolderballHeatcapacity(refVal_solderball_heatcapacity);
      }
      return ok;
  }
  
  int32_t Package::getId() const
  {
      return m_Id;
  }
  
  void Package::setId(int32_t value)
  {
      m_Id = value;
      m_IdIsSet = true;
  }
  
  bool Package::idIsSet() const
  {
      return m_IdIsSet;
  }
  
  void Package::unsetId()
  {
      m_IdIsSet = false;
  }
  utility::string_t Package::getName() const
  {
      return m_Name;
  }
  
  void Package::setName(const utility::string_t& value)
  {
      m_Name = value;
      m_NameIsSet = true;
  }
  
  bool Package::nameIsSet() const
  {
      return m_NameIsSet;
  }
  
  void Package::unsetName()
  {
      m_NameIsSet = false;
  }
  utility::string_t Package::getDescr() const
  {
      return m_Descr;
  }
  
  void Package::setDescr(const utility::string_t& value)
  {
      m_Descr = value;
      m_DescrIsSet = true;
  }
  
  bool Package::descrIsSet() const
  {
      return m_DescrIsSet;
  }
  
  void Package::unsetDescr()
  {
      m_DescrIsSet = false;
  }
  bool Package::isEditable() const
  {
      return m_Editable;
  }
  
  void Package::setEditable(bool value)
  {
      m_Editable = value;
      m_EditableIsSet = true;
  }
  
  bool Package::editableIsSet() const
  {
      return m_EditableIsSet;
  }
  
  void Package::unsetEditable()
  {
      m_EditableIsSet = false;
  }
  int32_t Package::getCurrentVersion() const
  {
      return m_Current_version;
  }
  
  void Package::setCurrentVersion(int32_t value)
  {
      m_Current_version = value;
      m_Current_versionIsSet = true;
  }
  
  bool Package::currentVersionIsSet() const
  {
      return m_Current_versionIsSet;
  }
  
  void Package::unsetCurrent_version()
  {
      m_Current_versionIsSet = false;
  }
  std::shared_ptr<PackageVersion> Package::getVersion() const
  {
      return m_Version;
  }
  
  void Package::setVersion(const std::shared_ptr<PackageVersion>& value)
  {
      m_Version = value;
      m_VersionIsSet = true;
  }
  
  bool Package::versionIsSet() const
  {
      return m_VersionIsSet;
  }
  
  void Package::unsetVersion()
  {
      m_VersionIsSet = false;
  }
  double Package::getWidth() const
  {
      return m_Width;
  }
  
  void Package::setWidth(double value)
  {
      m_Width = value;
      m_WidthIsSet = true;
  }
  
  bool Package::widthIsSet() const
  {
      return m_WidthIsSet;
  }
  
  void Package::unsetWidth()
  {
      m_WidthIsSet = false;
  }
  double Package::getHeight() const
  {
      return m_Height;
  }
  
  void Package::setHeight(double value)
  {
      m_Height = value;
      m_HeightIsSet = true;
  }
  
  bool Package::heightIsSet() const
  {
      return m_HeightIsSet;
  }
  
  void Package::unsetHeight()
  {
      m_HeightIsSet = false;
  }
  double Package::getDieWidthMin() const
  {
      return m_Die_width_min;
  }
  
  void Package::setDieWidthMin(double value)
  {
      m_Die_width_min = value;
      m_Die_width_minIsSet = true;
  }
  
  bool Package::dieWidthMinIsSet() const
  {
      return m_Die_width_minIsSet;
  }
  
  void Package::unsetDie_width_min()
  {
      m_Die_width_minIsSet = false;
  }
  double Package::getDieWidthMax() const
  {
      return m_Die_width_max;
  }
  
  void Package::setDieWidthMax(double value)
  {
      m_Die_width_max = value;
      m_Die_width_maxIsSet = true;
  }
  
  bool Package::dieWidthMaxIsSet() const
  {
      return m_Die_width_maxIsSet;
  }
  
  void Package::unsetDie_width_max()
  {
      m_Die_width_maxIsSet = false;
  }
  double Package::getDieHeightMin() const
  {
      return m_Die_height_min;
  }
  
  void Package::setDieHeightMin(double value)
  {
      m_Die_height_min = value;
      m_Die_height_minIsSet = true;
  }
  
  bool Package::dieHeightMinIsSet() const
  {
      return m_Die_height_minIsSet;
  }
  
  void Package::unsetDie_height_min()
  {
      m_Die_height_minIsSet = false;
  }
  double Package::getDieHeightMax() const
  {
      return m_Die_height_max;
  }
  
  void Package::setDieHeightMax(double value)
  {
      m_Die_height_max = value;
      m_Die_height_maxIsSet = true;
  }
  
  bool Package::dieHeightMaxIsSet() const
  {
      return m_Die_height_maxIsSet;
  }
  
  void Package::unsetDie_height_max()
  {
      m_Die_height_maxIsSet = false;
  }
  bool Package::isHeatspreaderSamesize() const
  {
      return m_Heatspreader_samesize;
  }
  
  void Package::setHeatspreaderSamesize(bool value)
  {
      m_Heatspreader_samesize = value;
      m_Heatspreader_samesizeIsSet = true;
  }
  
  bool Package::heatspreaderSamesizeIsSet() const
  {
      return m_Heatspreader_samesizeIsSet;
  }
  
  void Package::unsetHeatspreader_samesize()
  {
      m_Heatspreader_samesizeIsSet = false;
  }
  double Package::getHeatspreaderWidth() const
  {
      return m_Heatspreader_width;
  }
  
  void Package::setHeatspreaderWidth(double value)
  {
      m_Heatspreader_width = value;
      m_Heatspreader_widthIsSet = true;
  }
  
  bool Package::heatspreaderWidthIsSet() const
  {
      return m_Heatspreader_widthIsSet;
  }
  
  void Package::unsetHeatspreader_width()
  {
      m_Heatspreader_widthIsSet = false;
  }
  double Package::getHeatspreaderHeight() const
  {
      return m_Heatspreader_height;
  }
  
  void Package::setHeatspreaderHeight(double value)
  {
      m_Heatspreader_height = value;
      m_Heatspreader_heightIsSet = true;
  }
  
  bool Package::heatspreaderHeightIsSet() const
  {
      return m_Heatspreader_heightIsSet;
  }
  
  void Package::unsetHeatspreader_height()
  {
      m_Heatspreader_heightIsSet = false;
  }
  double Package::getHeatspreaderThickness() const
  {
      return m_Heatspreader_thickness;
  }
  
  void Package::setHeatspreaderThickness(double value)
  {
      m_Heatspreader_thickness = value;
      m_Heatspreader_thicknessIsSet = true;
  }
  
  bool Package::heatspreaderThicknessIsSet() const
  {
      return m_Heatspreader_thicknessIsSet;
  }
  
  void Package::unsetHeatspreader_thickness()
  {
      m_Heatspreader_thicknessIsSet = false;
  }
  double Package::getHeatspreaderConductivity() const
  {
      return m_Heatspreader_conductivity;
  }
  
  void Package::setHeatspreaderConductivity(double value)
  {
      m_Heatspreader_conductivity = value;
      m_Heatspreader_conductivityIsSet = true;
  }
  
  bool Package::heatspreaderConductivityIsSet() const
  {
      return m_Heatspreader_conductivityIsSet;
  }
  
  void Package::unsetHeatspreader_conductivity()
  {
      m_Heatspreader_conductivityIsSet = false;
  }
  double Package::getHeatspreaderHeatcapacity() const
  {
      return m_Heatspreader_heatcapacity;
  }
  
  void Package::setHeatspreaderHeatcapacity(double value)
  {
      m_Heatspreader_heatcapacity = value;
      m_Heatspreader_heatcapacityIsSet = true;
  }
  
  bool Package::heatspreaderHeatcapacityIsSet() const
  {
      return m_Heatspreader_heatcapacityIsSet;
  }
  
  void Package::unsetHeatspreader_heatcapacity()
  {
      m_Heatspreader_heatcapacityIsSet = false;
  }
  double Package::getTimThickness() const
  {
      return m_Tim_thickness;
  }
  
  void Package::setTimThickness(double value)
  {
      m_Tim_thickness = value;
      m_Tim_thicknessIsSet = true;
  }
  
  bool Package::timThicknessIsSet() const
  {
      return m_Tim_thicknessIsSet;
  }
  
  void Package::unsetTim_thickness()
  {
      m_Tim_thicknessIsSet = false;
  }
  double Package::getTimConductivity() const
  {
      return m_Tim_conductivity;
  }
  
  void Package::setTimConductivity(double value)
  {
      m_Tim_conductivity = value;
      m_Tim_conductivityIsSet = true;
  }
  
  bool Package::timConductivityIsSet() const
  {
      return m_Tim_conductivityIsSet;
  }
  
  void Package::unsetTim_conductivity()
  {
      m_Tim_conductivityIsSet = false;
  }
  double Package::getTimHeatcapacity() const
  {
      return m_Tim_heatcapacity;
  }
  
  void Package::setTimHeatcapacity(double value)
  {
      m_Tim_heatcapacity = value;
      m_Tim_heatcapacityIsSet = true;
  }
  
  bool Package::timHeatcapacityIsSet() const
  {
      return m_Tim_heatcapacityIsSet;
  }
  
  void Package::unsetTim_heatcapacity()
  {
      m_Tim_heatcapacityIsSet = false;
  }
  double Package::getUnderfillThickness() const
  {
      return m_Underfill_thickness;
  }
  
  void Package::setUnderfillThickness(double value)
  {
      m_Underfill_thickness = value;
      m_Underfill_thicknessIsSet = true;
  }
  
  bool Package::underfillThicknessIsSet() const
  {
      return m_Underfill_thicknessIsSet;
  }
  
  void Package::unsetUnderfill_thickness()
  {
      m_Underfill_thicknessIsSet = false;
  }
  double Package::getC4Width() const
  {
      return m_C4_width;
  }
  
  void Package::setC4Width(double value)
  {
      m_C4_width = value;
      m_C4_widthIsSet = true;
  }
  
  bool Package::c4WidthIsSet() const
  {
      return m_C4_widthIsSet;
  }
  
  void Package::unsetC4_width()
  {
      m_C4_widthIsSet = false;
  }
  int32_t Package::getC4Number() const
  {
      return m_C4_number;
  }
  
  void Package::setC4Number(int32_t value)
  {
      m_C4_number = value;
      m_C4_numberIsSet = true;
  }
  
  bool Package::c4NumberIsSet() const
  {
      return m_C4_numberIsSet;
  }
  
  void Package::unsetC4_number()
  {
      m_C4_numberIsSet = false;
  }
  double Package::getC4Conductivity() const
  {
      return m_C4_conductivity;
  }
  
  void Package::setC4Conductivity(double value)
  {
      m_C4_conductivity = value;
      m_C4_conductivityIsSet = true;
  }
  
  bool Package::c4ConductivityIsSet() const
  {
      return m_C4_conductivityIsSet;
  }
  
  void Package::unsetC4_conductivity()
  {
      m_C4_conductivityIsSet = false;
  }
  double Package::getC4Heatcapacity() const
  {
      return m_C4_heatcapacity;
  }
  
  void Package::setC4Heatcapacity(double value)
  {
      m_C4_heatcapacity = value;
      m_C4_heatcapacityIsSet = true;
  }
  
  bool Package::c4HeatcapacityIsSet() const
  {
      return m_C4_heatcapacityIsSet;
  }
  
  void Package::unsetC4_heatcapacity()
  {
      m_C4_heatcapacityIsSet = false;
  }
  bool Package::isSubstrateSamesize() const
  {
      return m_Substrate_samesize;
  }
  
  void Package::setSubstrateSamesize(bool value)
  {
      m_Substrate_samesize = value;
      m_Substrate_samesizeIsSet = true;
  }
  
  bool Package::substrateSamesizeIsSet() const
  {
      return m_Substrate_samesizeIsSet;
  }
  
  void Package::unsetSubstrate_samesize()
  {
      m_Substrate_samesizeIsSet = false;
  }
  double Package::getSubstrateWidth() const
  {
      return m_Substrate_width;
  }
  
  void Package::setSubstrateWidth(double value)
  {
      m_Substrate_width = value;
      m_Substrate_widthIsSet = true;
  }
  
  bool Package::substrateWidthIsSet() const
  {
      return m_Substrate_widthIsSet;
  }
  
  void Package::unsetSubstrate_width()
  {
      m_Substrate_widthIsSet = false;
  }
  double Package::getSubstrateHeight() const
  {
      return m_Substrate_height;
  }
  
  void Package::setSubstrateHeight(double value)
  {
      m_Substrate_height = value;
      m_Substrate_heightIsSet = true;
  }
  
  bool Package::substrateHeightIsSet() const
  {
      return m_Substrate_heightIsSet;
  }
  
  void Package::unsetSubstrate_height()
  {
      m_Substrate_heightIsSet = false;
  }
  double Package::getSubstrateThickness() const
  {
      return m_Substrate_thickness;
  }
  
  void Package::setSubstrateThickness(double value)
  {
      m_Substrate_thickness = value;
      m_Substrate_thicknessIsSet = true;
  }
  
  bool Package::substrateThicknessIsSet() const
  {
      return m_Substrate_thicknessIsSet;
  }
  
  void Package::unsetSubstrate_thickness()
  {
      m_Substrate_thicknessIsSet = false;
  }
  double Package::getSubstrateConductivity() const
  {
      return m_Substrate_conductivity;
  }
  
  void Package::setSubstrateConductivity(double value)
  {
      m_Substrate_conductivity = value;
      m_Substrate_conductivityIsSet = true;
  }
  
  bool Package::substrateConductivityIsSet() const
  {
      return m_Substrate_conductivityIsSet;
  }
  
  void Package::unsetSubstrate_conductivity()
  {
      m_Substrate_conductivityIsSet = false;
  }
  double Package::getSubstrateHeatcapacity() const
  {
      return m_Substrate_heatcapacity;
  }
  
  void Package::setSubstrateHeatcapacity(double value)
  {
      m_Substrate_heatcapacity = value;
      m_Substrate_heatcapacityIsSet = true;
  }
  
  bool Package::substrateHeatcapacityIsSet() const
  {
      return m_Substrate_heatcapacityIsSet;
  }
  
  void Package::unsetSubstrate_heatcapacity()
  {
      m_Substrate_heatcapacityIsSet = false;
  }
  bool Package::isSolderballSamesize() const
  {
      return m_Solderball_samesize;
  }
  
  void Package::setSolderballSamesize(bool value)
  {
      m_Solderball_samesize = value;
      m_Solderball_samesizeIsSet = true;
  }
  
  bool Package::solderballSamesizeIsSet() const
  {
      return m_Solderball_samesizeIsSet;
  }
  
  void Package::unsetSolderball_samesize()
  {
      m_Solderball_samesizeIsSet = false;
  }
  double Package::getSolderballWidth() const
  {
      return m_Solderball_width;
  }
  
  void Package::setSolderballWidth(double value)
  {
      m_Solderball_width = value;
      m_Solderball_widthIsSet = true;
  }
  
  bool Package::solderballWidthIsSet() const
  {
      return m_Solderball_widthIsSet;
  }
  
  void Package::unsetSolderball_width()
  {
      m_Solderball_widthIsSet = false;
  }
  double Package::getSolderballHeight() const
  {
      return m_Solderball_height;
  }
  
  void Package::setSolderballHeight(double value)
  {
      m_Solderball_height = value;
      m_Solderball_heightIsSet = true;
  }
  
  bool Package::solderballHeightIsSet() const
  {
      return m_Solderball_heightIsSet;
  }
  
  void Package::unsetSolderball_height()
  {
      m_Solderball_heightIsSet = false;
  }
  double Package::getSolderballThickness() const
  {
      return m_Solderball_thickness;
  }
  
  void Package::setSolderballThickness(double value)
  {
      m_Solderball_thickness = value;
      m_Solderball_thicknessIsSet = true;
  }
  
  bool Package::solderballThicknessIsSet() const
  {
      return m_Solderball_thicknessIsSet;
  }
  
  void Package::unsetSolderball_thickness()
  {
      m_Solderball_thicknessIsSet = false;
  }
  double Package::getSolderballConductivity() const
  {
      return m_Solderball_conductivity;
  }
  
  void Package::setSolderballConductivity(double value)
  {
      m_Solderball_conductivity = value;
      m_Solderball_conductivityIsSet = true;
  }
  
  bool Package::solderballConductivityIsSet() const
  {
      return m_Solderball_conductivityIsSet;
  }
  
  void Package::unsetSolderball_conductivity()
  {
      m_Solderball_conductivityIsSet = false;
  }
  double Package::getSolderballHeatcapacity() const
  {
      return m_Solderball_heatcapacity;
  }
  
  void Package::setSolderballHeatcapacity(double value)
  {
      m_Solderball_heatcapacity = value;
      m_Solderball_heatcapacityIsSet = true;
  }
  
  bool Package::solderballHeatcapacityIsSet() const
  {
      return m_Solderball_heatcapacityIsSet;
  }
  
  void Package::unsetSolderball_heatcapacity()
  {
      m_Solderball_heatcapacityIsSet = false;
  }
  }
  }
  
  
  