CMake/Source/cmSPDXSerializer.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#include "cmSPDXSerializer.h"

#include <new>
#include <string>

#include <cm/optional>

#include <cm3p/json/value.h>

// Serialization Utilities

template <typename T>
void addVectorSPDXValue(Json::Value& obj, std::string const& key,
                        std::vector<T> const& vec)
{
  auto& list = obj[key];
  list = Json::Value(Json::arrayValue);
  for (auto const& val : vec) {
    list.append(val.toJsonLD());
  }
}

template <>
void addVectorSPDXValue(Json::Value& obj, std::string const& key,
                        std::vector<std::string> const& vec)
{
  auto& list = obj[key];
  list = Json::Value(Json::arrayValue);
  for (auto const& val : vec) {
    list.append(val);
  }
}

template <typename T>
void addOptionalSPDXValue(Json::Value& obj, std::string const& key,
                          cm::optional<std::vector<T>> const& opt)
{
  if (opt) {
    addVectorSPDXValue(obj, key, *opt);
  }
}

template <typename T>
void addOptionalSPDXValue(Json::Value& obj, std::string const& key,
                          cm::optional<T> const& opt)
{
  if (opt) {
    obj[key] = opt->toJsonLD();
  }
}

template <>
void addOptionalSPDXValue(Json::Value& obj, std::string const& key,
                          cm::optional<std::string> const& opt)
{
  if (opt) {
    obj[key] = *opt;
  }
}

// Base Class

cmSPDXSerializationBase::SPDXTypeId cmSPDXSerializationBase::getTypeId() const
{
  return TypeId;
}

cmSPDXSerializationBase::cmSPDXSerializationBase(SPDXTypeId id)
  : TypeId(id)
{
}

cmSPDXSerializationBase::cmSPDXSerializationBase(SPDXTypeId id,
                                                 std::string nodeId)
  : NodeId(std::move(nodeId))
  , TypeId(id)
{
}

// Convenience Classes

cmSPDXIdentifierReference::cmSPDXIdentifierReference()
  : cmSPDXSerializationBase(CM_IDENTIFIER_REFERENCE)
{
}
cmSPDXIdentifierReference::cmSPDXIdentifierReference(
  cmSPDXSerializationBase const& ref)
  : cmSPDXSerializationBase(CM_IDENTIFIER_REFERENCE, ref.NodeId)
{
}
cmSPDXIdentifierReference::cmSPDXIdentifierReference(std::string const& ref)
  : cmSPDXSerializationBase(CM_IDENTIFIER_REFERENCE, ref)
{
}

Json::Value cmSPDXIdentifierReference::toJsonLD() const
{
  return NodeId;
}

cmSPDXNonElementBase::cmSPDXNonElementBase(SPDXTypeId id)
  : cmSPDXSerializationBase(id)
{
}

Json::Value cmSPDXNonElementBase::toJsonLD() const
{
  Json::Value obj(Json::objectValue);
  obj["@id"] = NodeId;
  return obj;
}

// SPDX Core Enums

