PrintAttributes.h

Go to the documentation of this file.

 
#pragma once
#include "enrollment/Export.h"
#include "enrollment/Print/PrintAttributes/PrintCaptureDeviceTechnology.h"
#include "enrollment/Print/PrintAttributes/PrintCaptureDeviceTypeID.h"
#include "enrollment/Print/PrintAttributes/PrintCaptureDeviceVendorID.h"
#include "enrollment/Print/PrintAttributes/PrintImpression.h"
#include "enrollment/Serialization/Writer.h"
#include <mutex>
#include <ostream>
 
namespace inno
{

     */
    class PrintAttributes : public Serializable
    {
    public:
         */
        void WriteTo(Writer& writer) const final
        {
            const std::scoped_lock lock(printAttributeMutex);
 
            writer.Write("i", static_cast<unsigned int>(impression));
            writer.Write("c", static_cast<unsigned int>(captureDeviceTechnology));
            writer.Write("v", static_cast<unsigned int>(captureDeviceVendor));
            writer.Write("t", static_cast<unsigned int>(captureDeviceType));
            writer.Write("f", static_cast<int>(certificationFlag));
        }
        PrintAttributes() = default;

         */
        PrintAttributes(const PrintAttributes& pa)
          : impression(pa.GetImpression())
          , captureDeviceTechnology(pa.GetCaptureDeviceTechnology())
          , captureDeviceVendor(pa.GetCaptureDeviceVendorID())
          , captureDeviceType(pa.GetCaptureDeviceTypeID())
          , certificationFlag(pa.GetCertificationFlag())
        {
        }

         */
        PrintAttributes(PrintAttributes&& pa) noexcept
          : impression(pa.GetImpression())
          , captureDeviceTechnology(pa.GetCaptureDeviceTechnology())
          , captureDeviceVendor(pa.GetCaptureDeviceVendorID())
          , captureDeviceType(pa.GetCaptureDeviceTypeID())
          , certificationFlag(pa.GetCertificationFlag())
        {
        }

         */
        PrintAttributes& operator=(const PrintAttributes& pa)
        {
            // Checks for self-assignment of operator.
            if (&pa == this)
            {
                return *this;
            }
 
            const std::scoped_lock lock(printAttributeMutex, pa.printAttributeMutex);
 
            impression = pa.impression;
            captureDeviceTechnology = pa.captureDeviceTechnology;
            captureDeviceVendor = pa.captureDeviceVendor;
            captureDeviceType = pa.captureDeviceType;
            certificationFlag = pa.certificationFlag;
 
            return *this;
        }

         */
        PrintAttributes& operator=(PrintAttributes&& pa) noexcept
        {
            const std::scoped_lock lock(printAttributeMutex, pa.printAttributeMutex);
 
            impression = pa.impression;
            captureDeviceTechnology = pa.captureDeviceTechnology;
            captureDeviceVendor = pa.captureDeviceVendor;
            captureDeviceType = pa.captureDeviceType;
            certificationFlag = pa.certificationFlag;
 
            return *this;
        }
 
        virtual ~PrintAttributes() = default;

         */
        constexpr bool operator==(const PrintAttributes& pa) const
        {
            return impression == pa.impression && captureDeviceTechnology == pa.captureDeviceTechnology &&
                   captureDeviceVendor == pa.captureDeviceVendor && captureDeviceType == pa.captureDeviceType &&
                   certificationFlag == pa.certificationFlag;
        }

         */
        void SetImpression(PrintImpression imp)
        {
            const std::scoped_lock lock(printAttributeMutex);
            impression = imp;
        }

         */
        [[nodiscard]] PrintImpression GetImpression() const
        {
            const std::scoped_lock lock(printAttributeMutex);
            return impression;
        }

         */
        void SetCaptureDeviceTechnology(PrintCaptureDeviceTechnology technology)
        {
            const std::scoped_lock lock(printAttributeMutex);
            captureDeviceTechnology = technology;
        }

         */
        [[nodiscard]] PrintCaptureDeviceTechnology GetCaptureDeviceTechnology() const
        {
            const std::scoped_lock lock(printAttributeMutex);
            return captureDeviceTechnology;
        }

         */
        void SetCaptureDeviceVendorID(PrintCaptureDeviceVendorID vendor)
        {
            const std::scoped_lock lock(printAttributeMutex);
            captureDeviceVendor = vendor;
        }

         */
        [[nodiscard]] PrintCaptureDeviceVendorID GetCaptureDeviceVendorID() const
        {
            const std::scoped_lock lock(printAttributeMutex);
            return captureDeviceVendor;
        }

         */
        void SetCaptureDeviceTypeID(PrintCaptureDeviceTypeID type)
        {
            const std::scoped_lock lock(printAttributeMutex);
            captureDeviceType = type;
        }

         */
        [[nodiscard]] PrintCaptureDeviceTypeID GetCaptureDeviceTypeID() const
        {
            const std::scoped_lock lock(printAttributeMutex);
            return captureDeviceType;
        }

         */
        void SetCertificationFlag(bool deviceCertified)
        {
            const std::scoped_lock lock(printAttributeMutex);
            certificationFlag = deviceCertified;
        }

         */
        [[nodiscard]] bool GetCertificationFlag() const
        {
            const std::scoped_lock lock(printAttributeMutex);
            return certificationFlag;
        }
 
    private:
        mutable std::mutex printAttributeMutex;
 
        PrintImpression impression{ PrintImpression::UNKNOWN };
        PrintCaptureDeviceTechnology captureDeviceTechnology{ PrintCaptureDeviceTechnology::UNKNOWN };
        PrintCaptureDeviceVendorID captureDeviceVendor{ 0 };
        PrintCaptureDeviceTypeID captureDeviceType{ 0 };
        bool certificationFlag{ false };
    };
 
} // namespace inno