FaceAttributes.h

Go to the documentation of this file.

 
#pragma once
#include "enrollment/Export.h"
#include <mutex>
#include <ostream>
 
#include "enrollment/Face/FaceAttributes/FaceCaptureDeviceTechnology.h"
#include "enrollment/Face/FaceAttributes/FaceCaptureDeviceTypeID.h"
#include "enrollment/Face/FaceAttributes/FaceCaptureDeviceVendorID.h"
#include "enrollment/Face/FaceAttributes/FaceImageType.h"
#include "enrollment/Serialization/Writer.h"
 
namespace inno
{

     */
    class FaceAttributes : public Serializable
    {
    public:
        FaceAttributes() = default;

         */
        FaceAttributes(const FaceAttributes& fa)
          : captureDeviceTechnology(fa.GetCaptureDeviceTechnology())
          , captureDeviceVendor(fa.GetCaptureDeviceVendorID())
          , captureDeviceType(fa.GetCaptureDeviceTypeID())
          , faceImageType(fa.GetFaceImageType())
        {
        }

         */
        FaceAttributes(FaceAttributes&& fa) noexcept
          : captureDeviceTechnology(fa.GetCaptureDeviceTechnology())
          , captureDeviceVendor(fa.GetCaptureDeviceVendorID())
          , captureDeviceType(fa.GetCaptureDeviceTypeID())
          , faceImageType(fa.GetFaceImageType())
        {
        }

         */
        FaceAttributes& operator=(const FaceAttributes& fa)
        {
            // Checks for self-assignment of operator.
            if (&fa == this)
            {
                return *this;
            }
 
            const std::scoped_lock lock(faceAttributeMutex, fa.faceAttributeMutex);
 
            captureDeviceTechnology = fa.captureDeviceTechnology;
            captureDeviceVendor = fa.captureDeviceVendor;
            captureDeviceType = fa.captureDeviceType;
            faceImageType = fa.faceImageType;
 
            return *this;
        }

         */
        FaceAttributes& operator=(FaceAttributes&& fa) noexcept
        {
            const std::scoped_lock lock(faceAttributeMutex, fa.faceAttributeMutex);
 
            captureDeviceTechnology = fa.captureDeviceTechnology;
            captureDeviceVendor = fa.captureDeviceVendor;
            captureDeviceType = fa.captureDeviceType;
            faceImageType = fa.faceImageType;
 
            return *this;
        }
 
        virtual ~FaceAttributes() = default;

         */
        constexpr bool operator==(const FaceAttributes& fa) const
        {
            return captureDeviceTechnology == fa.captureDeviceTechnology &&
                   captureDeviceVendor == fa.captureDeviceVendor && captureDeviceType == fa.captureDeviceType &&
                   faceImageType == fa.faceImageType;
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("dt", static_cast<uint8_t>(captureDeviceTechnology));
            writer.Write("dv", static_cast<unsigned int>(captureDeviceVendor));
            writer.Write("di", static_cast<unsigned int>(captureDeviceType));
        }

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

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

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

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

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

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

         */
        void SetFaceImageType(FaceImageType type)
        {
            const std::scoped_lock lock(faceAttributeMutex);
            faceImageType = type;
        }

         */
        [[nodiscard]] FaceImageType GetFaceImageType() const
        {
            const std::scoped_lock lock(faceAttributeMutex);
            return faceImageType;
        }
 
    private:
        mutable std::mutex faceAttributeMutex;
 
        FaceCaptureDeviceTechnology captureDeviceTechnology{ FaceCaptureDeviceTechnology::UNKNOWN };
        FaceCaptureDeviceVendorID captureDeviceVendor{ 0 };
        FaceCaptureDeviceTypeID captureDeviceType{ 0 };
        FaceImageType faceImageType{ FaceImageType::BASIC };
    };
 
} // namespace inno