cmSPDXAnnotationType::cmSPDXAnnotationType(cmSPDXAnnotationTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXAnnotationType::toJsonLD() const
{
  switch (TypeId) {
    case OTHER:
      return "other";
    case REVIEW:
      return "review";
    default:
      return "INVALID_ANNOTATION_TYPE_ID";
  }
}

cmSPDXExternalIdentifierType::cmSPDXExternalIdentifierType(
  cmSPDXExternalIdentifierTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXExternalIdentifierType::toJsonLD() const
{
  switch (TypeId) {
    case CPE22:
      return "cpe22";
    case CPE23:
      return "cpe23";
    case CVE:
      return "cve";
    case EMAIL:
      return "email";
    case GITOID:
      return "gitoid";
    case OTHER:
      return "other";
    case PACKAGE_URL:
      return "packageUrl";
    case SECURITY_OTHER:
      return "securityOther";
    case SWHID:
      return "swhid";
    case SWID:
      return "swid";
    case URL_SCHEME:
      return "urlScheme";
    default:
      return "INVALID_EXTERNAL_IDENTIFIER_TYPE_ID";
  }
}

cmSPDXExternalRefType::cmSPDXExternalRefType(cmSPDXExternalRefTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXExternalRefType::toJsonLD() const
{
  switch (TypeId) {
    case ALT_DOWNLOAD_LOCATION:
      return "altDownloadLocation:";
    case ALT_WEB_PAGE:
      return "altWebPage";
    case BINARY_ARTIFACT:
      return "binaryArtifact";
    case BOWER:
      return "bower";
    case BUILD_META:
      return "buildMeta";
    case BUILD_SYSTEM:
      return "buildSystem";
    case CERTIFICATION_REPORT:
      return "certificationReport";
    case CHAT:
      return "chat";
    case COMPONENT_ANALYSIS_REPORT:
      return "componentAnalysisReport";
    case CWE:
      return "cwe";
    case DOCUMENTATION:
      return "documentation";
    case DYNAMIC_ANALYSIS_REPORT:
      return "dynamicAnalysisReport";
    case EOL_NOTICE:
      return "eolNotice";
    case EXPORT_CONTROL_ASSESSMENT:
      return "exportControlAssessment";
    case FUNDING:
      return "funding";
    case ISSUE_TRACKER:
      return "issueTracker";
    case LICENSE:
      return "license";
    case MAILING_LIST:
      return "mailingList";
    case MAVEN_CENTRAL:
      return "mavenCentral";
    case METRICS:
      return "metrics";
    case NPM:
      return "npm";
    case NUGET:
      return "nuget";
    case OTHER:
      return "other";
    case PRIVACY_ASSESSMENT:
      return "privacyAssessment";
    case PRODUCT_METADATA:
      return "productMetadata";
    case PURCHASE_ORDER:
      return "purchaseOrder";
    case QUALITY_ASSESSMENT_REPORT:
      return "qualityAssessmentReport";
    case RELEASE_HISTORY:
      return "releaseHistory";
    case RELEASE_NOTES:
      return "releaseNotes";
    case RISK_ASSESSMENT:
      return "riskAssessment";
    case RUNTIME_ANALYSIS_REPORT:
      return "runtimeAnalysisReport";
    case SECURE_SOFTWARE_ATTESTATION:
      return "secureSoftwareAttestation";
    case SECURITY_ADVERSARY_MODEL:
      return "securityAdversaryModel";
    case SECURITY_ADVISORY:
      return "securityAdvisory";
    case SECURITY_FIX:
      return "securityFix";
    case SECURITY_OTHER:
      return "securityOther";
    case SECURITY_PEN_TEST_REPORT:
      return "securityPenTestReport";
    case SECURITY_POLICY:
      return "securityPolicy";
    case SECURITY_THREAT_MODEL:
      return "securityThreatModel";
    case SOCIAL_MEDIA:
      return "socialMedia";
    case SOURCE_ARTIFACT:
      return "sourceArtifact";
    case STATIC_ANALYSIS_REPORT:
      return "staticAnalysisReport";
    case SUPPORT:
      return "support";
    case VCS:
      return "vcs";
    case VULNERABILITY_DISCLOSURE_REPORT:
      return "vulnerabilityDisclosureReport";
    case VULNERABILITY_EXPLOITABILITY_ASSESSMENT:
      return "vulnerabilityExploitabilityAssessment";
    default:
      return "INVALID_EXTERNAL_REF_TYPE_ID";
  }
}

cmSPDXHashAlgorithm::cmSPDXHashAlgorithm(cmSPDXHashAlgorithmId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXHashAlgorithm::toJsonLD() const
{
  switch (TypeId) {
    case ADLER32:
      return "adler32";
    case BLAKE2B256:
      return "blake2b256";
    case BLAKE2B384:
      return "blake2b384";
    case BLAKE2B512:
      return "blake2b512";
    case BLAKE3:
      return "blake3";
    case CRYSTALS_DILITHIUM:
      return "crystalsDilithium";
    case CRYSTALS_KYBER:
      return "crystalsLyber";
    case FALCON:
      return "falcon";
    case MD2:
      return "md2";
    case MD4:
      return "md4";
    case MD5:
      return "md5";
    case MD6:
      return "md6";
    case OTHER:
      return "other";
    case SHA1:
      return "sha1";
    case SHA224:
      return "sha224";
    case SHA256:
      return "sha256";
    case SHA384:
      return "sha384";
    case SHA3_224:
      return "sha3_224";
    case SHA3_256:
      return "sha3_256";
    case SHA3_384:
      return "sha3_384";
    case SHA3_512:
      return "sha3_512";
    case SHA512:
      return "sha512";
    default:
      return "INVALID_HASH_TYPE_ID";
  }
}

cmSPDXLifecycleScopeType::cmSPDXLifecycleScopeType(
  cmSPDXLifecycleScopeTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXLifecycleScopeType::toJsonLD() const
{
  switch (TypeId) {
    case BUILD:
      return "build";
    case DESIGN:
      return "design";
    case DEVELOPMENT:
      return "development";
    case OTHER:
      return "other";
    case RUNTIME:
      return "runtime";
    case TEST:
      return "test";
    default:
      return "INVALID_LIFECYCLE_SCOPE_TYPE_ID";
  }
}

cmSPDXProfileIdentifierType::cmSPDXProfileIdentifierType(
  cmSPDXProfileIdentifierTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXProfileIdentifierType::toJsonLD() const
{
  switch (TypeId) {
    case AI:
      return "ai";
    case BUILD:
      return "build";
    case CORE:
      return "code";
    case DATASET:
      return "dataset";
    case EXPANDED_LICENSING:
      return "expandedLicensing";
    case EXTENSION:
      return "extension";
    case LITE:
      return "lite";
    case SECURITY:
      return "security";
    case SIMPLE_LICENSING:
      return "simpleLicensing";
    case SOFTWARE:
      return "software";
    default:
      return "INVALID_PROFILE_IDENTIFIER_TYPE_ID";
  }
}

cmSPDXRelationshipCompletenessType::cmSPDXRelationshipCompletenessType(
  cmSPDXRelationshipCompletenessTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXRelationshipCompletenessType::toJsonLD() const
{
  switch (TypeId) {
    case COMPLETE:
      return "complete";
    case INCOMPLETE:
      return "incomplete";
    case NO_ASSERTION:
      return "noAssertion";
    default:
      return "INVALID_RELATIONSHIP_COMPLETENESS_TYPE_ID";
  }
}

cmSPDXRelationshipType::cmSPDXRelationshipType(cmSPDXRelationshipTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXRelationshipType::toJsonLD() const
{
  switch (TypeId) {
    case AFFECTS:
      return "affects";
    case AMENDED_BY:
      return "amendedBy";
    case ANCESTOR_OF:
      return "ancestorOf";
    case AVAILABLE_FROM:
      return "availableFrom";
    case CONFIGURES:
      return "configures";
    case CONTAINS:
      return "contains";
    case COORDINATED_BY:
      return "coordinatedBy";
    case COPIED_TO:
      return "copiedTo";
    case DELEGATED_TO:
      return "delegatedTo";
    case DEPENDS_ON:
      return "dependsOn";
    case DESCENDANT_OF:
      return "descendantOf";
    case DESCRIBES:
      return "describes";
    case DOES_NOT_AFFECT:
      return "doesNotAffect";
    case EXPANDS_TO:
      return "expandsTo";
    case EXPLOIT_CREATED_BY:
      return "exploitCreatedBy";
    case FIXED_BY:
      return "fixedBy";
    case FIXED_IN:
      return "fixedIn";
    case FOUND_BY:
      return "foundBy";
    case GENERATES:
      return "generates";
    case HAS_ADDED_FILE:
      return "hasAddedFile";
    case HAS_ASSESSMENT_FOR:
      return "hasAssessmentFor";
    case HAS_ASSOCIATED_VULNERABILITY:
      return "hasAssociatedVulnerability";
    case HAS_CONCLUDED_LICENSE:
      return "hasConcludedLicense";
    case HAS_DATA_FILE:
      return "hasDataFile";
    case HAS_DECLARED_LICENSE:
      return "hasDeclaredLicense";
    case HAS_DELETED_FILE:
      return "hasDeletedFile";
    case HAS_DEPENDENCY_MANIFEST:
      return "hasDependencyManifest";
    case HAS_DISTRIBUTION_ARTIFACT:
      return "hasDistributionArtifact";
    case HAS_DOCUMENTATION:
      return "hasDocumentation";
    case HAS_DYNAMIC_LINK:
      return "hasDynamicLink";
    case HAS_EVIDENCE:
      return "hasEvidence";
    case HAS_EXAMPLE:
      return "hasExample";
    case HAS_HOST:
      return "hasHost";
    case HAS_INPUT:
      return "hasInput";
    case HAS_METADATA:
      return "hasMetadata";
    case HAS_OPTIONAL_COMPONENT:
      return "hasOptionalComponent";
    case HAS_OPTIONAL_DEPENDENCY:
      return "hasOptionalDependency";
    case HAS_OUTPUT:
      return "hasOutput";
    case HAS_PREREQUISITE:
      return "hasPrerequisite";
    case HAS_PROVIDED_DEPENDENCY:
      return "hasProvidedDependency";
    case HAS_REQUIREMENT:
      return "hasRequirement";
    case HAS_SPECIFICATION:
      return "hasSpecification";
    case HAS_STATIC_LINK:
      return "hasStaticLink";
    case HAS_TEST:
      return "hasTest";
    case HAS_TEST_CASE:
      return "hasTestCase";
    case HAS_VARIANT:
      return "hasVariant";
    case INVOKED_BY:
      return "invokedBy";
    case MODIFIED_BY:
      return "modifiedBy";
    case OTHER:
      return "other";
    case PACKAGED_BY:
      return "packagedBy";
    case PATCHED_BY:
      return "patchedBy";
    case PUBLISHED_BY:
      return "publishedBy";
    case REPORTED_BY:
      return "reportedBy";
    case REPUBLISHED_BY:
      return "republishedBy";
    case SERIALIZED_IN_ARTIFACT:
      return "serializedInArtifact";
    case TESTED_ON:
      return "testedOn";
    case TRAINED_ON:
      return "trainedOn";
    case UNDER_INVESTIGATION_FOR:
      return "underInvestigationFor";
    case USES_TOOL:
      return "usesTool";
    default:
      return "INVALID_RELATIONSHIP_TYPE_ID";
  }
}

cmSPDXSupportType::cmSPDXSupportType(cmSPDXSupportTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXSupportType::toJsonLD() const
{
  switch (TypeId) {
    case DEPLOYED:
      return "deployed";
    case DEVELOPMENT:
      return "development";
    case END_OF_SUPPORT:
      return "endOfSupport";
    case LIMITED_SUPPORT:
      return "limitedSupport";
    case NO_ASSERTION:
      return "noAssertion";
    case NO_SUPPORT:
      return "noSupport";
    case SUPPORT:
      return "support";
    default:
      return "INVALID_SUPPORT_TYPE_ID";
  }
}

// SPDX Core NonElement Classes, Abstract

cmSPDXIntegrityMethod::cmSPDXIntegrityMethod(SPDXTypeId id)
  : cmSPDXNonElementBase(id)
{
}

Json::Value cmSPDXIntegrityMethod::toJsonLD() const
{
  auto obj = cmSPDXNonElementBase::toJsonLD();
  addOptionalSPDXValue(obj, "comment", Comment);
  return obj;
}

// SPDX Core NonElement Classes, Concrete

cmSPDXCreationInfo::cmSPDXCreationInfo()
  : cmSPDXNonElementBase(CORE_CREATION_INFO)
{
}

Json::Value cmSPDXCreationInfo::toJsonLD() const
{
  auto obj = cmSPDXNonElementBase::toJsonLD();
  obj["type"] = "CreationInfo";
  addOptionalSPDXValue(obj, "Comment", Comment);
  obj["created"] = Created;
  addVectorSPDXValue(obj, "createdBy", CreatedBy);
  addOptionalSPDXValue(obj, "createdUsing", CreatedUsing);
  return obj;
}

cmSPDXDictionaryEntry::cmSPDXDictionaryEntry()
  : cmSPDXNonElementBase(CORE_DICTIONARY_ENTRY)
{
}
cmSPDXDictionaryEntry::cmSPDXDictionaryEntry(std::string key)
  : cmSPDXNonElementBase(CORE_DICTIONARY_ENTRY)
  , Key(std::move(key))
{
}
cmSPDXDictionaryEntry::cmSPDXDictionaryEntry(std::string key, std::string val)
  : cmSPDXNonElementBase(CORE_DICTIONARY_ENTRY)
  , Key(std::move(key))
  , Value(std::move(val))
{
}

Json::Value cmSPDXDictionaryEntry::toJsonLD() const
{
  auto obj = cmSPDXNonElementBase::toJsonLD();
  obj["type"] = "DictionaryEntry";
  obj["key"] = Key;
  addOptionalSPDXValue(obj, "value", Value);
  return obj;
}

cmSPDXExternalIdentifier::cmSPDXExternalIdentifier()
  : cmSPDXNonElementBase(CORE_EXTERNAL_IDENTIFIER)
{
}

Json::Value cmSPDXExternalIdentifier::toJsonLD() const
{
  auto obj = cmSPDXNonElementBase::toJsonLD();
  obj["type"] = "ExternalIdentifier";
  addOptionalSPDXValue(obj, "comment", Comment);
  obj["externalIdentifierType"] = ExternalIdentifierType.toJsonLD();
  obj["identifier"] = Identifier;
  addOptionalSPDXValue(obj, "identifierLocator", IdentifierLocator);
  addOptionalSPDXValue(obj, "issuingAuthority", IssuingAuthority);
  return obj;
}

cmSPDXExternalMap::cmSPDXExternalMap()
  : cmSPDXNonElementBase(CORE_EXTERNAL_MAP)
{
}

Json::Value cmSPDXExternalMap::toJsonLD() const
{
  auto obj = cmSPDXNonElementBase::toJsonLD();
  obj["type"] = "ExternalMap";
  addOptionalSPDXValue(obj, "definingArtifact", DefiningArtifact);
  obj["externalSpdxId"] = ExternalSpdxId;
  addOptionalSPDXValue(obj, "locationHint", LocationHint);
  addOptionalSPDXValue(obj, "integrityMethod", IntegrityMethod);
  return obj;
}

cmSPDXExternalRef::cmSPDXExternalRef()
  : cmSPDXNonElementBase(CORE_EXTERNAL_REF)
{
}

Json::Value cmSPDXExternalRef::toJsonLD() const
{
  auto obj = cmSPDXNonElementBase::toJsonLD();
  obj["type"] = "ExternalRef";
  addOptionalSPDXValue(obj, "comment", Comment);
  addOptionalSPDXValue(obj, "contentType", ContentType);
  addOptionalSPDXValue(obj, "externalRefType", ExternalRefType);
  addOptionalSPDXValue(obj, "locator", Locator);
  return obj;
}

cmSPDXHash::cmSPDXHash()
  : cmSPDXIntegrityMethod(CORE_HASH)
{
}

Json::Value cmSPDXHash::toJsonLD() const
{
  auto obj = cmSPDXIntegrityMethod::toJsonLD();
  obj["type"] = "Hash";
  obj["algorithm"] = Algorithm.toJsonLD();
  obj["hashValue"] = HashValue;
  return obj;
}

cmSPDXNamespaceMap::cmSPDXNamespaceMap()
  : cmSPDXNonElementBase(CORE_NAMESPACE_MAP)
{
}

Json::Value cmSPDXNamespaceMap::toJsonLD() const
{
  auto obj = cmSPDXNonElementBase::toJsonLD();
  obj["type"] = "NamespaceMap";
  obj["namespace"] = Namespace;
  obj["prefix"] = Namespace;
  return obj;
}

cmSPDXPackageVerificationCode::cmSPDXPackageVerificationCode()
  : cmSPDXIntegrityMethod(CORE_PACKAGE_VERIFICATION_CODE)
{
}

Json::Value cmSPDXPackageVerificationCode::toJsonLD() const
{
  auto obj = cmSPDXIntegrityMethod::toJsonLD();
  obj["type"] = "PackageVerificationCode";
  obj["algorithm"] = Algorithm.toJsonLD();
  obj["hashValue"] = HashValue;
  return obj;
}

cmSPDXPositiveIntegerRange::cmSPDXPositiveIntegerRange(
  unsigned int beingIntegerRange, unsigned int endIntegerRange)
  : cmSPDXNonElementBase(CORE_POSITIVE_INTEGER_RANGE)
  , BeginIntegerRange(beingIntegerRange)
  , EndIntegerRange(endIntegerRange)
{
}

Json::Value cmSPDXPositiveIntegerRange::toJsonLD() const
{
  auto obj = cmSPDXNonElementBase::toJsonLD();
  obj["type"] = "PositiveIntegerRange";
  obj["beginIntegerRange"] = BeginIntegerRange;
  obj["endIntegerRange"] = EndIntegerRange;
  return obj;
}

// SPDX Core Element Classes, Abstract

cmSPDXElement::cmSPDXElement(SPDXTypeId id,
                             cmSPDXCreationInfo const& creationInfo)
  : cmSPDXSerializationBase(id)
  , CreationInfo(creationInfo)
{
}

Json::Value cmSPDXElement::toJsonLD() const
{
  Json::Value obj(Json::objectValue);
  addOptionalSPDXValue(obj, "comment", Comment);
  obj["creationInfo"] = CreationInfo.toJsonLD();
  addOptionalSPDXValue(obj, "description", Description);
  addOptionalSPDXValue(obj, "extension", Extension);
  addOptionalSPDXValue(obj, "externalIdentifier", ExternalIdentifier);
  addOptionalSPDXValue(obj, "externalRef", ExternalRef);
  addOptionalSPDXValue(obj, "name", Name);
  obj["spdxId"] = NodeId;
  addOptionalSPDXValue(obj, "summary", Summary);
  addOptionalSPDXValue(obj, "verifiedUsing", VerifiedUsing);
  return obj;
}

cmSPDXArtifact::cmSPDXArtifact(SPDXTypeId id,
                               cmSPDXCreationInfo const& creationInfo)
  : cmSPDXElement(id, creationInfo)
{
}

Json::Value cmSPDXArtifact::toJsonLD() const
{
  auto obj = cmSPDXElement::toJsonLD();
  addOptionalSPDXValue(obj, "builtTime", BuiltTime);
  addOptionalSPDXValue(obj, "originateBy", OriginatedBy);
  addOptionalSPDXValue(obj, "releaseTime", ReleaseTime);
  addOptionalSPDXValue(obj, "standardName", StandardName);
  addOptionalSPDXValue(obj, "suppliedBy", SuppliedBy);
  addOptionalSPDXValue(obj, "supportType", SupportType);
  addOptionalSPDXValue(obj, "validUntilTime", ValidUntilTime);
  return obj;
}

cmSPDXElementCollection::cmSPDXElementCollection(
  SPDXTypeId id, cmSPDXCreationInfo const& creationInfo)
  : cmSPDXElement(id, creationInfo)
{
}

Json::Value cmSPDXElementCollection::toJsonLD() const
{
  auto obj = cmSPDXElement::toJsonLD();
  addOptionalSPDXValue(obj, "element", Element);
  addOptionalSPDXValue(obj, "profileConformance", ProfileConformance);
  addOptionalSPDXValue(obj, "rootElement", RootElement);
  return obj;
}

// SPDX Implicit Core Element Classes, Abstract

// Nominally an inheritable class, but adds nothing to Element
using cmSPDXAgentAbstract = cmSPDXElement;

cmSPDXBundleAbstract::cmSPDXBundleAbstract(
  SPDXTypeId id, cmSPDXCreationInfo const& creationInfo)
  : cmSPDXElementCollection(id, creationInfo)
{
}

Json::Value cmSPDXBundleAbstract::toJsonLD() const
{
  auto obj = cmSPDXElementCollection::toJsonLD();
  obj["context"] = Context;
  return obj;
}

// Nominally an inheritable class, but adds nothing to Bundle
using cmSPDXBomAbstract = cmSPDXBundleAbstract;

cmSPDXRelationshipAbstract::cmSPDXRelationshipAbstract(
  SPDXTypeId id, cmSPDXCreationInfo const& creationInfo)
  : cmSPDXElement(id, creationInfo)
{
}

Json::Value cmSPDXRelationshipAbstract::toJsonLD() const
{
  auto obj = cmSPDXElement::toJsonLD();
  addOptionalSPDXValue(obj, "completeness", Completeness);
  addOptionalSPDXValue(obj, "endTime", EndTime);
  obj["from"] = From.toJsonLD();
  obj["relationshipType"] = RelationshipType.toJsonLD();
  addOptionalSPDXValue(obj, "startTime", StartTime);
  addVectorSPDXValue(obj, "to", To);
  return obj;
}

// SPDX Core Element Classes, Concrete

cmSPDXAgent::cmSPDXAgent(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXAgentAbstract(CORE_AGENT, creationInfo)
{
}

Json::Value cmSPDXAgent::toJsonLD() const
{
  auto obj = cmSPDXAgentAbstract::toJsonLD();
  obj["type"] = "Agent";
  return obj;
}

cmSPDXAnnotation::cmSPDXAnnotation(cmSPDXCreationInfo const& creationInfo,
                                   cmSPDXIdentifierReference subject)
  : cmSPDXElement(CORE_ANNOTATION, creationInfo)
  , Subject(std::move(subject))
{
}

Json::Value cmSPDXAnnotation::toJsonLD() const
{
  auto obj = cmSPDXElement::toJsonLD();
  obj["type"] = "Annotation";
  obj["annotationType"] = AnnotationType.toJsonLD();
  addOptionalSPDXValue(obj, "contentType", ContentType);
  addOptionalSPDXValue(obj, "statement", Statement);
  obj["subject"] = Subject.toJsonLD();
  return obj;
}

cmSPDXBom::cmSPDXBom(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXBomAbstract(CORE_BOM, creationInfo)
{
}

Json::Value cmSPDXBom::toJsonLD() const
{
  auto obj = cmSPDXBomAbstract::toJsonLD();
  obj["type"] = "Bom";
  return obj;
}

cmSPDXBundle::cmSPDXBundle(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXBundleAbstract(CORE_BUNDLE, creationInfo)
{
}

Json::Value cmSPDXBundle::toJsonLD() const
{
  auto obj = cmSPDXBundleAbstract::toJsonLD();
  obj["type"] = "Bundle";
  return obj;
}

cmSPDXIndividualElement::cmSPDXIndividualElement(
  cmSPDXCreationInfo const& creationInfo)
  : cmSPDXElement(CORE_INDIVIDUAL_ELEMENT, creationInfo)
{
}

Json::Value cmSPDXIndividualElement::toJsonLD() const
{
  auto obj = cmSPDXElement::toJsonLD();
  obj["type"] = "IndividualElement";
  return obj;
}

cmSPDXLifecycleScopedRelationship::cmSPDXLifecycleScopedRelationship(
  cmSPDXCreationInfo const& creationInfo)
  : cmSPDXRelationshipAbstract(CORE_LIFECYCLE_SCOPED_RELATIONSHIP,
                               creationInfo)
{
}

Json::Value cmSPDXLifecycleScopedRelationship::toJsonLD() const
{
  auto obj = cmSPDXRelationshipAbstract::toJsonLD();
  obj["type"] = "LifecycleScopedRelationship";
  addOptionalSPDXValue(obj, "scope", Scope);
  return obj;
}

cmSPDXOrganization::cmSPDXOrganization(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXAgentAbstract(CORE_ORGANIZATION, creationInfo)
{
}

Json::Value cmSPDXOrganization::toJsonLD() const
{
  auto obj = cmSPDXAgentAbstract::toJsonLD();
  obj["type"] = "Organization";
  return obj;
}

cmSPDXPerson::cmSPDXPerson(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXAgentAbstract(CORE_PERSON, creationInfo)
{
}

Json::Value cmSPDXPerson::toJsonLD() const
{
  auto obj = cmSPDXAgentAbstract::toJsonLD();
  obj["type"] = "Person";
  return obj;
}

cmSPDXRelationship::cmSPDXRelationship(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXRelationshipAbstract(CORE_RELATIONSHIP, creationInfo)
{
}

Json::Value cmSPDXRelationship::toJsonLD() const
{
  auto obj = cmSPDXRelationshipAbstract::toJsonLD();
  obj["type"] = "Relationship";
  return obj;
}

cmSPDXSoftwareAgent::cmSPDXSoftwareAgent(
  cmSPDXCreationInfo const& creationInfo)
  : cmSPDXAgentAbstract(CORE_SOFTWARE_AGENT, creationInfo)
{
}

Json::Value cmSPDXSoftwareAgent::toJsonLD() const
{
  auto obj = cmSPDXAgentAbstract::toJsonLD();
  obj["type"] = "SoftwareAgent";
  return obj;
}

cmSPDXSpdxDocument::cmSPDXSpdxDocument(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXElementCollection(CORE_SPDX_DOCUMENT, creationInfo)
{
}

Json::Value cmSPDXSpdxDocument::toJsonLD() const
{
  auto obj = cmSPDXElementCollection::toJsonLD();
  obj["type"] = "SpdxDocument";
  addOptionalSPDXValue(obj, "dataLicense", DataLicense);
  addOptionalSPDXValue(obj, "externalMap", ExternalMap);
  addOptionalSPDXValue(obj, "namespaceMap", NamespaceMap);
  return obj;
}

cmSPDXTool::cmSPDXTool(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXElement(CORE_TOOL, creationInfo)
{
}

Json::Value cmSPDXTool::toJsonLD() const
{
  auto obj = cmSPDXElement::toJsonLD();
  obj["type"] = "Tool";
  return obj;
}

// SPDX Software Enums

cmSPDXContentIdentifierType::cmSPDXContentIdentifierType(
  cmSPDXContentIdentifierTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXContentIdentifierType::toJsonLD() const
{
  switch (TypeId) {
    case GITOID:
      return "gitoid";
    case SWHID:
      return "swhid";
    default:
      return "INVALID_CONTENT_IDENTIFIER_TYPE_ID";
  }
}

cmSPDXFileKindType::cmSPDXFileKindType(cmSPDXFileKindTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXFileKindType::toJsonLD() const
{
  switch (TypeId) {
    case DIRECTORY:
      return "directory";
    case FILE:
      return "file";
    default:
      return "INVALID_FILE_KIND_TYPE_ID";
  }
}

cmSPDXSbomType::cmSPDXSbomType(cmSPDXSbomTypeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXSbomType::toJsonLD() const
{
  switch (TypeId) {
    case ANALYZED:
      return "analyzed";
    case BUILD:
      return "build";
    case DEPLOYED:
      return "deployed";
    case DESIGN:
      return "design";
    case RUNTIME:
      return "runtime";
    case SOURCE:
      return "source";
    default:
      return "INVALID_SBOM_TYPE_ID";
  }
}

cmSPDXSoftwarePurpose::cmSPDXSoftwarePurpose(cmSPDXSoftwarePurposeId typeId)
  : TypeId(typeId)
{
}

Json::Value cmSPDXSoftwarePurpose::toJsonLD() const
{
  switch (TypeId) {
    case APPLICATION:
      return "application";
    case ARCHIVE:
      return "archive";
    case BOM:
      return "bom";
    case CONFIGURATION:
      return "configuration";
    case CONTAINER:
      return "container";
    case DATA:
      return "data";
    case DEVICE:
      return "device";
    case DEVICE_DRIVER:
      return "deviceDriver";
    case DISK_IMAGE:
      return "diskImage";
    case DOCUMENTATION:
      return "documentation";
    case EVIDENCE:
      return "evidence";
    case EXECUTABLE:
      return "executable";
    case FILE:
      return "file";
    case FILESYSTEM_IMAGE:
      return "filesystemImage";
    case FIRMWARE:
      return "firmware";
    case FRAMEWORK:
      return "framework";
    case INSTALL:
      return "install";
    case LIBRARY:
      return "library";
    case MANIFEST:
      return "manifest";
    case MODEL:
      return "model";
    case MODULE:
      return "module";
    case OPERATING_SYSTEM:
      return "operatingSystem";
    case OTHER:
      return "other";
    case PATCH:
      return "patch";
    case PLATFORM:
      return "platform";
    case REQUIREMENT:
      return "requirement";
    case SOURCE:
      return "source";
    case SPECIFICATION:
      return "specification";
    case TEST:
      return "test";
    default:
      return "INVALID_SOFTWARE_PURPOSE_ID";
  }
}

// SPDX Software NonElement Classes, Concrete

cmSPDXContentIdentifier::cmSPDXContentIdentifier()
  : cmSPDXIntegrityMethod(SOFTWARE_CONTENT_IDENTIFIER)
{
}

Json::Value cmSPDXContentIdentifier::toJsonLD() const
{
  auto obj = cmSPDXIntegrityMethod::toJsonLD();
  obj["type"] = "ContentIdentifier";
  obj["contentIdentifierType"] = ContentIdentifierType.toJsonLD();
  obj["contentIdentifierValue"] = ContentIdentifierValue;
  return obj;
}

// SPDX Software Element Classes, Abstract

cmSPDXSoftwareArtifact::cmSPDXSoftwareArtifact(
  SPDXTypeId id, cmSPDXCreationInfo const& creationInfo)
  : cmSPDXArtifact(id, creationInfo)
{
}

Json::Value cmSPDXSoftwareArtifact::toJsonLD() const
{
  auto obj = cmSPDXArtifact::toJsonLD();
  addOptionalSPDXValue(obj, "additionalPurpose", AdditionalPurpose);
  addOptionalSPDXValue(obj, "attributionText", AttributionText);
  addOptionalSPDXValue(obj, "contentIdentifier", ContentIdentifier);
  addOptionalSPDXValue(obj, "copyrightText", CopyrightText);
  addOptionalSPDXValue(obj, "primaryPurpose", PrimaryPurpose);
  return obj;
}

// SPDX Software Element Classes, Concrete

cmSPDXFile::cmSPDXFile(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXSoftwareArtifact(SOFTWARE_FILE, creationInfo)
{
}

Json::Value cmSPDXFile::toJsonLD() const
{
  auto obj = cmSPDXSoftwareArtifact::toJsonLD();
  obj["type"] = "File";
  addOptionalSPDXValue(obj, "contentType", ContentType);
  addOptionalSPDXValue(obj, "fileKind", FileKind);
  return obj;
}

cmSPDXPackage::cmSPDXPackage(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXSoftwareArtifact(SOFTWARE_PACKAGE, creationInfo)
{
}

Json::Value cmSPDXPackage::toJsonLD() const
{
  auto obj = cmSPDXSoftwareArtifact::toJsonLD();
  obj["type"] = "Package";
  addOptionalSPDXValue(obj, "downloadLocation", DownloadLocation);
  addOptionalSPDXValue(obj, "homePage", HomePage);
  addOptionalSPDXValue(obj, "packageUrl", PackageUrl);
  addOptionalSPDXValue(obj, "packageVersion", PackageVersion);
  addOptionalSPDXValue(obj, "sourceInfo", SourceInfo);
  return obj;
}

cmSPDXSbom::cmSPDXSbom(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXBomAbstract(SOFTWARE_SBOM, creationInfo)
{
}

Json::Value cmSPDXSbom::toJsonLD() const
{
  auto obj = cmSPDXBomAbstract::toJsonLD();
  obj["type"] = "Sbom";
  addOptionalSPDXValue(obj, "sbomType", SbomType);
  return obj;
}

cmSPDXSnippet::cmSPDXSnippet(cmSPDXCreationInfo const& creationInfo)
  : cmSPDXSoftwareArtifact(SOFTWARE_SNIPPET, creationInfo)
{
}

Json::Value cmSPDXSnippet::toJsonLD() const
{
  auto obj = cmSPDXSoftwareArtifact::toJsonLD();
  obj["type"] = "Snippet";
  addOptionalSPDXValue(obj, "byteRange", ByteRange);
  addOptionalSPDXValue(obj, "lineRange", LineRange);
  obj["snippetFromFile"] = SnippetFromFile.toJsonLD();
  return obj;
}

// SPDX SimpleLicensing Element Classes, Concrete

cmSPDXLicenseExpression::cmSPDXLicenseExpression(
  cmSPDXCreationInfo const& creationInfo)
  : cmSPDXAnyLicenseInfo(SIMPLE_LICENSING_LICENSE_EXPRESSION, creationInfo)
{
}

Json::Value cmSPDXLicenseExpression::toJsonLD() const
{
  auto obj = cmSPDXAnyLicenseInfo::toJsonLD();
  obj["type"] = "LicenseExpression";
  addOptionalSPDXValue(obj, "customIdToUri", CustomIdToUri);
  obj["licenseExpression"] = LicenseExpression;
  addOptionalSPDXValue(obj, "licenseListVersion", LicenseListVersion);
  return obj;
}

cmSPDXSimpleLicensingText::cmSPDXSimpleLicensingText(
  cmSPDXCreationInfo const& creationInfo)
  : cmSPDXElement(SIMPLE_LICENSING_SIMPLE_LICENSING_TEXT, creationInfo)
{
}

Json::Value cmSPDXSimpleLicensingText::toJsonLD() const
{
  auto obj = cmSPDXElement::toJsonLD();
  obj["type"] = "SimpleLicensingText";
  obj["licenseText"] = LicenseText;
  return obj;
}

// Graph Manipulation

#define X_SPDX(classtype, enumid, member, camel)                              \
  template <>                                                                 \
  cmSPDXSerializationBase::SPDXTypeId cmSPDXGetTypeId<classtype>()            \
  {                                                                           \
    return cmSPDXSerializationBase::enumid;                                   \
  }                                                                           \
                                                                              \
  template <>                                                                 \
  std::string cmSPDXGetTypeName<classtype>()                                  \
  {                                                                           \
    return #camel;                                                            \
  }                                                                           \
                                                                              \
  cmSPDXObject::cmSPDXObject(classtype val)                                   \
    : member(std::move(val)) {};                                              \
                                                                              \
  void cmSPDXObject::get(classtype** ptr)                                     \
  {                                                                           \
    *ptr = SerializationBase.getTypeId() == cmSPDXSerializationBase::enumid   \
      ? &member                                                               \
      : nullptr;                                                              \
  }
#include "cmSPDXTypes.def"

cmSPDXObject::cmSPDXObject()
  : IdentifierReference("UNINITIALIZED_SPDX_OBJECT")
{
}

cmSPDXObject::cmSPDXObject(cmSPDXObject const& other)
{
  switch (other.SerializationBase.getTypeId()) {
#define X_SPDX(classtype, enumid, member, camel)                              \
  case cmSPDXSerializationBase::enumid:                                       \
    new (&member) classtype(other.member);                                    \
    break;
#include "cmSPDXTypes.def"
    default:
      new (&IdentifierReference)
        cmSPDXIdentifierReference("UNINITIALIZED_SPDX_OBJECT");
  }
}

cmSPDXObject::cmSPDXObject(cmSPDXObject&& other) noexcept
{
  switch (other.SerializationBase.getTypeId()) {
#define X_SPDX(classtype, enumid, member, camel)                              \
  case cmSPDXSerializationBase::enumid:                                       \
    new (&member) classtype(std::move(other.member));                         \
    break;
#include "cmSPDXTypes.def"
    default:
      new (&IdentifierReference)
        cmSPDXIdentifierReference("UNINITIALIZED_SPDX_OBJECT");
  }
}

cmSPDXObject& cmSPDXObject::operator=(cmSPDXObject const& other)
{
  this->~cmSPDXObject();
  new (this) cmSPDXObject(other);
  return *this;
}

cmSPDXObject& cmSPDXObject::operator=(cmSPDXObject&& other) noexcept
{
  this->~cmSPDXObject();
  new (this) cmSPDXObject(std::move(other));
  return *this;
}

cmSPDXObject::~cmSPDXObject()
{
  switch (SerializationBase.getTypeId()) {
#define X_SPDX(classtype, enumid, member, camel)                              \
  case cmSPDXSerializationBase::enumid:                                       \
    member.~classtype();                                                      \
    break;
#include "cmSPDXTypes.def"
    default:
      break;
  }
}

Json::Value cmSPDXObject::toJsonLD() const
{
  switch (SerializationBase.getTypeId()) {
#define X_SPDX(classtype, enumid, member, camel)                              \
  case cmSPDXSerializationBase::enumid:                                       \
    return member.toJsonLD();
#include "cmSPDXTypes.def"
    default:
      return "INVALID_SPDX_OBJECT_TYPE_ID";
  }
}

cmSPDXSimpleGraph::cmSPDXSimpleGraph(std::string iriBase,
                                     cmSPDXCreationInfo creationInfo)
  : IRIBase(std::move(iriBase))
  , CreationInfo(&insert<cmSPDXCreationInfo>(std::move(creationInfo)))
{
}

cmSPDXCreationInfo& cmSPDXSimpleGraph::getCreationInfo()
{
  return *CreationInfo;
}

Json::Value cmSPDXSimpleGraph::toJsonLD()
{
  Json::Value obj(Json::objectValue);
  obj["@context"] = "https://spdx.org/rdf/3.0.1/spdx-context.jsonld";

  auto& graph = obj["@graph"];
  for (auto const& it : Graph) {
    graph.append(it.second.toJsonLD());
  }

  return obj;
}