Source/cmSpdx.h

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#pragma once
#include <string>
#include <vector>

#include <cm/optional>

#include "cmSbomObject.h"

class cmSbomSerializer;

using Datetime = std::string;
using MediaType = std::string;
using SemVer = std::string;

struct cmSpdxExternalIdentifier
{
  cm::optional<std::string> SpdxId;
  cm::optional<std::string> ExternalIdentifierType;
  cm::optional<std::string> Identifier;
  cm::optional<std::string> Comment;
  cm::optional<std::string> IdentifierLocation;
  cm::optional<std::string> IssuingAuthority;

  void Serialize(cmSbomSerializer&) const;
};

struct cmSpdxExternalRef
{
  cm::optional<std::string> SpdxId;
  cm::optional<std::string> ExternalRefType;
  cm::optional<std::string> Locator;
  cm::optional<std::string> ContentType;
  cm::optional<std::string> Comment;

  void Serialize(cmSbomSerializer&) const;
};

struct cmSpdxCreationInfo
{
  cm::optional<std::string> Id;
  cm::optional<std::string> SpdxId;
  cm::optional<SemVer> SpecVersion;
  cm::optional<std::string> Comment;
  cm::optional<Datetime> Created;
  std::vector<std::string> CreatedBy;
  std::vector<cmSbomObject> CreatedUsing;

  void Serialize(cmSbomSerializer&) const;
};

struct cmSpdxIntegrityMethod
{
  cm::optional<std::string> SpdxId;
  cm::optional<std::string> Comment;

  enum HashAlgorithmId
  {
    ADLER32,
    BLAKE2B256,
    BLAKE2B384,
    BLAKE2B512,
    BLAKE3,
    MD2,
    MD4,
    MD5,
    MD6,
    SHA1,
    SHA224,
    SHA256,
    SHA384,
    SHA512,
    SHA3_256,
    SHA3_384,
    SHA3_512,
  };

  cmSpdxIntegrityMethod() = default;
  cmSpdxIntegrityMethod(cmSpdxIntegrityMethod const&) = default;
  cmSpdxIntegrityMethod(cmSpdxIntegrityMethod&&) = default;
  cmSpdxIntegrityMethod& operator=(cmSpdxIntegrityMethod const&) = default;
  cmSpdxIntegrityMethod& operator=(cmSpdxIntegrityMethod&&) = default;

  virtual void Serialize(cmSbomSerializer&) const;
  virtual ~cmSpdxIntegrityMethod() = default;
};

struct cmSpdxChecksum
{
  cm::optional<std::string> SpdxId;
  cmSpdxIntegrityMethod::HashAlgorithmId Algorithm;
  std::string ChecksumValue;

  void Serialize(cmSbomSerializer&) const;
};

struct cmSpdxElement
{
  cm::optional<std::string> SpdxId;
  cm::optional<std::string> Name;
  cm::optional<std::string> Summary;
  cm::optional<std::string> Description;
  cm::optional<std::string> Comment;
  cm::optional<cmSbomObject> CreationInfo;
  cm::optional<cmSbomObject> VerifiedUsing;
  std::vector<cmSbomObject> ExternalRef;
  std::vector<cmSbomObject> ExternalIdentifier;
  cm::optional<cmSbomObject> Extension;

  cmSpdxElement() = default;
  cmSpdxElement(cmSpdxElement const&) = default;
  cmSpdxElement(cmSpdxElement&&) = default;
  cmSpdxElement& operator=(cmSpdxElement const&) = default;
  cmSpdxElement& operator=(cmSpdxElement&&) = default;

  virtual ~cmSpdxElement() = default;
  virtual void Serialize(cmSbomSerializer&) const;
};

