common.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef FRIF_COMMON_H_
#define FRIF_COMMON_H_
 
#include <compare>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <type_traits>
#include <vector>
 
namespace FRIF
{
        struct ReturnStatus
        {
                enum class Result
                {
                        Success = 0,
                        Failure
                };

                Result result{};
                std::optional<std::string> message{};

                explicit operator bool()
                    const
                    noexcept;
        };

        struct Image
        {
                enum class BitsPerPixel : uint8_t
                {
                        Eight = 8,
                        Sixteen = 16,
                        TwentyFour = 24,
                        FortyEight = 48
                };
                using BPP = BitsPerPixel;

                static BitsPerPixel
                toBitsPerPixel(
                    const std::underlying_type_t<BitsPerPixel> i);

                enum class BitsPerChannel : uint8_t
                {
                        Eight = 8,
                        Sixteen = 16
                };
                using BPC = BitsPerChannel;

                static BitsPerChannel
                toBitsPerChannel(
                    const std::underlying_type_t<BitsPerChannel> i);
 
                enum class Colorspace
                {
                        Grayscale,
                        RGB
                };
 
                Image();

                Image(
                    const uint8_t identifier,
                    const uint16_t width,
                    const uint16_t height,
                    const uint16_t ppi,
                    const Colorspace colorspace,
                    const BitsPerChannel bpc,
                    const BitsPerPixel bpp,
                    const std::vector<std::byte> &pixels);

                void
                sanityCheck()
                    const;

                uint8_t identifier{};
                uint16_t width{};
                uint16_t height{};
                uint16_t ppi{};
                Colorspace colorspace{Colorspace::Grayscale};
                BitsPerChannel bpc{BitsPerChannel::Eight};
                BitsPerPixel bpp{BitsPerPixel::Eight};
                std::vector<std::byte> pixels{};
        };

        struct Coordinate
        {
                uint32_t x{};
                uint32_t y{};

                Coordinate(
                    const uint32_t x = {},
                    const uint32_t y = {});
 
                std::strong_ordering
                operator<=>(
                    const Coordinate&)
                    const;
                bool operator==(const Coordinate&) const;
        };

        using Segment = std::tuple<Coordinate, Coordinate>;

        struct ProductIdentifier
        {
                struct CBEFFIdentifier
                {
                        uint16_t owner{};
                        std::optional<uint16_t> algorithm{};
 
                        std::strong_ordering
                        operator<=>(
                            const CBEFFIdentifier&)
                            const;
                        bool operator==(const CBEFFIdentifier&) const;
                };

                std::optional<std::string> marketing{};
                std::optional<CBEFFIdentifier> cbeff{};
 
                std::strong_ordering
                operator<=>(
                    const ProductIdentifier&)
                    const;
                bool operator==(const ProductIdentifier&) const;
        };
 
        /*
         * API versioning.
         *
         * NIST code will extern the version number symbols. Participant code
         * shall compile them into their core library.
         */
        #ifdef NIST_EXTERN_FRIFTE_API_VERSION
        extern uint16_t API_MAJOR_VERSION;
        extern uint16_t API_MINOR_VERSION;
        extern uint16_t API_PATCH_VERSION;
        #else /* NIST_EXTERN_FRIFTE_API_VERSION */
        uint16_t API_MAJOR_VERSION{1};
        uint16_t API_MINOR_VERSION{3};
        uint16_t API_PATCH_VERSION{0};
        #endif /* NIST_EXTERN_FRIFTE_API_VERSION */
 
        /*
         * Ensure that std::byte is exactly 8 bits, such that reinterpret_casts
         * may be safely used.
         */
        static_assert(std::is_same_v<std::underlying_type_t<std::byte>,
            uint8_t>, "std::byte not represented as unsigned 8 bit type");
}
 
#endif /* FRIF_COMMON_H_ */