/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
*
* The version of the OpenAPI document: 1.0.0-rc.42
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/


#include "Measurement_statistics.h"
#include "Helpers.h"

#include <sstream>

namespace org::openapitools::server::model
{

Measurement_statistics::Measurement_statistics()
{
    m_File_prefix = "";
    m_File_prefixIsSet = false;
    m_Run_number = 0L;
    m_Run_numberIsSet = false;
    m_Experiment_group = "";
    m_Experiment_groupIsSet = false;
    m_Images_expected = 0L;
    m_Images_expectedIsSet = false;
    m_Images_collected = 0L;
    m_Images_collectedIsSet = false;
    m_Images_sent = 0L;
    m_Images_sentIsSet = false;
    m_Images_discarded_lossy_compression = 0L;
    m_Images_discarded_lossy_compressionIsSet = false;
    m_Max_image_number_sent = 0L;
    m_Max_image_number_sentIsSet = false;
    m_Collection_efficiency = 0.0f;
    m_Collection_efficiencyIsSet = false;
    m_Compression_ratio = 0.0f;
    m_Compression_ratioIsSet = false;
    m_Cancelled = false;
    m_CancelledIsSet = false;
    m_Max_receiver_delay = 0L;
    m_Max_receiver_delayIsSet = false;
    m_Indexing_rate = 0.0f;
    m_Indexing_rateIsSet = false;
    m_Detector_width = 0L;
    m_Detector_widthIsSet = false;
    m_Detector_height = 0L;
    m_Detector_heightIsSet = false;
    m_Detector_pixel_depth = 0L;
    m_Detector_pixel_depthIsSet = false;
    m_Bkg_estimate = 0.0f;
    m_Bkg_estimateIsSet = false;
    m_Unit_cell = "";
    m_Unit_cellIsSet = false;
    m_Error_pixels = 0.0f;
    m_Error_pixelsIsSet = false;
    m_Saturated_pixels = 0.0f;
    m_Saturated_pixelsIsSet = false;
    m_Roi_beam_pixels = 0.0f;
    m_Roi_beam_pixelsIsSet = false;
    m_Roi_beam_sum = 0.0f;
    m_Roi_beam_sumIsSet = false;
    
}

void Measurement_statistics::validate() const
{
    std::stringstream msg;
    if (!validate(msg))
    {
        throw org::openapitools::server::helpers::ValidationException(msg.str());
    }
}

bool Measurement_statistics::validate(std::stringstream& msg) const
{
    return validate(msg, "");
}

bool Measurement_statistics::validate(std::stringstream& msg, const std::string& pathPrefix) const
{
    bool success = true;
    const std::string _pathPrefix = pathPrefix.empty() ? "Measurement_statistics" : pathPrefix;

                                         
    if (collectionEfficiencyIsSet())
    {
        const float& value = m_Collection_efficiency;
        const std::string currentValuePath = _pathPrefix + ".collectionEfficiency";
                
        
        if (value < static_cast<float>(0.0))
        {
            success = false;
            msg << currentValuePath << ": must be greater than or equal to 0.0;";
        }
        if (value > static_cast<float>(1.0))
        {
            success = false;
            msg << currentValuePath << ": must be less than or equal to 1.0;";
        }

    }
         
    if (compressionRatioIsSet())
    {
        const float& value = m_Compression_ratio;
        const std::string currentValuePath = _pathPrefix + ".compressionRatio";
                
        
        if (value < static_cast<float>(0.0))
        {
            success = false;
            msg << currentValuePath << ": must be greater than or equal to 0.0;";
        }

    }
                                                    
    return success;
}

bool Measurement_statistics::operator==(const Measurement_statistics& rhs) const
{
    return
    
    
    
    ((!filePrefixIsSet() && !rhs.filePrefixIsSet()) || (filePrefixIsSet() && rhs.filePrefixIsSet() && getFilePrefix() == rhs.getFilePrefix())) &&
    
    
    ((!runNumberIsSet() && !rhs.runNumberIsSet()) || (runNumberIsSet() && rhs.runNumberIsSet() && getRunNumber() == rhs.getRunNumber())) &&
    
    
    ((!experimentGroupIsSet() && !rhs.experimentGroupIsSet()) || (experimentGroupIsSet() && rhs.experimentGroupIsSet() && getExperimentGroup() == rhs.getExperimentGroup())) &&
    
    
    ((!imagesExpectedIsSet() && !rhs.imagesExpectedIsSet()) || (imagesExpectedIsSet() && rhs.imagesExpectedIsSet() && getImagesExpected() == rhs.getImagesExpected())) &&
    
    
    ((!imagesCollectedIsSet() && !rhs.imagesCollectedIsSet()) || (imagesCollectedIsSet() && rhs.imagesCollectedIsSet() && getImagesCollected() == rhs.getImagesCollected())) &&
    
    
    ((!imagesSentIsSet() && !rhs.imagesSentIsSet()) || (imagesSentIsSet() && rhs.imagesSentIsSet() && getImagesSent() == rhs.getImagesSent())) &&
    
    
    ((!imagesDiscardedLossyCompressionIsSet() && !rhs.imagesDiscardedLossyCompressionIsSet()) || (imagesDiscardedLossyCompressionIsSet() && rhs.imagesDiscardedLossyCompressionIsSet() && getImagesDiscardedLossyCompression() == rhs.getImagesDiscardedLossyCompression())) &&
    
    
    ((!maxImageNumberSentIsSet() && !rhs.maxImageNumberSentIsSet()) || (maxImageNumberSentIsSet() && rhs.maxImageNumberSentIsSet() && getMaxImageNumberSent() == rhs.getMaxImageNumberSent())) &&
    
    
    ((!collectionEfficiencyIsSet() && !rhs.collectionEfficiencyIsSet()) || (collectionEfficiencyIsSet() && rhs.collectionEfficiencyIsSet() && getCollectionEfficiency() == rhs.getCollectionEfficiency())) &&
    
    
    ((!compressionRatioIsSet() && !rhs.compressionRatioIsSet()) || (compressionRatioIsSet() && rhs.compressionRatioIsSet() && getCompressionRatio() == rhs.getCompressionRatio())) &&
    
    
    ((!cancelledIsSet() && !rhs.cancelledIsSet()) || (cancelledIsSet() && rhs.cancelledIsSet() && isCancelled() == rhs.isCancelled())) &&
    
    
    ((!maxReceiverDelayIsSet() && !rhs.maxReceiverDelayIsSet()) || (maxReceiverDelayIsSet() && rhs.maxReceiverDelayIsSet() && getMaxReceiverDelay() == rhs.getMaxReceiverDelay())) &&
    
    
    ((!indexingRateIsSet() && !rhs.indexingRateIsSet()) || (indexingRateIsSet() && rhs.indexingRateIsSet() && getIndexingRate() == rhs.getIndexingRate())) &&
    
    
    ((!detectorWidthIsSet() && !rhs.detectorWidthIsSet()) || (detectorWidthIsSet() && rhs.detectorWidthIsSet() && getDetectorWidth() == rhs.getDetectorWidth())) &&
    
    
    ((!detectorHeightIsSet() && !rhs.detectorHeightIsSet()) || (detectorHeightIsSet() && rhs.detectorHeightIsSet() && getDetectorHeight() == rhs.getDetectorHeight())) &&
    
    
    ((!detectorPixelDepthIsSet() && !rhs.detectorPixelDepthIsSet()) || (detectorPixelDepthIsSet() && rhs.detectorPixelDepthIsSet() && getDetectorPixelDepth() == rhs.getDetectorPixelDepth())) &&
    
    
    ((!bkgEstimateIsSet() && !rhs.bkgEstimateIsSet()) || (bkgEstimateIsSet() && rhs.bkgEstimateIsSet() && getBkgEstimate() == rhs.getBkgEstimate())) &&
    
    
    ((!unitCellIsSet() && !rhs.unitCellIsSet()) || (unitCellIsSet() && rhs.unitCellIsSet() && getUnitCell() == rhs.getUnitCell())) &&
    
    
    ((!errorPixelsIsSet() && !rhs.errorPixelsIsSet()) || (errorPixelsIsSet() && rhs.errorPixelsIsSet() && getErrorPixels() == rhs.getErrorPixels())) &&
    
    
    ((!saturatedPixelsIsSet() && !rhs.saturatedPixelsIsSet()) || (saturatedPixelsIsSet() && rhs.saturatedPixelsIsSet() && getSaturatedPixels() == rhs.getSaturatedPixels())) &&
    
    
    ((!roiBeamPixelsIsSet() && !rhs.roiBeamPixelsIsSet()) || (roiBeamPixelsIsSet() && rhs.roiBeamPixelsIsSet() && getRoiBeamPixels() == rhs.getRoiBeamPixels())) &&
    
    
    ((!roiBeamSumIsSet() && !rhs.roiBeamSumIsSet()) || (roiBeamSumIsSet() && rhs.roiBeamSumIsSet() && getRoiBeamSum() == rhs.getRoiBeamSum()))
    
    ;
}

bool Measurement_statistics::operator!=(const Measurement_statistics& rhs) const
{
    return !(*this == rhs);
}

void to_json(nlohmann::json& j, const Measurement_statistics& o)
{
    j = nlohmann::json::object();
    if(o.filePrefixIsSet())
        j["file_prefix"] = o.m_File_prefix;
    if(o.runNumberIsSet())
        j["run_number"] = o.m_Run_number;
    if(o.experimentGroupIsSet())
        j["experiment_group"] = o.m_Experiment_group;
    if(o.imagesExpectedIsSet())
        j["images_expected"] = o.m_Images_expected;
    if(o.imagesCollectedIsSet())
        j["images_collected"] = o.m_Images_collected;
    if(o.imagesSentIsSet())
        j["images_sent"] = o.m_Images_sent;
    if(o.imagesDiscardedLossyCompressionIsSet())
        j["images_discarded_lossy_compression"] = o.m_Images_discarded_lossy_compression;
    if(o.maxImageNumberSentIsSet())
        j["max_image_number_sent"] = o.m_Max_image_number_sent;
    if(o.collectionEfficiencyIsSet())
        j["collection_efficiency"] = o.m_Collection_efficiency;
    if(o.compressionRatioIsSet())
        j["compression_ratio"] = o.m_Compression_ratio;
    if(o.cancelledIsSet())
        j["cancelled"] = o.m_Cancelled;
    if(o.maxReceiverDelayIsSet())
        j["max_receiver_delay"] = o.m_Max_receiver_delay;
    if(o.indexingRateIsSet())
        j["indexing_rate"] = o.m_Indexing_rate;
    if(o.detectorWidthIsSet())
        j["detector_width"] = o.m_Detector_width;
    if(o.detectorHeightIsSet())
        j["detector_height"] = o.m_Detector_height;
    if(o.detectorPixelDepthIsSet())
        j["detector_pixel_depth"] = o.m_Detector_pixel_depth;
    if(o.bkgEstimateIsSet())
        j["bkg_estimate"] = o.m_Bkg_estimate;
    if(o.unitCellIsSet())
        j["unit_cell"] = o.m_Unit_cell;
    if(o.errorPixelsIsSet())
        j["error_pixels"] = o.m_Error_pixels;
    if(o.saturatedPixelsIsSet())
        j["saturated_pixels"] = o.m_Saturated_pixels;
    if(o.roiBeamPixelsIsSet())
        j["roi_beam_pixels"] = o.m_Roi_beam_pixels;
    if(o.roiBeamSumIsSet())
        j["roi_beam_sum"] = o.m_Roi_beam_sum;
    
}

void from_json(const nlohmann::json& j, Measurement_statistics& o)
{
    if(j.find("file_prefix") != j.end())
    {
        j.at("file_prefix").get_to(o.m_File_prefix);
        o.m_File_prefixIsSet = true;
    } 
    if(j.find("run_number") != j.end())
    {
        j.at("run_number").get_to(o.m_Run_number);
        o.m_Run_numberIsSet = true;
    } 
    if(j.find("experiment_group") != j.end())
    {
        j.at("experiment_group").get_to(o.m_Experiment_group);
        o.m_Experiment_groupIsSet = true;
    } 
    if(j.find("images_expected") != j.end())
    {
        j.at("images_expected").get_to(o.m_Images_expected);
        o.m_Images_expectedIsSet = true;
    } 
    if(j.find("images_collected") != j.end())
    {
        j.at("images_collected").get_to(o.m_Images_collected);
        o.m_Images_collectedIsSet = true;
    } 
    if(j.find("images_sent") != j.end())
    {
        j.at("images_sent").get_to(o.m_Images_sent);
        o.m_Images_sentIsSet = true;
    } 
    if(j.find("images_discarded_lossy_compression") != j.end())
    {
        j.at("images_discarded_lossy_compression").get_to(o.m_Images_discarded_lossy_compression);
        o.m_Images_discarded_lossy_compressionIsSet = true;
    } 
    if(j.find("max_image_number_sent") != j.end())
    {
        j.at("max_image_number_sent").get_to(o.m_Max_image_number_sent);
        o.m_Max_image_number_sentIsSet = true;
    } 
    if(j.find("collection_efficiency") != j.end())
    {
        j.at("collection_efficiency").get_to(o.m_Collection_efficiency);
        o.m_Collection_efficiencyIsSet = true;
    } 
    if(j.find("compression_ratio") != j.end())
    {
        j.at("compression_ratio").get_to(o.m_Compression_ratio);
        o.m_Compression_ratioIsSet = true;
    } 
    if(j.find("cancelled") != j.end())
    {
        j.at("cancelled").get_to(o.m_Cancelled);
        o.m_CancelledIsSet = true;
    } 
    if(j.find("max_receiver_delay") != j.end())
    {
        j.at("max_receiver_delay").get_to(o.m_Max_receiver_delay);
        o.m_Max_receiver_delayIsSet = true;
    } 
    if(j.find("indexing_rate") != j.end())
    {
        j.at("indexing_rate").get_to(o.m_Indexing_rate);
        o.m_Indexing_rateIsSet = true;
    } 
    if(j.find("detector_width") != j.end())
    {
        j.at("detector_width").get_to(o.m_Detector_width);
        o.m_Detector_widthIsSet = true;
    } 
    if(j.find("detector_height") != j.end())
    {
        j.at("detector_height").get_to(o.m_Detector_height);
        o.m_Detector_heightIsSet = true;
    } 
    if(j.find("detector_pixel_depth") != j.end())
    {
        j.at("detector_pixel_depth").get_to(o.m_Detector_pixel_depth);
        o.m_Detector_pixel_depthIsSet = true;
    } 
    if(j.find("bkg_estimate") != j.end())
    {
        j.at("bkg_estimate").get_to(o.m_Bkg_estimate);
        o.m_Bkg_estimateIsSet = true;
    } 
    if(j.find("unit_cell") != j.end())
    {
        j.at("unit_cell").get_to(o.m_Unit_cell);
        o.m_Unit_cellIsSet = true;
    } 
    if(j.find("error_pixels") != j.end())
    {
        j.at("error_pixels").get_to(o.m_Error_pixels);
        o.m_Error_pixelsIsSet = true;
    } 
    if(j.find("saturated_pixels") != j.end())
    {
        j.at("saturated_pixels").get_to(o.m_Saturated_pixels);
        o.m_Saturated_pixelsIsSet = true;
    } 
    if(j.find("roi_beam_pixels") != j.end())
    {
        j.at("roi_beam_pixels").get_to(o.m_Roi_beam_pixels);
        o.m_Roi_beam_pixelsIsSet = true;
    } 
    if(j.find("roi_beam_sum") != j.end())
    {
        j.at("roi_beam_sum").get_to(o.m_Roi_beam_sum);
        o.m_Roi_beam_sumIsSet = true;
    } 
    
}

std::string Measurement_statistics::getFilePrefix() const
{
    return m_File_prefix;
}
void Measurement_statistics::setFilePrefix(std::string const& value)
{
    m_File_prefix = value;
    m_File_prefixIsSet = true;
}
bool Measurement_statistics::filePrefixIsSet() const
{
    return m_File_prefixIsSet;
}
void Measurement_statistics::unsetFile_prefix()
{
    m_File_prefixIsSet = false;
}
int64_t Measurement_statistics::getRunNumber() const
{
    return m_Run_number;
}
void Measurement_statistics::setRunNumber(int64_t const value)
{
    m_Run_number = value;
    m_Run_numberIsSet = true;
}
bool Measurement_statistics::runNumberIsSet() const
{
    return m_Run_numberIsSet;
}
void Measurement_statistics::unsetRun_number()
{
    m_Run_numberIsSet = false;
}
std::string Measurement_statistics::getExperimentGroup() const
{
    return m_Experiment_group;
}
void Measurement_statistics::setExperimentGroup(std::string const& value)
{
    m_Experiment_group = value;
    m_Experiment_groupIsSet = true;
}
bool Measurement_statistics::experimentGroupIsSet() const
{
    return m_Experiment_groupIsSet;
}
void Measurement_statistics::unsetExperiment_group()
{
    m_Experiment_groupIsSet = false;
}
int64_t Measurement_statistics::getImagesExpected() const
{
    return m_Images_expected;
}
void Measurement_statistics::setImagesExpected(int64_t const value)
{
    m_Images_expected = value;
    m_Images_expectedIsSet = true;
}
bool Measurement_statistics::imagesExpectedIsSet() const
{
    return m_Images_expectedIsSet;
}
void Measurement_statistics::unsetImages_expected()
{
    m_Images_expectedIsSet = false;
}
int64_t Measurement_statistics::getImagesCollected() const
{
    return m_Images_collected;
}
void Measurement_statistics::setImagesCollected(int64_t const value)
{
    m_Images_collected = value;
    m_Images_collectedIsSet = true;
}
bool Measurement_statistics::imagesCollectedIsSet() const
{
    return m_Images_collectedIsSet;
}
void Measurement_statistics::unsetImages_collected()
{
    m_Images_collectedIsSet = false;
}
int64_t Measurement_statistics::getImagesSent() const
{
    return m_Images_sent;
}
void Measurement_statistics::setImagesSent(int64_t const value)
{
    m_Images_sent = value;
    m_Images_sentIsSet = true;
}
bool Measurement_statistics::imagesSentIsSet() const
{
    return m_Images_sentIsSet;
}
void Measurement_statistics::unsetImages_sent()
{
    m_Images_sentIsSet = false;
}
int64_t Measurement_statistics::getImagesDiscardedLossyCompression() const
{
    return m_Images_discarded_lossy_compression;
}
void Measurement_statistics::setImagesDiscardedLossyCompression(int64_t const value)
{
    m_Images_discarded_lossy_compression = value;
    m_Images_discarded_lossy_compressionIsSet = true;
}
bool Measurement_statistics::imagesDiscardedLossyCompressionIsSet() const
{
    return m_Images_discarded_lossy_compressionIsSet;
}
void Measurement_statistics::unsetImages_discarded_lossy_compression()
{
    m_Images_discarded_lossy_compressionIsSet = false;
}
int64_t Measurement_statistics::getMaxImageNumberSent() const
{
    return m_Max_image_number_sent;
}
void Measurement_statistics::setMaxImageNumberSent(int64_t const value)
{
    m_Max_image_number_sent = value;
    m_Max_image_number_sentIsSet = true;
}
bool Measurement_statistics::maxImageNumberSentIsSet() const
{
    return m_Max_image_number_sentIsSet;
}
void Measurement_statistics::unsetMax_image_number_sent()
{
    m_Max_image_number_sentIsSet = false;
}
float Measurement_statistics::getCollectionEfficiency() const
{
    return m_Collection_efficiency;
}
void Measurement_statistics::setCollectionEfficiency(float const value)
{
    m_Collection_efficiency = value;
    m_Collection_efficiencyIsSet = true;
}
bool Measurement_statistics::collectionEfficiencyIsSet() const
{
    return m_Collection_efficiencyIsSet;
}
void Measurement_statistics::unsetCollection_efficiency()
{
    m_Collection_efficiencyIsSet = false;
}
float Measurement_statistics::getCompressionRatio() const
{
    return m_Compression_ratio;
}
void Measurement_statistics::setCompressionRatio(float const value)
{
    m_Compression_ratio = value;
    m_Compression_ratioIsSet = true;
}
bool Measurement_statistics::compressionRatioIsSet() const
{
    return m_Compression_ratioIsSet;
}
void Measurement_statistics::unsetCompression_ratio()
{
    m_Compression_ratioIsSet = false;
}
bool Measurement_statistics::isCancelled() const
{
    return m_Cancelled;
}
void Measurement_statistics::setCancelled(bool const value)
{
    m_Cancelled = value;
    m_CancelledIsSet = true;
}
bool Measurement_statistics::cancelledIsSet() const
{
    return m_CancelledIsSet;
}
void Measurement_statistics::unsetCancelled()
{
    m_CancelledIsSet = false;
}
int64_t Measurement_statistics::getMaxReceiverDelay() const
{
    return m_Max_receiver_delay;
}
void Measurement_statistics::setMaxReceiverDelay(int64_t const value)
{
    m_Max_receiver_delay = value;
    m_Max_receiver_delayIsSet = true;
}
bool Measurement_statistics::maxReceiverDelayIsSet() const
{
    return m_Max_receiver_delayIsSet;
}
void Measurement_statistics::unsetMax_receiver_delay()
{
    m_Max_receiver_delayIsSet = false;
}
float Measurement_statistics::getIndexingRate() const
{
    return m_Indexing_rate;
}
void Measurement_statistics::setIndexingRate(float const value)
{
    m_Indexing_rate = value;
    m_Indexing_rateIsSet = true;
}
bool Measurement_statistics::indexingRateIsSet() const
{
    return m_Indexing_rateIsSet;
}
void Measurement_statistics::unsetIndexing_rate()
{
    m_Indexing_rateIsSet = false;
}
int64_t Measurement_statistics::getDetectorWidth() const
{
    return m_Detector_width;
}
void Measurement_statistics::setDetectorWidth(int64_t const value)
{
    m_Detector_width = value;
    m_Detector_widthIsSet = true;
}
bool Measurement_statistics::detectorWidthIsSet() const
{
    return m_Detector_widthIsSet;
}
void Measurement_statistics::unsetDetector_width()
{
    m_Detector_widthIsSet = false;
}
int64_t Measurement_statistics::getDetectorHeight() const
{
    return m_Detector_height;
}
void Measurement_statistics::setDetectorHeight(int64_t const value)
{
    m_Detector_height = value;
    m_Detector_heightIsSet = true;
}
bool Measurement_statistics::detectorHeightIsSet() const
{
    return m_Detector_heightIsSet;
}
void Measurement_statistics::unsetDetector_height()
{
    m_Detector_heightIsSet = false;
}
int64_t Measurement_statistics::getDetectorPixelDepth() const
{
    return m_Detector_pixel_depth;
}
void Measurement_statistics::setDetectorPixelDepth(int64_t const value)
{
    m_Detector_pixel_depth = value;
    m_Detector_pixel_depthIsSet = true;
}
bool Measurement_statistics::detectorPixelDepthIsSet() const
{
    return m_Detector_pixel_depthIsSet;
}
void Measurement_statistics::unsetDetector_pixel_depth()
{
    m_Detector_pixel_depthIsSet = false;
}
float Measurement_statistics::getBkgEstimate() const
{
    return m_Bkg_estimate;
}
void Measurement_statistics::setBkgEstimate(float const value)
{
    m_Bkg_estimate = value;
    m_Bkg_estimateIsSet = true;
}
bool Measurement_statistics::bkgEstimateIsSet() const
{
    return m_Bkg_estimateIsSet;
}
void Measurement_statistics::unsetBkg_estimate()
{
    m_Bkg_estimateIsSet = false;
}
std::string Measurement_statistics::getUnitCell() const
{
    return m_Unit_cell;
}
void Measurement_statistics::setUnitCell(std::string const& value)
{
    m_Unit_cell = value;
    m_Unit_cellIsSet = true;
}
bool Measurement_statistics::unitCellIsSet() const
{
    return m_Unit_cellIsSet;
}
void Measurement_statistics::unsetUnit_cell()
{
    m_Unit_cellIsSet = false;
}
float Measurement_statistics::getErrorPixels() const
{
    return m_Error_pixels;
}
void Measurement_statistics::setErrorPixels(float const value)
{
    m_Error_pixels = value;
    m_Error_pixelsIsSet = true;
}
bool Measurement_statistics::errorPixelsIsSet() const
{
    return m_Error_pixelsIsSet;
}
void Measurement_statistics::unsetError_pixels()
{
    m_Error_pixelsIsSet = false;
}
float Measurement_statistics::getSaturatedPixels() const
{
    return m_Saturated_pixels;
}
void Measurement_statistics::setSaturatedPixels(float const value)
{
    m_Saturated_pixels = value;
    m_Saturated_pixelsIsSet = true;
}
bool Measurement_statistics::saturatedPixelsIsSet() const
{
    return m_Saturated_pixelsIsSet;
}
void Measurement_statistics::unsetSaturated_pixels()
{
    m_Saturated_pixelsIsSet = false;
}
float Measurement_statistics::getRoiBeamPixels() const
{
    return m_Roi_beam_pixels;
}
void Measurement_statistics::setRoiBeamPixels(float const value)
{
    m_Roi_beam_pixels = value;
    m_Roi_beam_pixelsIsSet = true;
}
bool Measurement_statistics::roiBeamPixelsIsSet() const
{
    return m_Roi_beam_pixelsIsSet;
}
void Measurement_statistics::unsetRoi_beam_pixels()
{
    m_Roi_beam_pixelsIsSet = false;
}
float Measurement_statistics::getRoiBeamSum() const
{
    return m_Roi_beam_sum;
}
void Measurement_statistics::setRoiBeamSum(float const value)
{
    m_Roi_beam_sum = value;
    m_Roi_beam_sumIsSet = true;
}
bool Measurement_statistics::roiBeamSumIsSet() const
{
    return m_Roi_beam_sumIsSet;
}
void Measurement_statistics::unsetRoi_beam_sum()
{
    m_Roi_beam_sumIsSet = false;
}


} // namespace org::openapitools::server::model