struct cmSpdxTool final : cmSpdxElement
{
  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxAgent : cmSpdxElement
{
  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxOrganization final : cmSpdxAgent
{
  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxPerson final : cmSpdxAgent
{
  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxSoftwareAgent final : cmSpdxAgent
{
  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxPositiveIntegerRange
{
  cm::optional<std::string> SpdxId;
  cm::optional<std::string> BeginIntegerRange;
  cm::optional<std::string> EndIntegerRange;

  void Serialize(cmSbomSerializer&) const;
};

struct cmSpdxRelationship : cmSpdxElement
{
  enum RelationshipTypeId
  {
    DESCRIBES,
    CONTAINS,
    DEPENDS_ON,
    HAS_DECLARED_LICENSE,
    OTHER
  };

  cm::optional<cmSbomObject> From;
  std::vector<cmSbomObject> To;
  cm::optional<RelationshipTypeId> RelationshipType;
  cm::optional<Datetime> StartTime;
  cm::optional<Datetime> EndTime;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxLifecycleScopedRelationship final : cmSpdxRelationship
{
  enum ScopeId
  {
    BUILD,
    DESIGN,
    RUNTIME,
    TEST
  };

  cm::optional<ScopeId> Scope;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxArtifact : cmSpdxElement
{
  enum SupportTypeId
  {
    COMMUNITY,
    COMMERCIAL,
    NONE
  };

  std::vector<cmSbomObject> OriginatedBy;
  cm::optional<cmSbomObject> SuppliedBy;
  cm::optional<Datetime> BuiltTime;
  cm::optional<Datetime> ReleaseTime;
  cm::optional<Datetime> ValidUntilTime;
  cm::optional<std::string> StandardName;
  cm::optional<SupportTypeId> Support;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxIndividualElement final : cmSpdxElement
{
  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxAnnotation final : cmSpdxElement
{
  enum AnnotationTypeId
  {
    REVIEW,
    OTHER
  };

  cm::optional<AnnotationTypeId> AnnotationType;
  cm::optional<MediaType> ContentType;
  cm::optional<std::string> Statement;
  cm::optional<cmSbomObject> Element;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxExternalMap
{
  cm::optional<std::string> SpdxId;
  cm::optional<std::string> ExternalSpdxId;
  cm::optional<cmSbomObject> VerifiedUsing;
  cm::optional<std::string> LocationHistory;
  cm::optional<cmSbomObject> DefiningArtifact;

  void Serialize(cmSbomSerializer&) const;
};

struct cmSpdxNamespaceMap
{
  cm::optional<std::string> SpdxId;
  cm::optional<std::string> Prefix;
  cm::optional<std::string> Namespace;

  void Serialize(cmSbomSerializer&) const;
};

struct cmSpdxElementCollection : cmSpdxElement
{
  std::vector<cmSbomObject> Elements;
  std::vector<cmSbomObject> RootElements;
  std::vector<std::string> ProfileConformance;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxPackageVerificationCode final : cmSpdxIntegrityMethod
{
  cm::optional<HashAlgorithmId> Algorithm;
  cm::optional<std::string> HashValue;
  cm::optional<std::string> PackageVerificationCodeExcludedFile;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxHash final : cmSpdxIntegrityMethod
{
  HashAlgorithmId HashAlgorithm;
  std::string HashValue;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxBundle : cmSpdxElementCollection
{
  cm::optional<std::string> Context;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxBom : cmSpdxBundle
{
  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxSbom final : cmSpdxBom
{
  enum TypeId
  {
    ANALYZED,
    BUILD,
    DEPLOYED,
    DESIGN,
    RUNTIME,
    SOURCE,
    TEST
  };

  cm::optional<std::vector<TypeId>> Types;
  cm::optional<TypeId> LifecycleScope;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxSoftwareArtifact : cmSpdxArtifact
{
  enum PurposeId
  {
    APPLICATION,
    ARCHIVE,
    CONTAINER,
    DATA,
    DEVICE,
    FIRMWARE,
    FILE,
    INSTALL,
    LIBRARY,
    MODULE,
    OPERATING_SYSTEM,
    SOURCE
  };

  cm::optional<PurposeId> PrimaryPurpose;
  cm::optional<std::vector<PurposeId>> AdditionalPurpose;
  cm::optional<std::string> CopyrightText;
  cm::optional<std::string> AttributionText;
  cm::optional<cmSbomObject> ContentIdentifier;
  cm::optional<std::string> ArtifactSize;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxPackage final : cmSpdxSoftwareArtifact
{
  cm::optional<std::string> DownloadLocation;
  cm::optional<std::string> Homepage;
  cm::optional<std::string> PackageVersion;
  cm::optional<std::string> PackageUrl;
  cm::optional<std::string> SourceInfo;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxAnyLicenseInfo : cmSpdxElement
{
  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxLicenseExpression final : cmSpdxAnyLicenseInfo
{
  cm::optional<std::string> LicenseExpression;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxDocument final : cmSpdxElementCollection
{
  cm::optional<cmSbomObject> ExternalMap;
  cm::optional<cmSbomObject> NamespaceMap;
  cm::optional<cmSbomObject> DataLicense;

  void Serialize(cmSbomSerializer& serializer) const override;
};

struct cmSpdxContentIdentifier final : cmSpdxIntegrityMethod
{
  cm::optional<std::string> ContentIdentifierType;
  cm::optional<std::string> ContentValue;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxFile final : cmSpdxArtifact
{
  enum FileKindId
  {
    DIRECTORY,
    FILE
  };
  cm::optional<MediaType> ContentType;
  cm::optional<FileKindId> FileType;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSpdxSnippet final : cmSpdxSoftwareArtifact
{
  cm::optional<std::string> ByteRange;
  cm::optional<std::string> LineRange;
  cm::optional<cmSbomObject> SnippetFromFile;

  void Serialize(cmSbomSerializer&) const override;
};

struct cmSbomDocument
{
  cm::optional<std::string> Context;
  std::vector<cmSbomObject> Graph;

  void Serialize(cmSbomSerializer&) const;
};