mirror of
https://github.com/Kitware/CMake.git
synced 2025-10-14 02:08:27 +08:00
1009 lines
22 KiB
C++
1009 lines
22 KiB
C++
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file LICENSE.rst or https://cmake.org/licensing for details. */
|
|
#pragma once
|
|
|
|
#include <array>
|
|
#include <cstddef>
|
|
#include <map>
|
|
#include <new>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <cm/optional>
|
|
#include <cm/type_traits>
|
|
|
|
#include <cm3p/json/value.h>
|
|
|
|
#include "cmStringAlgorithms.h"
|
|
|
|
// Base Class
|
|
|
|
struct cmSPDXSerializationBase
|
|
{
|
|
enum SPDXTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
|
|
#define X_SPDX(classtype, enumid, title, camel) enumid,
|
|
#include "cmSPDXTypes.def"
|
|
|
|
SPDX_TYPE_ID_MAX,
|
|
};
|
|
|
|
SPDXTypeId getTypeId() const;
|
|
|
|
std::string NodeId;
|
|
|
|
protected:
|
|
cmSPDXSerializationBase(SPDXTypeId id);
|
|
cmSPDXSerializationBase(SPDXTypeId id, std::string nodeId);
|
|
|
|
private:
|
|
SPDXTypeId TypeId;
|
|
};
|
|
|
|
// Convenience Classes
|
|
|
|
struct cmSPDXIdentifierReference : cmSPDXSerializationBase
|
|
{
|
|
cmSPDXIdentifierReference();
|
|
cmSPDXIdentifierReference(cmSPDXSerializationBase const& ref);
|
|
cmSPDXIdentifierReference(std::string const& ref);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXNonElementBase : cmSPDXSerializationBase
|
|
{
|
|
protected:
|
|
cmSPDXNonElementBase(SPDXTypeId id);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Core Data Types
|
|
|
|
// Nominally these are supposed to be validated strings
|
|
using cmSPDXDateTime = std::string;
|
|
using cmSPDXMediaType = std::string;
|
|
using cmSPDXSemVer = std::string;
|
|
|
|
// SPDX Core Enums
|
|
|
|
struct cmSPDXAnnotationType
|
|
{
|
|
enum cmSPDXAnnotationTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
OTHER,
|
|
REVIEW,
|
|
};
|
|
|
|
cmSPDXAnnotationTypeId TypeId;
|
|
|
|
cmSPDXAnnotationType(cmSPDXAnnotationTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXExternalIdentifierType
|
|
{
|
|
enum cmSPDXExternalIdentifierTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
CPE22,
|
|
CPE23,
|
|
CVE,
|
|
EMAIL,
|
|
GITOID,
|
|
OTHER,
|
|
PACKAGE_URL,
|
|
SECURITY_OTHER,
|
|
SWHID,
|
|
SWID,
|
|
URL_SCHEME,
|
|
};
|
|
|
|
cmSPDXExternalIdentifierTypeId TypeId;
|
|
|
|
cmSPDXExternalIdentifierType(
|
|
cmSPDXExternalIdentifierTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXExternalRefType
|
|
{
|
|
enum cmSPDXExternalRefTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
ALT_DOWNLOAD_LOCATION,
|
|
ALT_WEB_PAGE,
|
|
BINARY_ARTIFACT,
|
|
BOWER,
|
|
BUILD_META,
|
|
BUILD_SYSTEM,
|
|
CERTIFICATION_REPORT,
|
|
CHAT,
|
|
COMPONENT_ANALYSIS_REPORT,
|
|
CWE,
|
|
DOCUMENTATION,
|
|
DYNAMIC_ANALYSIS_REPORT,
|
|
EOL_NOTICE,
|
|
EXPORT_CONTROL_ASSESSMENT,
|
|
FUNDING,
|
|
ISSUE_TRACKER,
|
|
LICENSE,
|
|
MAILING_LIST,
|
|
MAVEN_CENTRAL,
|
|
METRICS,
|
|
NPM,
|
|
NUGET,
|
|
OTHER,
|
|
PRIVACY_ASSESSMENT,
|
|
PRODUCT_METADATA,
|
|
PURCHASE_ORDER,
|
|
QUALITY_ASSESSMENT_REPORT,
|
|
RELEASE_HISTORY,
|
|
RELEASE_NOTES,
|
|
RISK_ASSESSMENT,
|
|
RUNTIME_ANALYSIS_REPORT,
|
|
SECURE_SOFTWARE_ATTESTATION,
|
|
SECURITY_ADVERSARY_MODEL,
|
|
SECURITY_ADVISORY,
|
|
SECURITY_FIX,
|
|
SECURITY_OTHER,
|
|
SECURITY_PEN_TEST_REPORT,
|
|
SECURITY_POLICY,
|
|
SECURITY_THREAT_MODEL,
|
|
SOCIAL_MEDIA,
|
|
SOURCE_ARTIFACT,
|
|
STATIC_ANALYSIS_REPORT,
|
|
SUPPORT,
|
|
VCS,
|
|
VULNERABILITY_DISCLOSURE_REPORT,
|
|
VULNERABILITY_EXPLOITABILITY_ASSESSMENT,
|
|
};
|
|
|
|
cmSPDXExternalRefTypeId TypeId;
|
|
|
|
cmSPDXExternalRefType(cmSPDXExternalRefTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXHashAlgorithm
|
|
{
|
|
enum cmSPDXHashAlgorithmId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
ADLER32,
|
|
BLAKE2B256,
|
|
BLAKE2B384,
|
|
BLAKE2B512,
|
|
BLAKE3,
|
|
CRYSTALS_DILITHIUM,
|
|
CRYSTALS_KYBER,
|
|
FALCON,
|
|
MD2,
|
|
MD4,
|
|
MD5,
|
|
MD6,
|
|
OTHER,
|
|
SHA1,
|
|
SHA224,
|
|
SHA256,
|
|
SHA384,
|
|
SHA3_224,
|
|
SHA3_256,
|
|
SHA3_384,
|
|
SHA3_512,
|
|
SHA512,
|
|
};
|
|
|
|
cmSPDXHashAlgorithmId TypeId;
|
|
|
|
cmSPDXHashAlgorithm(cmSPDXHashAlgorithmId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXLifecycleScopeType
|
|
{
|
|
enum cmSPDXLifecycleScopeTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
BUILD,
|
|
DESIGN,
|
|
DEVELOPMENT,
|
|
OTHER,
|
|
RUNTIME,
|
|
TEST,
|
|
};
|
|
|
|
cmSPDXLifecycleScopeTypeId TypeId;
|
|
|
|
cmSPDXLifecycleScopeType(cmSPDXLifecycleScopeTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXProfileIdentifierType
|
|
{
|
|
enum cmSPDXProfileIdentifierTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
AI,
|
|
BUILD,
|
|
CORE,
|
|
DATASET,
|
|
EXPANDED_LICENSING,
|
|
EXTENSION,
|
|
LITE,
|
|
SECURITY,
|
|
SIMPLE_LICENSING,
|
|
SOFTWARE,
|
|
};
|
|
|
|
cmSPDXProfileIdentifierTypeId TypeId;
|
|
|
|
cmSPDXProfileIdentifierType(cmSPDXProfileIdentifierTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXRelationshipCompletenessType
|
|
{
|
|
enum cmSPDXRelationshipCompletenessTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
COMPLETE,
|
|
INCOMPLETE,
|
|
NO_ASSERTION,
|
|
};
|
|
|
|
cmSPDXRelationshipCompletenessTypeId TypeId;
|
|
|
|
cmSPDXRelationshipCompletenessType(
|
|
cmSPDXRelationshipCompletenessTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXRelationshipType
|
|
{
|
|
enum cmSPDXRelationshipTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
AFFECTS,
|
|
AMENDED_BY,
|
|
ANCESTOR_OF,
|
|
AVAILABLE_FROM,
|
|
CONFIGURES,
|
|
CONTAINS,
|
|
COORDINATED_BY,
|
|
COPIED_TO,
|
|
DELEGATED_TO,
|
|
DEPENDS_ON,
|
|
DESCENDANT_OF,
|
|
DESCRIBES,
|
|
DOES_NOT_AFFECT,
|
|
EXPANDS_TO,
|
|
EXPLOIT_CREATED_BY,
|
|
FIXED_BY,
|
|
FIXED_IN,
|
|
FOUND_BY,
|
|
GENERATES,
|
|
HAS_ADDED_FILE,
|
|
HAS_ASSESSMENT_FOR,
|
|
HAS_ASSOCIATED_VULNERABILITY,
|
|
HAS_CONCLUDED_LICENSE,
|
|
HAS_DATA_FILE,
|
|
HAS_DECLARED_LICENSE,
|
|
HAS_DELETED_FILE,
|
|
HAS_DEPENDENCY_MANIFEST,
|
|
HAS_DISTRIBUTION_ARTIFACT,
|
|
HAS_DOCUMENTATION,
|
|
HAS_DYNAMIC_LINK,
|
|
HAS_EVIDENCE,
|
|
HAS_EXAMPLE,
|
|
HAS_HOST,
|
|
HAS_INPUT,
|
|
HAS_METADATA,
|
|
HAS_OPTIONAL_COMPONENT,
|
|
HAS_OPTIONAL_DEPENDENCY,
|
|
HAS_OUTPUT,
|
|
HAS_PREREQUISITE,
|
|
HAS_PROVIDED_DEPENDENCY,
|
|
HAS_REQUIREMENT,
|
|
HAS_SPECIFICATION,
|
|
HAS_STATIC_LINK,
|
|
HAS_TEST,
|
|
HAS_TEST_CASE,
|
|
HAS_VARIANT,
|
|
INVOKED_BY,
|
|
MODIFIED_BY,
|
|
OTHER,
|
|
PACKAGED_BY,
|
|
PATCHED_BY,
|
|
PUBLISHED_BY,
|
|
REPORTED_BY,
|
|
REPUBLISHED_BY,
|
|
SERIALIZED_IN_ARTIFACT,
|
|
TESTED_ON,
|
|
TRAINED_ON,
|
|
UNDER_INVESTIGATION_FOR,
|
|
USES_TOOL,
|
|
};
|
|
|
|
cmSPDXRelationshipTypeId TypeId;
|
|
|
|
cmSPDXRelationshipType(cmSPDXRelationshipTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXSupportType
|
|
{
|
|
enum cmSPDXSupportTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
DEPLOYED,
|
|
DEVELOPMENT,
|
|
END_OF_SUPPORT,
|
|
LIMITED_SUPPORT,
|
|
NO_ASSERTION,
|
|
NO_SUPPORT,
|
|
SUPPORT,
|
|
};
|
|
|
|
cmSPDXSupportTypeId TypeId;
|
|
|
|
cmSPDXSupportType(cmSPDXSupportTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Core NonElement Classes, Abstract
|
|
|
|
struct cmSPDXIntegrityMethod : cmSPDXNonElementBase
|
|
{
|
|
|
|
cm::optional<std::string> Comment;
|
|
|
|
protected:
|
|
cmSPDXIntegrityMethod(SPDXTypeId id);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Core NonElement Classes, Concrete
|
|
|
|
struct cmSPDXCreationInfo : cmSPDXNonElementBase
|
|
{
|
|
cm::optional<std::string> Comment;
|
|
cmSPDXDateTime Created;
|
|
std::vector<cmSPDXIdentifierReference> CreatedBy;
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> CreatedUsing;
|
|
|
|
cmSPDXCreationInfo();
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXDictionaryEntry : cmSPDXNonElementBase
|
|
{
|
|
std::string Key;
|
|
cm::optional<std::string> Value;
|
|
|
|
cmSPDXDictionaryEntry();
|
|
cmSPDXDictionaryEntry(std::string key);
|
|
cmSPDXDictionaryEntry(std::string key, std::string val);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXExternalIdentifier : cmSPDXNonElementBase
|
|
{
|
|
cm::optional<std::string> Comment;
|
|
cmSPDXExternalIdentifierType ExternalIdentifierType;
|
|
std::string Identifier;
|
|
cm::optional<std::vector<std::string>> IdentifierLocator;
|
|
cm::optional<std::string> IssuingAuthority;
|
|
|
|
cmSPDXExternalIdentifier();
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXExternalMap : cmSPDXNonElementBase
|
|
{
|
|
cm::optional<cmSPDXIdentifierReference> DefiningArtifact;
|
|
std::string ExternalSpdxId;
|
|
cm::optional<std::string> LocationHint;
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> IntegrityMethod;
|
|
|
|
cmSPDXExternalMap();
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXExternalRef : cmSPDXNonElementBase
|
|
{
|
|
cm::optional<std::string> Comment;
|
|
cm::optional<cmSPDXMediaType> ContentType;
|
|
cm::optional<cmSPDXExternalRefType> ExternalRefType;
|
|
cm::optional<std::vector<std::string>> Locator;
|
|
|
|
cmSPDXExternalRef();
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXHash : cmSPDXIntegrityMethod
|
|
{
|
|
cmSPDXHashAlgorithm Algorithm;
|
|
std::string HashValue;
|
|
|
|
cmSPDXHash();
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXNamespaceMap : cmSPDXNonElementBase
|
|
{
|
|
std::string Namespace;
|
|
std::string Prefix;
|
|
|
|
cmSPDXNamespaceMap();
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXPackageVerificationCode : cmSPDXIntegrityMethod
|
|
{
|
|
cmSPDXHashAlgorithm Algorithm;
|
|
std::string HashValue;
|
|
cm::optional<std::vector<std::string>> PackageVerificationCodeExcludedFile;
|
|
|
|
cmSPDXPackageVerificationCode();
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXPositiveIntegerRange : cmSPDXNonElementBase
|
|
{
|
|
unsigned int BeginIntegerRange;
|
|
unsigned int EndIntegerRange;
|
|
|
|
cmSPDXPositiveIntegerRange(unsigned int beingIntegerRange = 0,
|
|
unsigned int endIntegerRange = 0);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Core Element Classes, Abstract
|
|
|
|
struct cmSPDXElement : cmSPDXSerializationBase
|
|
{
|
|
cm::optional<std::string> Comment;
|
|
cmSPDXIdentifierReference CreationInfo;
|
|
cm::optional<std::string> Description;
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> Extension;
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> ExternalIdentifier;
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> ExternalRef;
|
|
cm::optional<std::string> Name;
|
|
// SpdxId is the NodeId
|
|
cm::optional<std::string> Summary;
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> VerifiedUsing;
|
|
|
|
protected:
|
|
cmSPDXElement(SPDXTypeId id, cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXArtifact : cmSPDXElement
|
|
{
|
|
cm::optional<cmSPDXDateTime> BuiltTime;
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> OriginatedBy;
|
|
cm::optional<cmSPDXDateTime> ReleaseTime;
|
|
cm::optional<std::vector<std::string>> StandardName;
|
|
cm::optional<cmSPDXIdentifierReference> SuppliedBy;
|
|
cm::optional<std::vector<cmSPDXSupportType>> SupportType;
|
|
cm::optional<cmSPDXDateTime> ValidUntilTime;
|
|
|
|
protected:
|
|
cmSPDXArtifact(SPDXTypeId id, cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXElementCollection : cmSPDXElement
|
|
{
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> Element;
|
|
cm::optional<std::vector<cmSPDXProfileIdentifierType>> ProfileConformance;
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> RootElement;
|
|
|
|
protected:
|
|
cmSPDXElementCollection(SPDXTypeId id,
|
|
cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Implicit Core Element Classes, Abstract
|
|
|
|
// Nominally an inheritable class, but adds nothing to Element
|
|
using cmSPDXAgentAbstract = cmSPDXElement;
|
|
|
|
struct cmSPDXBundleAbstract : cmSPDXElementCollection
|
|
{
|
|
std::string Context;
|
|
|
|
protected:
|
|
cmSPDXBundleAbstract(SPDXTypeId id, cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// Nominally an inheritable class, but adds nothing to Bundle
|
|
using cmSPDXBomAbstract = cmSPDXBundleAbstract;
|
|
|
|
struct cmSPDXRelationshipAbstract : cmSPDXElement
|
|
{
|
|
cm::optional<cmSPDXRelationshipCompletenessType> Completeness;
|
|
cm::optional<cmSPDXDateTime> EndTime;
|
|
cmSPDXIdentifierReference From;
|
|
cmSPDXRelationshipType RelationshipType;
|
|
cm::optional<cmSPDXDateTime> StartTime;
|
|
std::vector<cmSPDXIdentifierReference> To;
|
|
|
|
protected:
|
|
cmSPDXRelationshipAbstract(SPDXTypeId id,
|
|
cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Core Element Classes, Concrete
|
|
|
|
struct cmSPDXAgent : cmSPDXAgentAbstract
|
|
{
|
|
cmSPDXAgent(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXAnnotation : cmSPDXElement
|
|
{
|
|
cmSPDXAnnotationType AnnotationType;
|
|
cm::optional<cmSPDXMediaType> ContentType;
|
|
cm::optional<std::string> Statement;
|
|
cmSPDXIdentifierReference Subject;
|
|
|
|
cmSPDXAnnotation(cmSPDXCreationInfo const& creationInfo,
|
|
cmSPDXIdentifierReference subject = {});
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXBom : cmSPDXBomAbstract
|
|
{
|
|
cmSPDXBom(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXBundle : cmSPDXBundleAbstract
|
|
{
|
|
cmSPDXBundle(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXIndividualElement : cmSPDXElement
|
|
{
|
|
cmSPDXIndividualElement(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXLifecycleScopedRelationship : cmSPDXRelationshipAbstract
|
|
{
|
|
cm::optional<cmSPDXLifecycleScopeType> Scope;
|
|
|
|
cmSPDXLifecycleScopedRelationship(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXOrganization : cmSPDXAgentAbstract
|
|
{
|
|
cmSPDXOrganization(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXPerson : cmSPDXAgentAbstract
|
|
{
|
|
cmSPDXPerson(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXRelationship : cmSPDXRelationshipAbstract
|
|
{
|
|
cmSPDXRelationship(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXSoftwareAgent : cmSPDXAgentAbstract
|
|
{
|
|
cmSPDXSoftwareAgent(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXSpdxDocument : cmSPDXElementCollection
|
|
{
|
|
cm::optional<cmSPDXIdentifierReference> DataLicense;
|
|
cm::optional<cmSPDXIdentifierReference> ExternalMap;
|
|
cm::optional<cmSPDXIdentifierReference> NamespaceMap;
|
|
|
|
cmSPDXSpdxDocument(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXTool : cmSPDXElement
|
|
{
|
|
cmSPDXTool(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Software Enums
|
|
|
|
struct cmSPDXContentIdentifierType
|
|
{
|
|
enum cmSPDXContentIdentifierTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
GITOID,
|
|
SWHID,
|
|
};
|
|
|
|
cmSPDXContentIdentifierTypeId TypeId;
|
|
|
|
cmSPDXContentIdentifierType(cmSPDXContentIdentifierTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXFileKindType
|
|
{
|
|
enum cmSPDXFileKindTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
DIRECTORY,
|
|
FILE,
|
|
};
|
|
|
|
cmSPDXFileKindTypeId TypeId;
|
|
|
|
cmSPDXFileKindType(cmSPDXFileKindTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXSbomType
|
|
{
|
|
enum cmSPDXSbomTypeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
ANALYZED,
|
|
BUILD,
|
|
DEPLOYED,
|
|
DESIGN,
|
|
RUNTIME,
|
|
SOURCE,
|
|
};
|
|
|
|
cmSPDXSbomTypeId TypeId;
|
|
|
|
cmSPDXSbomType(cmSPDXSbomTypeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXSoftwarePurpose
|
|
{
|
|
enum cmSPDXSoftwarePurposeId
|
|
{
|
|
INVALID = -1,
|
|
NULL_ID = 0,
|
|
APPLICATION,
|
|
ARCHIVE,
|
|
BOM,
|
|
CONFIGURATION,
|
|
CONTAINER,
|
|
DATA,
|
|
DEVICE,
|
|
DEVICE_DRIVER,
|
|
DISK_IMAGE,
|
|
DOCUMENTATION,
|
|
EVIDENCE,
|
|
EXECUTABLE,
|
|
FILE,
|
|
FILESYSTEM_IMAGE,
|
|
FIRMWARE,
|
|
FRAMEWORK,
|
|
INSTALL,
|
|
LIBRARY,
|
|
MANIFEST,
|
|
MODEL,
|
|
MODULE,
|
|
OPERATING_SYSTEM,
|
|
OTHER,
|
|
PATCH,
|
|
PLATFORM,
|
|
REQUIREMENT,
|
|
SOURCE,
|
|
SPECIFICATION,
|
|
TEST,
|
|
};
|
|
|
|
cmSPDXSoftwarePurposeId TypeId;
|
|
|
|
cmSPDXSoftwarePurpose(cmSPDXSoftwarePurposeId typeId = NULL_ID);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Software NonElement Classes, Concrete
|
|
|
|
struct cmSPDXContentIdentifier : cmSPDXIntegrityMethod
|
|
{
|
|
cmSPDXContentIdentifierType ContentIdentifierType;
|
|
std::string ContentIdentifierValue;
|
|
|
|
cmSPDXContentIdentifier();
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Software Element Classes, Abstract
|
|
|
|
struct cmSPDXSoftwareArtifact : cmSPDXArtifact
|
|
{
|
|
cm::optional<std::vector<cmSPDXSoftwarePurpose>> AdditionalPurpose;
|
|
cm::optional<std::string> AttributionText;
|
|
cm::optional<cmSPDXIdentifierReference> ContentIdentifier;
|
|
cm::optional<std::string> CopyrightText;
|
|
cm::optional<cmSPDXSoftwarePurpose> PrimaryPurpose;
|
|
|
|
protected:
|
|
cmSPDXSoftwareArtifact(SPDXTypeId id,
|
|
cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX Software Element Classes, Concrete
|
|
|
|
struct cmSPDXFile : cmSPDXSoftwareArtifact
|
|
{
|
|
cm::optional<cmSPDXMediaType> ContentType;
|
|
cm::optional<cmSPDXFileKindType> FileKind;
|
|
|
|
cmSPDXFile(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXPackage : cmSPDXSoftwareArtifact
|
|
{
|
|
cm::optional<std::string> DownloadLocation;
|
|
cm::optional<std::string> HomePage;
|
|
cm::optional<std::string> PackageUrl;
|
|
cm::optional<std::string> PackageVersion;
|
|
cm::optional<std::string> SourceInfo;
|
|
|
|
cmSPDXPackage(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXSbom : cmSPDXBomAbstract
|
|
{
|
|
cm::optional<std::vector<cmSPDXSbomType>> SbomType;
|
|
|
|
cmSPDXSbom(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXSnippet : cmSPDXSoftwareArtifact
|
|
{
|
|
cm::optional<cmSPDXIdentifierReference> ByteRange;
|
|
cm::optional<cmSPDXIdentifierReference> LineRange;
|
|
cmSPDXIdentifierReference SnippetFromFile;
|
|
|
|
cmSPDXSnippet(cmSPDXCreationInfo const& creationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// SPDX SimpleLicensing Element Classes, Abstract
|
|
|
|
// Nominally an inheritable class, but adds nothing to Element
|
|
using cmSPDXAnyLicenseInfo = cmSPDXElement;
|
|
|
|
// SPDX SimpleLicensing Element Classes, Concrete
|
|
|
|
struct cmSPDXLicenseExpression : cmSPDXAnyLicenseInfo
|
|
{
|
|
cm::optional<std::vector<cmSPDXIdentifierReference>> CustomIdToUri;
|
|
std::string LicenseExpression;
|
|
cm::optional<cmSPDXSemVer> LicenseListVersion;
|
|
|
|
cmSPDXLicenseExpression(cmSPDXCreationInfo const& CreationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
struct cmSPDXSimpleLicensingText : cmSPDXElement
|
|
{
|
|
std::string LicenseText;
|
|
|
|
cmSPDXSimpleLicensingText(cmSPDXCreationInfo const& CreationInfo);
|
|
|
|
Json::Value toJsonLD() const;
|
|
};
|
|
|
|
// Graph Manipulation
|
|
|
|
template <typename T>
|
|
cmSPDXSerializationBase::SPDXTypeId cmSPDXGetTypeId();
|
|
|
|
template <typename T>
|
|
std::string cmSPDXGetTypeName();
|
|
|
|
#define X_SPDX(classtype, enumid, member, camel) \
|
|
template <> \
|
|
cmSPDXSerializationBase::SPDXTypeId cmSPDXGetTypeId<classtype>(); \
|
|
\
|
|
template <> \
|
|
std::string cmSPDXGetTypeName<classtype>();
|
|
#include "cmSPDXTypes.def"
|
|
|
|
template <class T>
|
|
struct cmSPDXTag
|
|
{
|
|
using type = T;
|
|
};
|
|
|
|
union cmSPDXObject
|
|
{
|
|
|
|
cmSPDXSerializationBase SerializationBase;
|
|
|
|
cmSPDXObject();
|
|
cmSPDXObject(cmSPDXObject const& other);
|
|
cmSPDXObject(cmSPDXObject&& other) noexcept;
|
|
|
|
#define X_SPDX(classtype, enumid, member, camel) \
|
|
classtype member; \
|
|
cmSPDXObject(classtype val); \
|
|
\
|
|
template <typename... Args> \
|
|
cmSPDXObject(cmSPDXTag<classtype>, Args&&... args) \
|
|
{ \
|
|
new (&member) classtype(std::forward<Args>(args)...); \
|
|
}
|
|
#include "cmSPDXTypes.def"
|
|
|
|
cmSPDXObject& operator=(cmSPDXObject const& other);
|
|
cmSPDXObject& operator=(cmSPDXObject&& other) noexcept;
|
|
|
|
~cmSPDXObject();
|
|
|
|
template <typename T>
|
|
T* get()
|
|
{
|
|
T* ptr;
|
|
get(&ptr);
|
|
return ptr;
|
|
}
|
|
|
|
Json::Value toJsonLD() const;
|
|
|
|
private:
|
|
#define X_SPDX(classtype, enumid, member, camel) void get(classtype** ptr);
|
|
#include "cmSPDXTypes.def"
|
|
};
|
|
|
|
struct cmSPDXSimpleGraph
|
|
{
|
|
cmSPDXSimpleGraph(std::string iriBase, cmSPDXCreationInfo creationInfo = {});
|
|
|
|
template <typename T, typename... Args>
|
|
cm::enable_if_t<std::is_base_of<cmSPDXElement, T>::value, T>& insert(
|
|
Args&&... args)
|
|
{
|
|
std::string nodeId = cmStrCat(IRIBase, IRICount++);
|
|
auto const& it =
|
|
Graph.emplace(std::piecewise_construct, std::forward_as_tuple(nodeId),
|
|
std::forward_as_tuple(cmSPDXTag<T>{}, *CreationInfo,
|
|
std::forward<Args>(args)...));
|
|
auto& node = *it.first->second.template get<T>();
|
|
node.NodeId = std::move(nodeId);
|
|
return node;
|
|
}
|
|
|
|
cmSPDXCreationInfo& getCreationInfo();
|
|
|
|
template <typename T, typename... Args>
|
|
cm::enable_if_t<std::is_base_of<cmSPDXNonElementBase, T>::value, T>& insert(
|
|
Args&&... args)
|
|
{
|
|
std::size_t nodeCount = BlankCounts[cmSPDXGetTypeId<T>()]++;
|
|
std::string nodeId =
|
|
cmStrCat("_:", cmSPDXGetTypeName<T>(), "_", nodeCount);
|
|
auto const& it = Graph.emplace(
|
|
std::piecewise_construct, std::forward_as_tuple(nodeId),
|
|
std::forward_as_tuple(cmSPDXTag<T>{}, std::forward<Args>(args)...));
|
|
auto& node = *it.first->second.template get<T>();
|
|
node.NodeId = std::move(nodeId);
|
|
return node;
|
|
}
|
|
|
|
template <typename T>
|
|
T* get(std::string const& key)
|
|
{
|
|
auto it = Graph.find(key);
|
|
if (it == Graph.end()) {
|
|
return nullptr;
|
|
}
|
|
return it->second.get<T>();
|
|
}
|
|
|
|
template <typename T>
|
|
T* get(cmSPDXIdentifierReference const& key)
|
|
{
|
|
auto it = Graph.find(key.NodeId);
|
|
if (it == Graph.end()) {
|
|
return nullptr;
|
|
}
|
|
return it->second.get<T>();
|
|
}
|
|
|
|
Json::Value toJsonLD();
|
|
|
|
private:
|
|
std::string IRIBase;
|
|
std::size_t IRICount{ 0 };
|
|
std::array<std::size_t, cmSPDXSerializationBase::SPDX_TYPE_ID_MAX>
|
|
BlankCounts{};
|
|
|
|
std::map<std::string, cmSPDXObject> Graph;
|
|
cmSPDXCreationInfo* CreationInfo;
|
|
};
|