Overhaul structs, refactor JSON parser and saver

Signed-off-by: Ian Ling <ian@iancaling.com>

14 files changed, 494 insertions, 592 deletions

diff --git a/tvloader/parser2v1/parse_annotation.go b/tvloader/parser2v1/parse_annotation.go
index 65680d9..ca2e850 100644
--- a/tvloader/parser2v1/parse_annotation.go
+++ b/tvloader/parser2v1/parse_annotation.go
@@ -18,8 +18,8 @@ func (parser *tvParser2_1) parsePairForAnnotation2_1(tag string, value string) e
 			return err
 		}
 		if subkey == "Person" || subkey == "Organization" || subkey == "Tool" {
-			parser.ann.AnnotatorType = subkey
-			parser.ann.Annotator = subvalue
+			parser.ann.Annotator.AnnotatorType = subkey
+			parser.ann.Annotator.Annotator = subvalue
 			return nil
 		}
 		return fmt.Errorf("unrecognized Annotator type %v", subkey)
diff --git a/tvloader/parser2v1/parse_annotation_test.go b/tvloader/parser2v1/parse_annotation_test.go
index 3fdce9f..eb0f4cf 100644
--- a/tvloader/parser2v1/parse_annotation_test.go
+++ b/tvloader/parser2v1/parse_annotation_test.go
@@ -70,11 +70,11 @@ func TestParser2_1CanParseAnnotationTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.ann.Annotator != "John Doe" {
+	if parser.ann.Annotator.Annotator != "John Doe" {
 		t.Errorf("got %v for Annotator, expected John Doe", parser.ann.Annotator)
 	}
-	if parser.ann.AnnotatorType != "Person" {
-		t.Errorf("got %v for AnnotatorType, expected Person", parser.ann.AnnotatorType)
+	if parser.ann.Annotator.AnnotatorType != "Person" {
+		t.Errorf("got %v for AnnotatorType, expected Person", parser.ann.Annotator.AnnotatorType)
 	}
 
 	// Annotation Date
@@ -156,4 +156,3 @@ func TestParser2_1FailsIfAnnotationRefInvalid(t *testing.T) {
 		t.Errorf("expected non-nil error, got nil")
 	}
 }
-
diff --git a/tvloader/parser2v1/parse_creation_info.go b/tvloader/parser2v1/parse_creation_info.go
index 8742bf2..df16008 100644
--- a/tvloader/parser2v1/parse_creation_info.go
+++ b/tvloader/parser2v1/parse_creation_info.go
@@ -17,39 +17,11 @@ func (parser *tvParser2_1) parsePairFromCreationInfo2_1(tag string, value string
 
 	// create an SPDX Creation Info data struct if we don't have one already
 	if parser.doc.CreationInfo == nil {
-		parser.doc.CreationInfo = &spdx.CreationInfo2_1{
-			ExternalDocumentReferences: map[string]spdx.ExternalDocumentRef2_1{},
-		}
+		parser.doc.CreationInfo = &spdx.CreationInfo2_1{}
 	}
 
 	ci := parser.doc.CreationInfo
 	switch tag {
-	case "SPDXVersion":
-		ci.SPDXVersion = value
-	case "DataLicense":
-		ci.DataLicense = value
-	case "SPDXID":
-		eID, err := extractElementID(value)
-		if err != nil {
-			return err
-		}
-		ci.SPDXIdentifier = eID
-	case "DocumentName":
-		ci.DocumentName = value
-	case "DocumentNamespace":
-		ci.DocumentNamespace = value
-	case "ExternalDocumentRef":
-		documentRefID, uri, alg, checksum, err := extractExternalDocumentReference(value)
-		if err != nil {
-			return err
-		}
-		edr := spdx.ExternalDocumentRef2_1{
-			DocumentRefID: documentRefID,
-			URI:           uri,
-			Alg:           alg,
-			Checksum:      checksum,
-		}
-		ci.ExternalDocumentReferences[documentRefID] = edr
 	case "LicenseListVersion":
 		ci.LicenseListVersion = value
 	case "Creator":
@@ -57,22 +29,20 @@ func (parser *tvParser2_1) parsePairFromCreationInfo2_1(tag string, value string
 		if err != nil {
 			return err
 		}
+
+		creator := spdx.Creator{Creator: subvalue}
 		switch subkey {
-		case "Person":
-			ci.CreatorPersons = append(ci.CreatorPersons, subvalue)
-		case "Organization":
-			ci.CreatorOrganizations = append(ci.CreatorOrganizations, subvalue)
-		case "Tool":
-			ci.CreatorTools = append(ci.CreatorTools, subvalue)
+		case "Person", "Organization", "Tool":
+			creator.CreatorType = subkey
 		default:
 			return fmt.Errorf("unrecognized Creator type %v", subkey)
 		}
+
+		ci.Creators = append(ci.Creators, creator)
 	case "Created":
 		ci.Created = value
 	case "CreatorComment":
 		ci.CreatorComment = value
-	case "DocumentComment":
-		ci.DocumentComment = value
 
 	// tag for going on to package section
 	case "PackageName":
@@ -91,7 +61,7 @@ func (parser *tvParser2_1) parsePairFromCreationInfo2_1(tag string, value string
 		return parser.parsePairFromPackage2_1(tag, value)
 	// tag for going on to _unpackaged_ file section
 	case "FileName":
-		// leave pkg as nil, so that packages will be placed in UnpackagedFiles
+		// leave pkg as nil, so that packages will be placed in Files
 		parser.st = psFile2_1
 		parser.pkg = nil
 		return parser.parsePairFromFile2_1(tag, value)
diff --git a/tvloader/parser2v1/parse_creation_info_test.go b/tvloader/parser2v1/parse_creation_info_test.go
index 2a8c094..83058dd 100644
--- a/tvloader/parser2v1/parse_creation_info_test.go
+++ b/tvloader/parser2v1/parse_creation_info_test.go
@@ -58,7 +58,7 @@ func TestParser2_1CIMovesToFileAfterParsingFileNameTagWithNoPackages(t *testing.
 		t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_1)
 	}
 	// and current package should be nil, meaning Files are placed in the
-	// UnpackagedFiles map instead of in a Package
+	// Files map instead of in a Package
 	if parser.pkg != nil {
 		t.Fatalf("expected pkg to be nil, got non-nil pkg")
 	}
@@ -179,7 +179,7 @@ func TestParser2_1HasCreationInfoAfterCallToParseFirstTag(t *testing.T) {
 		doc: &spdx.Document2_1{},
 		st:  psCreationInfo2_1,
 	}
-	err := parser.parsePairFromCreationInfo2_1("SPDXVersion", "SPDX-2.1")
+	err := parser.parsePairFromCreationInfo2_1("LicenseListVersion", "3.9")
 	if err != nil {
 		t.Errorf("got error when calling parsePairFromCreationInfo2_1: %v", err)
 	}
@@ -194,96 +194,8 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) {
 		st:  psCreationInfo2_1,
 	}
 
-	// SPDX Version
-	err := parser.parsePairFromCreationInfo2_1("SPDXVersion", "SPDX-2.1")
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	if parser.doc.CreationInfo.SPDXVersion != "SPDX-2.1" {
-		t.Errorf("got %v for SPDXVersion", parser.doc.CreationInfo.SPDXVersion)
-	}
-
-	// Data License
-	err = parser.parsePairFromCreationInfo2_1("DataLicense", "CC0-1.0")
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	if parser.doc.CreationInfo.DataLicense != "CC0-1.0" {
-		t.Errorf("got %v for DataLicense", parser.doc.CreationInfo.DataLicense)
-	}
-
-	// SPDX Identifier
-	err = parser.parsePairFromCreationInfo2_1("SPDXID", "SPDXRef-DOCUMENT")
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	if parser.doc.CreationInfo.SPDXIdentifier != "DOCUMENT" {
-		t.Errorf("got %v for SPDXIdentifier", parser.doc.CreationInfo.SPDXIdentifier)
-	}
-
-	// Document Name
-	err = parser.parsePairFromCreationInfo2_1("DocumentName", "xyz-2.1.5")
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	if parser.doc.CreationInfo.DocumentName != "xyz-2.1.5" {
-		t.Errorf("got %v for DocumentName", parser.doc.CreationInfo.DocumentName)
-	}
-
-	// Document Namespace
-	err = parser.parsePairFromCreationInfo2_1("DocumentNamespace", "http://example.com/xyz-2.1.5.spdx")
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	if parser.doc.CreationInfo.DocumentNamespace != "http://example.com/xyz-2.1.5.spdx" {
-		t.Errorf("got %v for DocumentNamespace", parser.doc.CreationInfo.DocumentNamespace)
-	}
-
-	// External Document Reference
-	refs := []string{
-		"DocumentRef-spdx-tool-1.2 http://spdx.org/spdxdocs/spdx-tools-v1.2-3F2504E0-4F89-41D3-9A0C-0305E82C3301 SHA1: d6a770ba38583ed4bb4525bd96e50461655d2759",
-		"DocumentRef-xyz-2.1.2 http://example.com/xyz-2.1.2 SHA1:d6a770ba38583ed4bb4525bd96e50461655d2760",
-	}
-	wantRef0 := spdx.ExternalDocumentRef2_1{
-		DocumentRefID: "spdx-tool-1.2",
-		URI:           "http://spdx.org/spdxdocs/spdx-tools-v1.2-3F2504E0-4F89-41D3-9A0C-0305E82C3301",
-		Alg:           "SHA1",
-		Checksum:      "d6a770ba38583ed4bb4525bd96e50461655d2759",
-	}
-	wantRef1 := spdx.ExternalDocumentRef2_1{
-		DocumentRefID: "xyz-2.1.2",
-		URI:           "http://example.com/xyz-2.1.2",
-		Alg:           "SHA1",
-		Checksum:      "d6a770ba38583ed4bb4525bd96e50461655d2760",
-	}
-	err = parser.parsePairFromCreationInfo2_1("ExternalDocumentRef", refs[0])
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	err = parser.parsePairFromCreationInfo2_1("ExternalDocumentRef", refs[1])
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	if len(parser.doc.CreationInfo.ExternalDocumentReferences) != 2 {
-		t.Errorf("got %d ExternalDocumentReferences, expected %d", len(parser.doc.CreationInfo.ExternalDocumentReferences), 2)
-	}
-	gotRef0 := parser.doc.CreationInfo.ExternalDocumentReferences["spdx-tool-1.2"]
-	if gotRef0.DocumentRefID != wantRef0.DocumentRefID ||
-		gotRef0.URI != wantRef0.URI ||
-		gotRef0.Alg != wantRef0.Alg ||
-		gotRef0.Checksum != wantRef0.Checksum {
-		t.Errorf("got %#v for ExternalDocumentReferences[0], wanted %#v", gotRef0, wantRef0)
-	}
-	gotRef1 := parser.doc.CreationInfo.ExternalDocumentReferences["xyz-2.1.2"]
-	if gotRef1.DocumentRefID != wantRef1.DocumentRefID ||
-		gotRef1.URI != wantRef1.URI ||
-		gotRef1.Alg != wantRef1.Alg ||
-		gotRef1.Checksum != wantRef1.Checksum {
-		t.Errorf("got %#v for ExternalDocumentReferences[1], wanted %#v", gotRef1, wantRef1)
-	}
-
 	// License List Version
-	err = parser.parsePairFromCreationInfo2_1("LicenseListVersion", "2.2")
+	err := parser.parsePairFromCreationInfo2_1("LicenseListVersion", "2.2")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
@@ -304,10 +216,10 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if len(parser.doc.CreationInfo.CreatorPersons) != 2 ||
-		parser.doc.CreationInfo.CreatorPersons[0] != "Person A" ||
-		parser.doc.CreationInfo.CreatorPersons[1] != "Person B" {
-		t.Errorf("got %v for CreatorPersons", parser.doc.CreationInfo.CreatorPersons)
+	if len(parser.doc.CreationInfo.Creators) != 2 ||
+		parser.doc.CreationInfo.Creators[0].Creator != "Person A" ||
+		parser.doc.CreationInfo.Creators[1].Creator != "Person B" {
+		t.Errorf("got %+v for Creators", parser.doc.CreationInfo.Creators)
 	}
 
 	// Creators: Organizations
@@ -323,10 +235,10 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if len(parser.doc.CreationInfo.CreatorOrganizations) != 2 ||
-		parser.doc.CreationInfo.CreatorOrganizations[0] != "Organization A" ||
-		parser.doc.CreationInfo.CreatorOrganizations[1] != "Organization B" {
-		t.Errorf("got %v for CreatorOrganizations", parser.doc.CreationInfo.CreatorOrganizations)
+	if len(parser.doc.CreationInfo.Creators) != 4 ||
+		parser.doc.CreationInfo.Creators[2].Creator != "Organization A" ||
+		parser.doc.CreationInfo.Creators[3].Creator != "Organization B" {
+		t.Errorf("got %+v for CreatorOrganizations", parser.doc.CreationInfo.Creators)
 	}
 
 	// Creators: Tools
@@ -342,10 +254,10 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if len(parser.doc.CreationInfo.CreatorTools) != 2 ||
-		parser.doc.CreationInfo.CreatorTools[0] != "Tool A" ||
-		parser.doc.CreationInfo.CreatorTools[1] != "Tool B" {
-		t.Errorf("got %v for CreatorTools", parser.doc.CreationInfo.CreatorTools)
+	if len(parser.doc.CreationInfo.Creators) != 6 ||
+		parser.doc.CreationInfo.Creators[4].Creator != "Tool A" ||
+		parser.doc.CreationInfo.Creators[5].Creator != "Tool B" {
+		t.Errorf("got %v for CreatorTools", parser.doc.CreationInfo.Creators)
 	}
 
 	// Created date
@@ -365,16 +277,6 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) {
 	if parser.doc.CreationInfo.CreatorComment != "Blah whatever" {
 		t.Errorf("got %v for CreatorComment", parser.doc.CreationInfo.CreatorComment)
 	}
-
-	// Document Comment
-	err = parser.parsePairFromCreationInfo2_1("DocumentComment", "Blah whatever")
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	if parser.doc.CreationInfo.DocumentComment != "Blah whatever" {
-		t.Errorf("got %v for DocumentComment", parser.doc.CreationInfo.DocumentComment)
-	}
-
 }
 
 func TestParser2_1InvalidCreatorTagsFail(t *testing.T) {
diff --git a/tvloader/parser2v1/parse_file.go b/tvloader/parser2v1/parse_file.go
index 7347384..81768bb 100644
--- a/tvloader/parser2v1/parse_file.go
+++ b/tvloader/parser2v1/parse_file.go
@@ -49,37 +49,37 @@ func (parser *tvParser2_1) parsePairFromFile2_1(tag string, value string) error
 		}
 		parser.file.FileSPDXIdentifier = eID
 		if parser.pkg == nil {
-			if parser.doc.UnpackagedFiles == nil {
-				parser.doc.UnpackagedFiles = map[spdx.ElementID]*spdx.File2_1{}
+			if parser.doc.Files == nil {
+				parser.doc.Files = []*spdx.File2_1{}
 			}
-			parser.doc.UnpackagedFiles[eID] = parser.file
+			parser.doc.Files = append(parser.doc.Files, parser.file)
 		} else {
 			if parser.pkg.Files == nil {
-				parser.pkg.Files = map[spdx.ElementID]*spdx.File2_1{}
+				parser.pkg.Files = []*spdx.File2_1{}
 			}
-			parser.pkg.Files[eID] = parser.file
+			parser.pkg.Files = append(parser.pkg.Files, parser.file)
 		}
 	case "FileType":
-		parser.file.FileType = append(parser.file.FileType, value)
+		parser.file.FileTypes = append(parser.file.FileTypes, value)
 	case "FileChecksum":
 		subkey, subvalue, err := extractSubs(value)
 		if err != nil {
 			return err
 		}
-		switch subkey {
-		case "SHA1":
-			parser.file.FileChecksumSHA1 = subvalue
-		case "SHA256":
-			parser.file.FileChecksumSHA256 = subvalue
-		case "MD5":
-			parser.file.FileChecksumMD5 = subvalue
+		if parser.file.Checksums == nil {
+			parser.file.Checksums = []spdx.Checksum{}
+		}
+		switch spdx.ChecksumAlgorithm(subkey) {
+		case spdx.SHA1, spdx.SHA256, spdx.MD5:
+			algorithm := spdx.ChecksumAlgorithm(subkey)
+			parser.file.Checksums = append(parser.file.Checksums, spdx.Checksum{Algorithm: algorithm, Value: subvalue})
 		default:
 			return fmt.Errorf("got unknown checksum type %s", subkey)
 		}
 	case "LicenseConcluded":
 		parser.file.LicenseConcluded = value
 	case "LicenseInfoInFile":
-		parser.file.LicenseInfoInFile = append(parser.file.LicenseInfoInFile, value)
+		parser.file.LicenseInfoInFiles = append(parser.file.LicenseInfoInFiles, value)
 	case "LicenseComments":
 		parser.file.LicenseComments = value
 	case "FileCopyrightText":
@@ -103,7 +103,7 @@ func (parser *tvParser2_1) parsePairFromFile2_1(tag string, value string) error
 	case "FileNotice":
 		parser.file.FileNotice = value
 	case "FileContributor":
-		parser.file.FileContributor = append(parser.file.FileContributor, value)
+		parser.file.FileContributors = append(parser.file.FileContributors, value)
 	case "FileDependency":
 		parser.file.FileDependencies = append(parser.file.FileDependencies, value)
 	// for relationship tags, pass along but don't change state
diff --git a/tvloader/parser2v1/parse_file_test.go b/tvloader/parser2v1/parse_file_test.go
index 9f42b55..375f967 100644
--- a/tvloader/parser2v1/parse_file_test.go
+++ b/tvloader/parser2v1/parse_file_test.go
@@ -13,23 +13,23 @@ func TestParser2_1FileStartsNewFileAfterParsingFileNameTag(t *testing.T) {
 	fileOldName := "f1.txt"
 
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: fileOldName, FileSPDXIdentifier: "f1"},
 	}
 	fileOld := parser.file
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = fileOld
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, fileOld)
 	// the Package's Files should have this one only
 	if len(parser.pkg.Files) != 1 {
 		t.Fatalf("expected 1 file, got %d", len(parser.pkg.Files))
 	}
-	if parser.pkg.Files["f1"] != fileOld {
-		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"])
+	if parser.pkg.Files[0] != fileOld {
+		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files[0])
 	}
-	if parser.pkg.Files["f1"].FileName != fileOldName {
-		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName)
+	if parser.pkg.Files[0].FileName != fileOldName {
+		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files[0].FileName)
 	}
 
 	// now add a new file
@@ -55,11 +55,11 @@ func TestParser2_1FileStartsNewFileAfterParsingFileNameTag(t *testing.T) {
 	if len(parser.pkg.Files) != 1 {
 		t.Fatalf("expected 1 file, got %d", len(parser.pkg.Files))
 	}
-	if parser.pkg.Files["f1"] != fileOld {
-		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"])
+	if parser.pkg.Files[0] != fileOld {
+		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files[0])
 	}
-	if parser.pkg.Files["f1"].FileName != fileOldName {
-		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName)
+	if parser.pkg.Files[0].FileName != fileOldName {
+		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files[0].FileName)
 	}
 
 	// now parse an SPDX identifier tag
@@ -71,17 +71,17 @@ func TestParser2_1FileStartsNewFileAfterParsingFileNameTag(t *testing.T) {
 	if len(parser.pkg.Files) != 2 {
 		t.Fatalf("expected 2 files, got %d", len(parser.pkg.Files))
 	}
-	if parser.pkg.Files["f1"] != fileOld {
-		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"])
+	if parser.pkg.Files[0] != fileOld {
+		t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files[0])
 	}
-	if parser.pkg.Files["f1"].FileName != fileOldName {
-		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName)
+	if parser.pkg.Files[0].FileName != fileOldName {
+		t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files[0].FileName)
 	}
-	if parser.pkg.Files["f2ID"] != parser.file {
-		t.Errorf("expected file %v in Files[f2ID], got %v", parser.file, parser.pkg.Files["f2ID"])
+	if parser.pkg.Files[1] != parser.file {
+		t.Errorf("expected file %v in Files[f2ID], got %v", parser.file, parser.pkg.Files[1])
 	}
-	if parser.pkg.Files["f2ID"].FileName != fileName {
-		t.Errorf("expected file name %s in Files[f2ID], got %s", fileName, parser.pkg.Files["f2ID"].FileName)
+	if parser.pkg.Files[1].FileName != fileName {
+		t.Errorf("expected file name %s in Files[f2ID], got %s", fileName, parser.pkg.Files[1].FileName)
 	}
 }
 
@@ -103,12 +103,12 @@ func TestParser2_1FileAddsToPackageOrUnpackagedFiles(t *testing.T) {
 		t.Errorf("got error when calling parsePair2_1: %v", err)
 	}
 	fileOld := parser.file
-	// should have been added to UnpackagedFiles
-	if len(parser.doc.UnpackagedFiles) != 1 {
-		t.Fatalf("expected 1 file in UnpackagedFiles, got %d", len(parser.doc.UnpackagedFiles))
+	// should have been added to Files
+	if len(parser.doc.Files) != 1 {
+		t.Fatalf("expected 1 file in Files, got %d", len(parser.doc.Files))
 	}
-	if parser.doc.UnpackagedFiles["f2ID"] != fileOld {
-		t.Errorf("expected file %v in UnpackagedFiles[f2ID], got %v", fileOld, parser.doc.UnpackagedFiles["f2ID"])
+	if parser.doc.Files[0] != fileOld {
+		t.Errorf("expected file %v in Files[f2ID], got %v", fileOld, parser.doc.Files[0])
 	}
 	// now create a package and a new file
 	err = parser.parsePair2_1("PackageName", "package1")
@@ -127,19 +127,19 @@ func TestParser2_1FileAddsToPackageOrUnpackagedFiles(t *testing.T) {
 	if err != nil {
 		t.Errorf("got error when calling parsePair2_1: %v", err)
 	}
-	// UnpackagedFiles should still be size 1 and have old file only
-	if len(parser.doc.UnpackagedFiles) != 1 {
-		t.Fatalf("expected 1 file in UnpackagedFiles, got %d", len(parser.doc.UnpackagedFiles))
+	// Files should still be size 1 and have old file only
+	if len(parser.doc.Files) != 1 {
+		t.Fatalf("expected 1 file in Files, got %d", len(parser.doc.Files))
 	}
-	if parser.doc.UnpackagedFiles["f2ID"] != fileOld {
-		t.Errorf("expected file %v in UnpackagedFiles[f2ID], got %v", fileOld, parser.doc.UnpackagedFiles["f2ID"])
+	if parser.doc.Files[0] != fileOld {
+		t.Errorf("expected file %v in Files[f2ID], got %v", fileOld, parser.doc.Files[0])
 	}
 	// and new package should have gotten the new file
 	if len(parser.pkg.Files) != 1 {
 		t.Fatalf("expected 1 file in Files, got %d", len(parser.pkg.Files))
 	}
-	if parser.pkg.Files["f3ID"] != parser.file {
-		t.Errorf("expected file %v in Files[f3ID], got %v", parser.file, parser.pkg.Files["f3ID"])
+	if parser.pkg.Files[0] != parser.file {
+		t.Errorf("expected file %v in Files[f3ID], got %v", parser.file, parser.pkg.Files[0])
 	}
 }
 
@@ -149,15 +149,15 @@ func TestParser2_1FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
 	f1Name := "f1.txt"
 
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: p1Name, PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: p1Name, PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: f1Name, FileSPDXIdentifier: "f1"},
 	}
 	p1 := parser.pkg
 	f1 := parser.file
-	parser.doc.Packages["package1"] = p1
-	parser.pkg.Files["f1"] = f1
+	parser.doc.Packages = append(parser.doc.Packages, p1)
+	parser.pkg.Files = append(parser.pkg.Files, f1)
 
 	// now add a new package
 	p2Name := "package2"
@@ -193,21 +193,21 @@ func TestParser2_1FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
 	if len(parser.doc.Packages) != 1 {
 		t.Fatalf("expected 1 package, got %d", len(parser.doc.Packages))
 	}
-	if parser.doc.Packages["package1"] != p1 {
-		t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages["package1"])
+	if parser.doc.Packages[0] != p1 {
+		t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages[0])
 	}
-	if parser.doc.Packages["package1"].PackageName != p1Name {
-		t.Errorf("expected package name %s in Packages[package1], got %s", p1Name, parser.doc.Packages["package1"].PackageName)
+	if parser.doc.Packages[0].PackageName != p1Name {
+		t.Errorf("expected package name %s in Packages[package1], got %s", p1Name, parser.doc.Packages[0].PackageName)
 	}
 	// and the first Package's Files should be of size 1 and have f1 only
-	if len(parser.doc.Packages["package1"].Files) != 1 {
-		t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages["package1"].Files))
+	if len(parser.doc.Packages[0].Files) != 1 {
+		t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages[0].Files))
 	}
-	if parser.doc.Packages["package1"].Files["f1"] != f1 {
-		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages["package1"].Files["f1"])
+	if parser.doc.Packages[0].Files[0] != f1 {
+		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages[0].Files[0])
 	}
-	if parser.doc.Packages["package1"].Files["f1"].FileName != f1Name {
-		t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.doc.Packages["package1"].Files["f1"].FileName)
+	if parser.doc.Packages[0].Files[0].FileName != f1Name {
+		t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.doc.Packages[0].Files[0].FileName)
 	}
 	// and the current file should be nil
 	if parser.file != nil {
@@ -217,13 +217,13 @@ func TestParser2_1FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
 
 func TestParser2_1FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	fileCurrent := parser.file
 
 	err := parser.parsePair2_1("SnippetSPDXID", "SPDXRef-Test1")
@@ -242,13 +242,13 @@ func TestParser2_1FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) {
 
 func TestParser2_1FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic")
 	if err != nil {
@@ -261,13 +261,13 @@ func TestParser2_1FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T)
 
 func TestParser2_1FileMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePair2_1("Reviewer", "Person: John Doe")
 	if err != nil {
@@ -280,13 +280,13 @@ func TestParser2_1FileMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_1FileStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
 	if err != nil {
@@ -309,13 +309,13 @@ func TestParser2_1FileStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_1FileStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePair2_1("Annotator", "Person: John Doe ()")
 	if err != nil {
@@ -361,11 +361,11 @@ func TestParser2_1FileStaysAfterParsingAnnotationTags(t *testing.T) {
 // ===== File data section tests =====
 func TestParser2_1CanParseFileTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psFile2_1,
-		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// File Name
 	err := parser.parsePairFromFile2_1("FileName", "f1.txt")
@@ -393,8 +393,8 @@ func TestParser2_1CanParseFileTags(t *testing.T) {
 	if len(parser.pkg.Files) != 1 {
 		t.Errorf("expected 1 file, got %d", len(parser.pkg.Files))
 	}
-	if parser.pkg.Files["f1"] != parser.file {
-		t.Errorf("expected Files[f1] to be %v, got %v", parser.file, parser.pkg.Files["f1"])
+	if parser.pkg.Files[0] != parser.file {
+		t.Errorf("expected Files[f1] to be %v, got %v", parser.file, parser.pkg.Files[0])
 	}
 
 	// File Type
@@ -410,18 +410,18 @@ func TestParser2_1CanParseFileTags(t *testing.T) {
 	}
 	for _, typeWant := range fileTypes {
 		flagFound := false
-		for _, typeCheck := range parser.file.FileType {
+		for _, typeCheck := range parser.file.FileTypes {
 			if typeWant == typeCheck {
 				flagFound = true
 			}
 		}
 		if flagFound == false {
-			t.Errorf("didn't find %s in FileType", typeWant)
+			t.Errorf("didn't find %s in FileTypes", typeWant)
 		}
 	}
-	if len(fileTypes) != len(parser.file.FileType) {
-		t.Errorf("expected %d types in FileType, got %d", len(fileTypes),
-			len(parser.file.FileType))
+	if len(fileTypes) != len(parser.file.FileTypes) {
+		t.Errorf("expected %d types in FileTypes, got %d", len(fileTypes),
+			len(parser.file.FileTypes))
 	}
 
 	// File Checksums
@@ -443,16 +443,22 @@ func TestParser2_1CanParseFileTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.file.FileChecksumSHA1 != codeSha1 {
-		t.Errorf("expected %s for FileChecksumSHA1, got %s", codeSha1, parser.file.FileChecksumSHA1)
-	}
-	if parser.file.FileChecksumSHA256 != codeSha256 {
-		t.Errorf("expected %s for FileChecksumSHA256, got %s", codeSha256, parser.file.FileChecksumSHA256)
-	}
-	if parser.file.FileChecksumMD5 != codeMd5 {
-		t.Errorf("expected %s for FileChecksumMD5, got %s", codeMd5, parser.file.FileChecksumMD5)
+	for _, checksum := range parser.file.Checksums {
+		switch checksum.Algorithm {
+		case spdx.SHA1:
+			if checksum.Value != codeSha1 {
+				t.Errorf("expected %s for FileChecksumSHA1, got %s", codeSha1, checksum.Value)
+			}
+		case spdx.SHA256:
+			if checksum.Value != codeSha256 {
+				t.Errorf("expected %s for FileChecksumSHA1, got %s", codeSha256, checksum.Value)
+			}
+		case spdx.MD5:
+			if checksum.Value != codeMd5 {
+				t.Errorf("expected %s for FileChecksumSHA1, got %s", codeMd5, checksum.Value)
+			}
+		}
 	}
-
 	// Concluded License
 	err = parser.parsePairFromFile2_1("LicenseConcluded", "Apache-2.0 OR GPL-2.0-or-later")
 	if err != nil {
@@ -476,18 +482,18 @@ func TestParser2_1CanParseFileTags(t *testing.T) {
 	}
 	for _, licWant := range lics {
 		flagFound := false
-		for _, licCheck := range parser.file.LicenseInfoInFile {
+		for _, licCheck := range parser.file.LicenseInfoInFiles {
 			if licWant == licCheck {
 				flagFound = true
 			}
 		}
 		if flagFound == false {
-			t.Errorf("didn't find %s in LicenseInfoInFile", licWant)
+			t.Errorf("didn't find %s in LicenseInfoInFiles", licWant)
 		}
 	}
-	if len(lics) != len(parser.file.LicenseInfoInFile) {
-		t.Errorf("expected %d licenses in LicenseInfoInFile, got %d", len(lics),
-			len(parser.file.LicenseInfoInFile))
+	if len(lics) != len(parser.file.LicenseInfoInFiles) {
+		t.Errorf("expected %d licenses in LicenseInfoInFiles, got %d", len(lics),
+			len(parser.file.LicenseInfoInFiles))
 	}
 
 	// Comments on License
@@ -625,18 +631,18 @@ func TestParser2_1CanParseFileTags(t *testing.T) {
 	}
 	for _, contribWant := range contribs {
 		flagFound := false
-		for _, contribCheck := range parser.file.FileContributor {
+		for _, contribCheck := range parser.file.FileContributors {
 			if contribWant == contribCheck {
 				flagFound = true
 			}
 		}
 		if flagFound == false {
-			t.Errorf("didn't find %s in FileContributor", contribWant)
+			t.Errorf("didn't find %s in FileContributors", contribWant)
 		}
 	}
-	if len(contribs) != len(parser.file.FileContributor) {
-		t.Errorf("expected %d contribenses in FileContributor, got %d", len(contribs),
-			len(parser.file.FileContributor))
+	if len(contribs) != len(parser.file.FileContributors) {
+		t.Errorf("expected %d contribenses in FileContributors, got %d", len(contribs),
+			len(parser.file.FileContributors))
 	}
 
 	// File Dependencies
@@ -670,13 +676,13 @@ func TestParser2_1CanParseFileTags(t *testing.T) {
 
 func TestParser2_1FileCreatesRelationshipInDocument(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever")
 	if err != nil {
@@ -692,13 +698,13 @@ func TestParser2_1FileCreatesRelationshipInDocument(t *testing.T) {
 
 func TestParser2_1FileCreatesAnnotationInDocument(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePair2_1("Annotator", "Person: John Doe ()")
 	if err != nil {
@@ -714,13 +720,13 @@ func TestParser2_1FileCreatesAnnotationInDocument(t *testing.T) {
 
 func TestParser2_1FileUnknownTagFails(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePairFromFile2_1("blah", "something")
 	if err == nil {
@@ -730,13 +736,13 @@ func TestParser2_1FileUnknownTagFails(t *testing.T) {
 
 func TestFileAOPPointerChangesAfterTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePairFromFile2_1("ArtifactOfProjectName", "project1")
 	if err != nil {
@@ -787,11 +793,11 @@ func TestFileAOPPointerChangesAfterTags(t *testing.T) {
 
 func TestParser2_1FailsIfInvalidSPDXIDInFileSection(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psFile2_1,
-		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_1("FileName", "f1.txt")
@@ -807,11 +813,11 @@ func TestParser2_1FailsIfInvalidSPDXIDInFileSection(t *testing.T) {
 
 func TestParser2_1FailsIfInvalidChecksumFormatInFileSection(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psFile2_1,
-		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_1("FileName", "f1.txt")
@@ -827,11 +833,11 @@ func TestParser2_1FailsIfInvalidChecksumFormatInFileSection(t *testing.T) {
 
 func TestParser2_1FailsIfUnknownChecksumTypeInFileSection(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psFile2_1,
-		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_1("FileName", "f1.txt")
@@ -847,11 +853,11 @@ func TestParser2_1FailsIfUnknownChecksumTypeInFileSection(t *testing.T) {
 
 func TestParser2_1FailsIfArtifactHomePageBeforeArtifactName(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psFile2_1,
-		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_1("FileName", "f1.txt")
@@ -867,11 +873,11 @@ func TestParser2_1FailsIfArtifactHomePageBeforeArtifactName(t *testing.T) {
 
 func TestParser2_1FailsIfArtifactURIBeforeArtifactName(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psFile2_1,
-		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_1("FileName", "f1.txt")
@@ -888,7 +894,7 @@ func TestParser2_1FailsIfArtifactURIBeforeArtifactName(t *testing.T) {
 func TestParser2_1FilesWithoutSpdxIdThrowError(t *testing.T) {
 	// case 1: The previous file (packaged or unpackaged) does not contain spdxID
 	parser1 := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psFile2_1,
 		file: &spdx.File2_1{FileName: "FileName"},
 	}
diff --git a/tvloader/parser2v1/parse_other_license_test.go b/tvloader/parser2v1/parse_other_license_test.go
index d97eb1c..5ae520b 100644
--- a/tvloader/parser2v1/parse_other_license_test.go
+++ b/tvloader/parser2v1/parse_other_license_test.go
@@ -14,9 +14,9 @@ func TestParser2_1OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T)
 	olname1 := "License 11"
 
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psOtherLicense2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: olid1,
@@ -24,8 +24,8 @@ func TestParser2_1OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T)
 		},
 	}
 	olic1 := parser.otherLic
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 
 	// the Document's OtherLicenses should have this one only
@@ -90,13 +90,13 @@ func TestParser2_1OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T)
 
 func TestParser2_1OLMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psOtherLicense2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 
 	err := parser.parsePair2_1("Reviewer", "Person: John Doe")
@@ -110,17 +110,17 @@ func TestParser2_1OLMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_1OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psOtherLicense2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-whatever",
 			LicenseName:       "the whatever license",
 		},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 
 	err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
@@ -152,17 +152,17 @@ func TestParser2_1OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_1OtherLicenseStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psOtherLicense2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-whatever",
 			LicenseName:       "the whatever license",
 		},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 
 	err := parser.parsePair2_1("Annotator", "Person: John Doe ()")
@@ -209,24 +209,24 @@ func TestParser2_1OtherLicenseStaysAfterParsingAnnotationTags(t *testing.T) {
 	if len(parser.doc.Annotations) != 1 {
 		t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations))
 	}
-	if parser.doc.Annotations[0].Annotator != "John Doe ()" {
+	if parser.doc.Annotations[0].Annotator.Annotator != "John Doe ()" {
 		t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator)
 	}
 }
 
 func TestParser2_1OLFailsAfterParsingOtherSectionTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psOtherLicense2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
 			LicenseName:       "License 11",
 		},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 
 	// can't go back to old sections
@@ -247,13 +247,13 @@ func TestParser2_1OLFailsAfterParsingOtherSectionTags(t *testing.T) {
 // ===== Other License data section tests =====
 func TestParser2_1CanParseOtherLicenseTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psOtherLicense2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 
 	// License Identifier
@@ -323,13 +323,13 @@ func TestParser2_1CanParseOtherLicenseTags(t *testing.T) {
 
 func TestParser2_1OLUnknownTagFails(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psOtherLicense2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 
 	err := parser.parsePairFromOtherLicense2_1("blah", "something")
diff --git a/tvloader/parser2v1/parse_package.go b/tvloader/parser2v1/parse_package.go
index a867107..22fc1ed 100644
--- a/tvloader/parser2v1/parse_package.go
+++ b/tvloader/parser2v1/parse_package.go
@@ -45,16 +45,17 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err
 		}
 		parser.pkg.PackageSPDXIdentifier = eID
 		if parser.doc.Packages == nil {
-			parser.doc.Packages = map[spdx.ElementID]*spdx.Package2_1{}
+			parser.doc.Packages = []*spdx.Package2_1{}
 		}
-		parser.doc.Packages[eID] = parser.pkg
+		parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 	case "PackageVersion":
 		parser.pkg.PackageVersion = value
 	case "PackageFileName":
 		parser.pkg.PackageFileName = value
 	case "PackageSupplier":
+		parser.pkg.PackageSupplier = &spdx.Supplier{}
 		if value == "NOASSERTION" {
-			parser.pkg.PackageSupplierNOASSERTION = true
+			parser.pkg.PackageSupplier.Supplier = value
 			break
 		}
 		subkey, subvalue, err := extractSubs(value)
@@ -62,16 +63,16 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err
 			return err
 		}
 		switch subkey {
-		case "Person":
-			parser.pkg.PackageSupplierPerson = subvalue
-		case "Organization":
-			parser.pkg.PackageSupplierOrganization = subvalue
+		case "Person", "Organization":
+			parser.pkg.PackageSupplier.Supplier = subvalue
+			parser.pkg.PackageSupplier.SupplierType = subkey
 		default:
 			return fmt.Errorf("unrecognized PackageSupplier type %v", subkey)
 		}
 	case "PackageOriginator":
+		parser.pkg.PackageOriginator = &spdx.Originator{}
 		if value == "NOASSERTION" {
-			parser.pkg.PackageOriginatorNOASSERTION = true
+			parser.pkg.PackageOriginator.Originator = value
 			break
 		}
 		subkey, subvalue, err := extractSubs(value)
@@ -79,10 +80,9 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err
 			return err
 		}
 		switch subkey {
-		case "Person":
-			parser.pkg.PackageOriginatorPerson = subvalue
-		case "Organization":
-			parser.pkg.PackageOriginatorOrganization = subvalue
+		case "Person", "Organization":
+			parser.pkg.PackageOriginator.Originator = subvalue
+			parser.pkg.PackageOriginator.OriginatorType = subkey
 		default:
 			return fmt.Errorf("unrecognized PackageOriginator type %v", subkey)
 		}
@@ -96,21 +96,19 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err
 			parser.pkg.FilesAnalyzed = true
 		}
 	case "PackageVerificationCode":
-		code, excludesFileName := extractCodeAndExcludes(value)
-		parser.pkg.PackageVerificationCode = code
-		parser.pkg.PackageVerificationCodeExcludedFile = excludesFileName
+		parser.pkg.PackageVerificationCode = extractCodeAndExcludes(value)
 	case "PackageChecksum":
 		subkey, subvalue, err := extractSubs(value)
 		if err != nil {
 			return err
 		}
-		switch subkey {
-		case "SHA1":
-			parser.pkg.PackageChecksumSHA1 = subvalue
-		case "SHA256":
-			parser.pkg.PackageChecksumSHA256 = subvalue
-		case "MD5":
-			parser.pkg.PackageChecksumMD5 = subvalue
+		if parser.pkg.PackageChecksums == nil {
+			parser.pkg.PackageChecksums = []spdx.Checksum{}
+		}
+		switch spdx.ChecksumAlgorithm(subkey) {
+		case spdx.SHA1, spdx.SHA256, spdx.MD5:
+			algorithm := spdx.ChecksumAlgorithm(subkey)
+			parser.pkg.PackageChecksums = append(parser.pkg.PackageChecksums, spdx.Checksum{Algorithm: algorithm, Value: subvalue})
 		default:
 			return fmt.Errorf("got unknown checksum type %s", subkey)
 		}
@@ -184,13 +182,13 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err
 
 // ===== Helper functions =====
 
-func extractCodeAndExcludes(value string) (string, string) {
+func extractCodeAndExcludes(value string) spdx.PackageVerificationCode {
 	// FIXME this should probably be done using regular expressions instead
 	// split by paren + word "excludes:"
 	sp := strings.SplitN(value, "(excludes:", 2)
 	if len(sp) < 2 {
 		// not found; return the whole string as just the code
-		return value, ""
+		return spdx.PackageVerificationCode{Value: value, ExcludedFiles: []string{}}
 	}
 
 	// if we're here, code is in first part and excludes filename is in
@@ -198,7 +196,7 @@ func extractCodeAndExcludes(value string) (string, string) {
 	code := strings.TrimSpace(sp[0])
 	parsedSp := strings.SplitN(sp[1], ")", 2)
 	fileName := strings.TrimSpace(parsedSp[0])
-	return code, fileName
+	return spdx.PackageVerificationCode{Value: code, ExcludedFiles: []string{fileName}}
 }
 
 func extractPackageExternalReference(value string) (string, string, string, error) {
diff --git a/tvloader/parser2v1/parse_package_test.go b/tvloader/parser2v1/parse_package_test.go
index 3cda3ce..734fc91 100644
--- a/tvloader/parser2v1/parse_package_test.go
+++ b/tvloader/parser2v1/parse_package_test.go
@@ -13,19 +13,12 @@ func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T
 	pkgOldName := "p1"
 
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: pkgOldName, PackageSPDXIdentifier: "p1"},
 	}
 	pkgOld := parser.pkg
-	parser.doc.Packages["p1"] = pkgOld
-	// the Document's Packages should have this one only
-	if parser.doc.Packages["p1"] != pkgOld {
-		t.Errorf("expected package %v, got %v", pkgOld, parser.doc.Packages["p1"])
-	}
-	if len(parser.doc.Packages) != 1 {
-		t.Errorf("expected 1 package, got %d", len(parser.doc.Packages))
-	}
+	parser.doc.Packages = append(parser.doc.Packages, pkgOld)
 
 	// now add a new package
 	pkgName := "p2"
@@ -57,8 +50,8 @@ func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T
 		t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true")
 	}
 	// and the Document's Packages should still be of size 1 and have pkgOld only
-	if parser.doc.Packages["p1"] != pkgOld {
-		t.Errorf("Expected package %v, got %v", pkgOld, parser.doc.Packages["p1"])
+	if parser.doc.Packages[0] != pkgOld {
+		t.Errorf("Expected package %v, got %v", pkgOld, parser.doc.Packages[0])
 	}
 	if len(parser.doc.Packages) != 1 {
 		t.Errorf("expected 1 package, got %d", len(parser.doc.Packages))
@@ -67,9 +60,9 @@ func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T
 
 func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpackaged(t *testing.T) {
 	// pkg is nil, so that Files appearing before the first PackageName tag
-	// are added to UnpackagedFiles instead of Packages
+	// are added to Files instead of Packages
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psFile2_1,
 		pkg: nil,
 	}
@@ -112,11 +105,11 @@ func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpack
 
 func TestParser2_1PackageMovesToFileAfterParsingFileNameTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 	pkgCurrent := parser.pkg
 
 	err := parser.parsePair2_1("FileName", "testFile")
@@ -135,11 +128,11 @@ func TestParser2_1PackageMovesToFileAfterParsingFileNameTag(t *testing.T) {
 
 func TestParser2_1PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic")
 	if err != nil {
@@ -152,11 +145,11 @@ func TestParser2_1PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.
 
 func TestParser2_1PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_1("Reviewer", "Person: John Doe")
 	if err != nil {
@@ -169,11 +162,11 @@ func TestParser2_1PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_1PackageStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
 	if err != nil {
@@ -196,11 +189,11 @@ func TestParser2_1PackageStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_1PackageStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_1("Annotator", "Person: John Doe ()")
 	if err != nil {
@@ -246,7 +239,7 @@ func TestParser2_1PackageStaysAfterParsingAnnotationTags(t *testing.T) {
 // ===== Package data section tests =====
 func TestParser2_1CanParsePackageTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -282,8 +275,8 @@ func TestParser2_1CanParsePackageTags(t *testing.T) {
 	if len(parser.doc.Packages) != 1 {
 		t.Errorf("expected 1 package, got %d", len(parser.doc.Packages))
 	}
-	if parser.doc.Packages["p1"] != parser.pkg {
-		t.Errorf("expected to point to parser.pkg, got %v", parser.doc.Packages["p1"])
+	if parser.doc.Packages[0] != parser.pkg {
+		t.Errorf("expected to point to parser.pkg, got %v", parser.doc.Packages[0])
 	}
 
 	// Package Version
@@ -353,14 +346,22 @@ func TestParser2_1CanParsePackageTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageChecksumSHA1 != codeSha1 {
-		t.Errorf("expected %s for PackageChecksumSHA1, got %s", codeSha1, parser.pkg.PackageChecksumSHA1)
-	}
-	if parser.pkg.PackageChecksumSHA256 != codeSha256 {
-		t.Errorf("expected %s for PackageChecksumSHA256, got %s", codeSha256, parser.pkg.PackageChecksumSHA256)
-	}
-	if parser.pkg.PackageChecksumMD5 != codeMd5 {
-		t.Errorf("expected %s for PackageChecksumMD5, got %s", codeMd5, parser.pkg.PackageChecksumMD5)
+
+	for _, checksum := range parser.pkg.PackageChecksums {
+		switch checksum.Algorithm {
+		case spdx.SHA1:
+			if checksum.Value != codeSha1 {
+				t.Errorf("expected %s for PackageChecksum SHA1, got %s", codeSha1, checksum.Value)
+			}
+		case spdx.SHA256:
+			if checksum.Value != codeSha256 {
+				t.Errorf("expected %s for PackageChecksum SHA256, got %s", codeSha256, checksum.Value)
+			}
+		case spdx.MD5:
+			if checksum.Value != codeMd5 {
+				t.Errorf("expected %s for PackageChecksum MD5, got %s", codeMd5, checksum.Value)
+			}
+		}
 	}
 
 	// Package Home Page
@@ -555,119 +556,119 @@ func TestParser2_1CanParsePackageTags(t *testing.T) {
 
 func TestParser2_1CanParsePackageSupplierPersonTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// Package Supplier: Person
 	err := parser.parsePairFromPackage2_1("PackageSupplier", "Person: John Doe")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageSupplierPerson != "John Doe" {
-		t.Errorf("got %v for PackageSupplierPerson", parser.pkg.PackageSupplierPerson)
+	if parser.pkg.PackageSupplier.Supplier != "John Doe" {
+		t.Errorf("got %v for PackageSupplierPerson", parser.pkg.PackageSupplier.Supplier)
 	}
 }
 
 func TestParser2_1CanParsePackageSupplierOrganizationTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// Package Supplier: Organization
 	err := parser.parsePairFromPackage2_1("PackageSupplier", "Organization: John Doe, Inc.")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageSupplierOrganization != "John Doe, Inc." {
-		t.Errorf("got %v for PackageSupplierOrganization", parser.pkg.PackageSupplierOrganization)
+	if parser.pkg.PackageSupplier.Supplier != "John Doe, Inc." {
+		t.Errorf("got %v for PackageSupplierOrganization", parser.pkg.PackageSupplier.Supplier)
 	}
 }
 
 func TestParser2_1CanParsePackageSupplierNOASSERTIONTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// Package Supplier: NOASSERTION
 	err := parser.parsePairFromPackage2_1("PackageSupplier", "NOASSERTION")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageSupplierNOASSERTION != true {
+	if parser.pkg.PackageSupplier.Supplier != "NOASSERTION" {
 		t.Errorf("got false for PackageSupplierNOASSERTION")
 	}
 }
 
 func TestParser2_1CanParsePackageOriginatorPersonTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// Package Originator: Person
 	err := parser.parsePairFromPackage2_1("PackageOriginator", "Person: John Doe")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageOriginatorPerson != "John Doe" {
-		t.Errorf("got %v for PackageOriginatorPerson", parser.pkg.PackageOriginatorPerson)
+	if parser.pkg.PackageOriginator.Originator != "John Doe" {
+		t.Errorf("got %v for PackageOriginatorPerson", parser.pkg.PackageOriginator.Originator)
 	}
 }
 
 func TestParser2_1CanParsePackageOriginatorOrganizationTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// Package Originator: Organization
 	err := parser.parsePairFromPackage2_1("PackageOriginator", "Organization: John Doe, Inc.")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageOriginatorOrganization != "John Doe, Inc." {
-		t.Errorf("got %v for PackageOriginatorOrganization", parser.pkg.PackageOriginatorOrganization)
+	if parser.pkg.PackageOriginator.Originator != "John Doe, Inc." {
+		t.Errorf("got %v for PackageOriginatorOrganization", parser.pkg.PackageOriginator.Originator)
 	}
 }
 
 func TestParser2_1CanParsePackageOriginatorNOASSERTIONTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// Package Originator: NOASSERTION
 	err := parser.parsePairFromPackage2_1("PackageOriginator", "NOASSERTION")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageOriginatorNOASSERTION != true {
+	if parser.pkg.PackageOriginator.Originator != "NOASSERTION" {
 		t.Errorf("got false for PackageOriginatorNOASSERTION")
 	}
 }
 
 func TestParser2_1CanParsePackageVerificationCodeTagWithExcludes(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// Package Verification Code with excludes parenthetical
 	code := "d6a770ba38583ed4bb4525bd96e50461655d2758"
@@ -677,22 +678,22 @@ func TestParser2_1CanParsePackageVerificationCodeTagWithExcludes(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageVerificationCode != code {
+	if parser.pkg.PackageVerificationCode.Value != code {
 		t.Errorf("got %v for PackageVerificationCode", parser.pkg.PackageVerificationCode)
 	}
-	if parser.pkg.PackageVerificationCodeExcludedFile != fileName {
-		t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCodeExcludedFile)
+	if len(parser.pkg.PackageVerificationCode.ExcludedFiles) != 1 || parser.pkg.PackageVerificationCode.ExcludedFiles[0] != fileName {
+		t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCode.ExcludedFiles)
 	}
 
 }
 
 func TestParser2_1CanParsePackageVerificationCodeTagWithoutExcludes(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// Package Verification Code without excludes parenthetical
 	code := "d6a770ba38583ed4bb4525bd96e50461655d2758"
@@ -700,22 +701,22 @@ func TestParser2_1CanParsePackageVerificationCodeTagWithoutExcludes(t *testing.T
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageVerificationCode != code {
+	if parser.pkg.PackageVerificationCode.Value != code {
 		t.Errorf("got %v for PackageVerificationCode", parser.pkg.PackageVerificationCode)
 	}
-	if parser.pkg.PackageVerificationCodeExcludedFile != "" {
-		t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCodeExcludedFile)
+	if len(parser.pkg.PackageVerificationCode.ExcludedFiles) != 0 {
+		t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCode.ExcludedFiles)
 	}
 
 }
 
 func TestPackageExternalRefPointerChangesAfterTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	ref1 := "SECURITY cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*"
 	err := parser.parsePairFromPackage2_1("ExternalRef", ref1)
@@ -756,11 +757,11 @@ func TestPackageExternalRefPointerChangesAfterTags(t *testing.T) {
 
 func TestParser2_1PackageCreatesRelationshipInDocument(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever")
 	if err != nil {
@@ -776,11 +777,11 @@ func TestParser2_1PackageCreatesRelationshipInDocument(t *testing.T) {
 
 func TestParser2_1PackageCreatesAnnotationInDocument(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_1("Annotator", "Person: John Doe ()")
 	if err != nil {
@@ -796,11 +797,11 @@ func TestParser2_1PackageCreatesAnnotationInDocument(t *testing.T) {
 
 func TestParser2_1PackageUnknownTagFails(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePairFromPackage2_1("blah", "something")
 	if err == nil {
@@ -810,7 +811,7 @@ func TestParser2_1PackageUnknownTagFails(t *testing.T) {
 
 func TestParser2_1FailsIfInvalidSPDXIDInPackageSection(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -829,7 +830,7 @@ func TestParser2_1FailsIfInvalidSPDXIDInPackageSection(t *testing.T) {
 
 func TestParser2_1FailsIfInvalidPackageSupplierFormat(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -848,7 +849,7 @@ func TestParser2_1FailsIfInvalidPackageSupplierFormat(t *testing.T) {
 
 func TestParser2_1FailsIfUnknownPackageSupplierType(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -867,7 +868,7 @@ func TestParser2_1FailsIfUnknownPackageSupplierType(t *testing.T) {
 
 func TestParser2_1FailsIfInvalidPackageOriginatorFormat(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -886,7 +887,7 @@ func TestParser2_1FailsIfInvalidPackageOriginatorFormat(t *testing.T) {
 
 func TestParser2_1FailsIfUnknownPackageOriginatorType(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -905,7 +906,7 @@ func TestParser2_1FailsIfUnknownPackageOriginatorType(t *testing.T) {
 
 func TestParser2_1SetsFilesAnalyzedTagsCorrectly(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -930,7 +931,7 @@ func TestParser2_1SetsFilesAnalyzedTagsCorrectly(t *testing.T) {
 
 func TestParser2_1FailsIfInvalidPackageChecksumFormat(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -949,7 +950,7 @@ func TestParser2_1FailsIfInvalidPackageChecksumFormat(t *testing.T) {
 
 func TestParser2_1FailsIfInvalidPackageChecksumType(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -968,7 +969,7 @@ func TestParser2_1FailsIfInvalidPackageChecksumType(t *testing.T) {
 
 func TestParser2_1FailsIfInvalidExternalRefFormat(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -987,7 +988,7 @@ func TestParser2_1FailsIfInvalidExternalRefFormat(t *testing.T) {
 
 func TestParser2_1FailsIfExternalRefCommentBeforeExternalRef(t *testing.T) {
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{},
 	}
@@ -1011,12 +1012,12 @@ func TestCanCheckAndExtractExcludesFilenameAndCode(t *testing.T) {
 	fileName := "./package.spdx"
 	fullCodeValue := "d6a770ba38583ed4bb4525bd96e50461655d2758 (excludes: ./package.spdx)"
 
-	gotCode, gotFileName := extractCodeAndExcludes(fullCodeValue)
-	if gotCode != code {
+	gotCode := extractCodeAndExcludes(fullCodeValue)
+	if gotCode.Value != code {
 		t.Errorf("got %v for gotCode", gotCode)
 	}
-	if gotFileName != fileName {
-		t.Errorf("got %v for gotFileName", gotFileName)
+	if len(gotCode.ExcludedFiles) != 1 || gotCode.ExcludedFiles[0] != fileName {
+		t.Errorf("got %v for gotFileName", gotCode.ExcludedFiles)
 	}
 }
 
@@ -1073,15 +1074,15 @@ func TestParser2_1PackageWithoutSpdxIdentifierThrowsError(t *testing.T) {
 	// More than one package, the previous package doesn't contain the SPDXID
 	pkgOldName := "p1"
 	parser := tvParser2_1{
-		doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:  psPackage2_1,
 		pkg: &spdx.Package2_1{PackageName: pkgOldName},
 	}
 	pkgOld := parser.pkg
-	parser.doc.Packages["p1"] = pkgOld
+	parser.doc.Packages = append(parser.doc.Packages, pkgOld)
 	// the Document's Packages should have this one only
-	if parser.doc.Packages["p1"] != pkgOld {
-		t.Errorf("expected package %v, got %v", pkgOld, parser.doc.Packages["p1"])
+	if parser.doc.Packages[0] != pkgOld {
+		t.Errorf("expected package %v, got %v", pkgOld, parser.doc.Packages[0])
 	}
 	if len(parser.doc.Packages) != 1 {
 		t.Errorf("expected 1 package, got %d", len(parser.doc.Packages))
diff --git a/tvloader/parser2v1/parse_review_test.go b/tvloader/parser2v1/parse_review_test.go
index efcde5c..2ef7006 100644
--- a/tvloader/parser2v1/parse_review_test.go
+++ b/tvloader/parser2v1/parse_review_test.go
@@ -12,9 +12,9 @@ func TestParser2_1ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) {
 	// create the first review
 	rev1 := "John Doe"
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -25,8 +25,8 @@ func TestParser2_1ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) {
 			ReviewerType: "Person",
 		},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 	r1 := parser.rev
@@ -82,9 +82,9 @@ func TestParser2_1ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_1ReviewStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -95,8 +95,8 @@ func TestParser2_1ReviewStaysAfterParsingRelationshipTags(t *testing.T) {
 			ReviewerType: "Person",
 		},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 
@@ -129,9 +129,9 @@ func TestParser2_1ReviewStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_1ReviewStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -142,8 +142,8 @@ func TestParser2_1ReviewStaysAfterParsingAnnotationTags(t *testing.T) {
 			ReviewerType: "Person",
 		},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 
@@ -191,16 +191,16 @@ func TestParser2_1ReviewStaysAfterParsingAnnotationTags(t *testing.T) {
 	if len(parser.doc.Annotations) != 1 {
 		t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations))
 	}
-	if parser.doc.Annotations[0].Annotator != "John Doe ()" {
+	if parser.doc.Annotations[0].Annotator.Annotator != "John Doe ()" {
 		t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator)
 	}
 }
 
 func TestParser2_1ReviewFailsAfterParsingOtherSectionTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -208,8 +208,8 @@ func TestParser2_1ReviewFailsAfterParsingOtherSectionTags(t *testing.T) {
 		},
 		rev: &spdx.Review2_1{},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 
@@ -235,9 +235,9 @@ func TestParser2_1ReviewFailsAfterParsingOtherSectionTags(t *testing.T) {
 // ===== Review data section tests =====
 func TestParser2_1CanParseReviewTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -245,8 +245,8 @@ func TestParser2_1CanParseReviewTags(t *testing.T) {
 		},
 		rev: &spdx.Review2_1{},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 
@@ -274,9 +274,9 @@ func TestParser2_1CanParseReviewTags(t *testing.T) {
 
 func TestParser2_1CanParseReviewerPersonTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -284,8 +284,8 @@ func TestParser2_1CanParseReviewerPersonTag(t *testing.T) {
 		},
 		rev: &spdx.Review2_1{},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 
@@ -304,9 +304,9 @@ func TestParser2_1CanParseReviewerPersonTag(t *testing.T) {
 
 func TestParser2_1CanParseReviewerOrganizationTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -314,8 +314,8 @@ func TestParser2_1CanParseReviewerOrganizationTag(t *testing.T) {
 		},
 		rev: &spdx.Review2_1{},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 
@@ -334,9 +334,9 @@ func TestParser2_1CanParseReviewerOrganizationTag(t *testing.T) {
 
 func TestParser2_1CanParseReviewerToolTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -344,8 +344,8 @@ func TestParser2_1CanParseReviewerToolTag(t *testing.T) {
 		},
 		rev: &spdx.Review2_1{},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 
@@ -364,8 +364,8 @@ func TestParser2_1CanParseReviewerToolTag(t *testing.T) {
 
 func TestParser2_1FailsIfReviewerInvalidFormat(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
-		st:   psReview2_1,
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
+		st:  psReview2_1,
 		rev: &spdx.Review2_1{},
 	}
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
@@ -378,8 +378,8 @@ func TestParser2_1FailsIfReviewerInvalidFormat(t *testing.T) {
 
 func TestParser2_1FailsIfReviewerUnknownType(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
-		st:   psReview2_1,
+		doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
+		st:  psReview2_1,
 		rev: &spdx.Review2_1{},
 	}
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
@@ -392,9 +392,9 @@ func TestParser2_1FailsIfReviewerUnknownType(t *testing.T) {
 
 func TestParser2_1ReviewUnknownTagFails(t *testing.T) {
 	parser := tvParser2_1{
-		doc:  &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:  &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:   psReview2_1,
-		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:  &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_1{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -402,8 +402,8 @@ func TestParser2_1ReviewUnknownTagFails(t *testing.T) {
 		},
 		rev: &spdx.Review2_1{},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic)
 	parser.doc.Reviews = append(parser.doc.Reviews, parser.rev)
 
@@ -412,5 +412,3 @@ func TestParser2_1ReviewUnknownTagFails(t *testing.T) {
 		t.Errorf("expected error from parsing unknown tag")
 	}
 }
-
-
diff --git a/tvloader/parser2v1/parse_snippet.go b/tvloader/parser2v1/parse_snippet.go
index d590383..33392d5 100644
--- a/tvloader/parser2v1/parse_snippet.go
+++ b/tvloader/parser2v1/parse_snippet.go
@@ -51,7 +51,7 @@ func (parser *tvParser2_1) parsePairFromSnippet2_1(tag string, value string) err
 		if err != nil {
 			return err
 		}
-		parser.snippet.SnippetFromFileSPDXIdentifier = deID
+		parser.snippet.SnippetFromFileSPDXIdentifier = deID.ElementRefID
 	case "SnippetByteRange":
 		byteStart, byteEnd, err := extractSubs(value)
 		if err != nil {
@@ -65,8 +65,12 @@ func (parser *tvParser2_1) parsePairFromSnippet2_1(tag string, value string) err
 		if err != nil {
 			return err
 		}
-		parser.snippet.SnippetByteRangeStart = bIntStart
-		parser.snippet.SnippetByteRangeEnd = bIntEnd
+
+		if parser.snippet.Ranges == nil {
+			parser.snippet.Ranges = []spdx.SnippetRange{}
+		}
+		byteRange := spdx.SnippetRange{StartPointer: spdx.SnippetRangePointer{Offset: bIntStart}, EndPointer: spdx.SnippetRangePointer{Offset: bIntEnd}}
+		parser.snippet.Ranges = append(parser.snippet.Ranges, byteRange)
 	case "SnippetLineRange":
 		lineStart, lineEnd, err := extractSubs(value)
 		if err != nil {
@@ -80,8 +84,12 @@ func (parser *tvParser2_1) parsePairFromSnippet2_1(tag string, value string) err
 		if err != nil {
 			return err
 		}
-		parser.snippet.SnippetLineRangeStart = lInttStart
-		parser.snippet.SnippetLineRangeEnd = lInttEnd
+
+		if parser.snippet.Ranges == nil {
+			parser.snippet.Ranges = []spdx.SnippetRange{}
+		}
+		lineRange := spdx.SnippetRange{StartPointer: spdx.SnippetRangePointer{LineNumber: lInttStart}, EndPointer: spdx.SnippetRangePointer{LineNumber: lInttEnd}}
+		parser.snippet.Ranges = append(parser.snippet.Ranges, lineRange)
 	case "SnippetLicenseConcluded":
 		parser.snippet.SnippetLicenseConcluded = value
 	case "LicenseInfoInSnippet":
diff --git a/tvloader/parser2v1/parse_snippet_test.go b/tvloader/parser2v1/parse_snippet_test.go
index 603abc5..ea747f4 100644
--- a/tvloader/parser2v1/parse_snippet_test.go
+++ b/tvloader/parser2v1/parse_snippet_test.go
@@ -12,15 +12,15 @@ func TestParser2_1SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing
 	// create the first snippet
 	sid1 := spdx.ElementID("s1")
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: sid1},
 	}
 	s1 := parser.snippet
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.file.Snippets[sid1] = parser.snippet
 
 	// the File's Snippets should have this one only
@@ -71,16 +71,16 @@ func TestParser2_1SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing
 
 func TestParser2_1SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"},
 	}
 	p1 := parser.pkg
 	f1 := parser.file
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.file.Snippets["s1"] = parser.snippet
 
 	// now add a new package
@@ -113,21 +113,21 @@ func TestParser2_1SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T
 	if len(parser.doc.Packages) != 1 {
 		t.Errorf("Expected len(Packages) to be 1, got %d", len(parser.doc.Packages))
 	}
-	if parser.doc.Packages["package1"] != p1 {
-		t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages["package1"])
+	if parser.doc.Packages[0] != p1 {
+		t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages[0])
 	}
-	if parser.doc.Packages["package1"].PackageName != "package1" {
-		t.Errorf("expected package name %s in Packages[package1], got %s", "package1", parser.doc.Packages["package1"].PackageName)
+	if parser.doc.Packages[0].PackageName != "package1" {
+		t.Errorf("expected package name %s in Packages[package1], got %s", "package1", parser.doc.Packages[0].PackageName)
 	}
 	// and the first Package's Files should be of size 1 and have f1 only
-	if len(parser.doc.Packages["package1"].Files) != 1 {
-		t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages["package1"].Files))
+	if len(parser.doc.Packages[0].Files) != 1 {
+		t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages[0].Files))
 	}
-	if parser.doc.Packages["package1"].Files["f1"] != f1 {
-		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages["package1"].Files["f1"])
+	if parser.doc.Packages[0].Files[0] != f1 {
+		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages[0].Files[0])
 	}
-	if parser.doc.Packages["package1"].Files["f1"].FileName != "f1.txt" {
-		t.Errorf("expected file name %s in Files[f1], got %s", "f1.txt", parser.doc.Packages["package1"].Files["f1"].FileName)
+	if parser.doc.Packages[0].Files[0].FileName != "f1.txt" {
+		t.Errorf("expected file name %s in Files[f1], got %s", "f1.txt", parser.doc.Packages[0].Files[0].FileName)
 	}
 	// and the new Package should have no files
 	if len(parser.pkg.Files) != 0 {
@@ -146,16 +146,16 @@ func TestParser2_1SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T
 func TestParser2_1SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) {
 	f1Name := "f1.txt"
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"},
 	}
 	p1 := parser.pkg
 	f1 := parser.file
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.file.Snippets["s1"] = parser.snippet
 
 	f2Name := "f2.txt"
@@ -184,11 +184,11 @@ func TestParser2_1SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) {
 	if len(parser.pkg.Files) != 1 {
 		t.Errorf("Expected len(Files) to be 1, got %d", len(parser.pkg.Files))
 	}
-	if parser.pkg.Files["f1"] != f1 {
-		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.pkg.Files["f1"])
+	if parser.pkg.Files[0] != f1 {
+		t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.pkg.Files[0])
 	}
-	if parser.pkg.Files["f1"].FileName != f1Name {
-		t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.pkg.Files["f1"].FileName)
+	if parser.pkg.Files[0].FileName != f1Name {
+		t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.pkg.Files[0].FileName)
 	}
 	// and the current snippet should be nil
 	if parser.snippet != nil {
@@ -198,14 +198,14 @@ func TestParser2_1SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) {
 
 func TestParser2_1SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.file.Snippets["s1"] = parser.snippet
 
 	err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic")
@@ -219,14 +219,14 @@ func TestParser2_1SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.
 
 func TestParser2_1SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.file.Snippets["s1"] = parser.snippet
 
 	err := parser.parsePair2_1("Reviewer", "Person: John Doe")
@@ -240,14 +240,14 @@ func TestParser2_1SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_1SnippetStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.file.Snippets["s1"] = parser.snippet
 
 	err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
@@ -279,14 +279,14 @@ func TestParser2_1SnippetStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_1SnippetStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 	parser.file.Snippets["s1"] = parser.snippet
 
 	err := parser.parsePair2_1("Annotator", "Person: John Doe ()")
@@ -333,7 +333,7 @@ func TestParser2_1SnippetStaysAfterParsingAnnotationTags(t *testing.T) {
 	if len(parser.doc.Annotations) != 1 {
 		t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations))
 	}
-	if parser.doc.Annotations[0].Annotator != "John Doe ()" {
+	if parser.doc.Annotations[0].Annotator.Annotator != "John Doe ()" {
 		t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator)
 	}
 }
@@ -341,14 +341,14 @@ func TestParser2_1SnippetStaysAfterParsingAnnotationTags(t *testing.T) {
 // ===== Snippet data section tests =====
 func TestParser2_1CanParseSnippetTags(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	// Snippet SPDX Identifier
 	err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1")
@@ -365,7 +365,7 @@ func TestParser2_1CanParseSnippetTags(t *testing.T) {
 		t.Errorf("expected nil error, got %v", err)
 	}
 	wantDeID := spdx.DocElementID{DocumentRefID: "", ElementRefID: spdx.ElementID("f1")}
-	if parser.snippet.SnippetFromFileSPDXIdentifier != wantDeID {
+	if parser.snippet.SnippetFromFileSPDXIdentifier != wantDeID.ElementRefID {
 		t.Errorf("got %v for SnippetFromFileSPDXIdentifier", parser.snippet.SnippetFromFileSPDXIdentifier)
 	}
 
@@ -374,11 +374,11 @@ func TestParser2_1CanParseSnippetTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.snippet.SnippetByteRangeStart != 20 {
-		t.Errorf("got %v for SnippetByteRangeStart", parser.snippet.SnippetByteRangeStart)
+	if parser.snippet.Ranges[0].StartPointer.Offset != 20 {
+		t.Errorf("got %v for SnippetByteRangeStart", parser.snippet.Ranges[0].StartPointer.Offset)
 	}
-	if parser.snippet.SnippetByteRangeEnd != 320 {
-		t.Errorf("got %v for SnippetByteRangeEnd", parser.snippet.SnippetByteRangeEnd)
+	if parser.snippet.Ranges[0].EndPointer.Offset != 320 {
+		t.Errorf("got %v for SnippetByteRangeEnd", parser.snippet.Ranges[0].EndPointer.Offset)
 	}
 
 	// Snippet Line Range
@@ -386,11 +386,11 @@ func TestParser2_1CanParseSnippetTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.snippet.SnippetLineRangeStart != 5 {
-		t.Errorf("got %v for SnippetLineRangeStart", parser.snippet.SnippetLineRangeStart)
+	if parser.snippet.Ranges[1].StartPointer.LineNumber != 5 {
+		t.Errorf("got %v for SnippetLineRangeStart", parser.snippet.Ranges[1].StartPointer.LineNumber)
 	}
-	if parser.snippet.SnippetLineRangeEnd != 12 {
-		t.Errorf("got %v for SnippetLineRangeEnd", parser.snippet.SnippetLineRangeEnd)
+	if parser.snippet.Ranges[1].EndPointer.LineNumber != 12 {
+		t.Errorf("got %v for SnippetLineRangeEnd", parser.snippet.Ranges[1].EndPointer.LineNumber)
 	}
 
 	// Snippet Concluded License
@@ -469,14 +469,14 @@ func TestParser2_1CanParseSnippetTags(t *testing.T) {
 
 func TestParser2_1SnippetUnknownTagFails(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePairFromSnippet2_1("blah", "something")
 	if err == nil {
@@ -486,14 +486,14 @@ func TestParser2_1SnippetUnknownTagFails(t *testing.T) {
 
 func TestParser2_1FailsForInvalidSnippetSPDXID(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	// invalid Snippet SPDX Identifier
 	err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "whoops")
@@ -504,14 +504,14 @@ func TestParser2_1FailsForInvalidSnippetSPDXID(t *testing.T) {
 
 func TestParser2_1FailsForInvalidSnippetFromFileSPDXID(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	// start with Snippet SPDX Identifier
 	err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1")
@@ -527,14 +527,14 @@ func TestParser2_1FailsForInvalidSnippetFromFileSPDXID(t *testing.T) {
 
 func TestParser2_1FailsForInvalidSnippetByteValues(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	// start with Snippet SPDX Identifier
 	err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1")
@@ -558,14 +558,14 @@ func TestParser2_1FailsForInvalidSnippetByteValues(t *testing.T) {
 
 func TestParser2_1FailsForInvalidSnippetLineValues(t *testing.T) {
 	parser := tvParser2_1{
-		doc:     &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}},
+		doc:     &spdx.Document2_1{Packages: []*spdx.Package2_1{}},
 		st:      psSnippet2_1,
-		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}},
+		pkg:     &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}},
 		file:    &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}},
 		snippet: &spdx.Snippet2_1{},
 	}
-	parser.doc.Packages["package1"] = parser.pkg
-	parser.pkg.Files["f1"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	// start with Snippet SPDX Identifier
 	err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1")
diff --git a/tvloader/parser2v1/parser.go b/tvloader/parser2v1/parser.go
index f4a5ae1..70f4819 100644
--- a/tvloader/parser2v1/parser.go
+++ b/tvloader/parser2v1/parser.go
@@ -59,12 +59,44 @@ func (parser *tvParser2_1) parsePairFromStart2_1(tag string, value string) error
 
 	// create an SPDX Document data struct if we don't have one already
 	if parser.doc == nil {
-		parser.doc = &spdx.Document2_1{}
+		parser.doc = &spdx.Document2_1{
+			ExternalDocumentReferences: []spdx.ExternalDocumentRef2_1{},
+		}
 	}
 
-	// move to Creation Info parser state
-	parser.st = psCreationInfo2_1
+	switch tag {
+	case "SPDXVersion":
+		parser.doc.SPDXVersion = value
+	case "DataLicense":
+		parser.doc.DataLicense = value
+	case "SPDXID":
+		eID, err := extractElementID(value)
+		if err != nil {
+			return err
+		}
+		parser.doc.SPDXIdentifier = eID
+	case "DocumentName":
+		parser.doc.DocumentName = value
+	case "DocumentNamespace":
+		parser.doc.DocumentNamespace = value
+	case "ExternalDocumentRef":
+		documentRefID, uri, alg, checksum, err := extractExternalDocumentReference(value)
+		if err != nil {
+			return err
+		}
+		edr := spdx.ExternalDocumentRef2_1{
+			DocumentRefID: documentRefID,
+			URI:           uri,
+			Checksum:      spdx.Checksum{Algorithm: spdx.ChecksumAlgorithm(alg), Value: checksum},
+		}
+		parser.doc.ExternalDocumentReferences = append(parser.doc.ExternalDocumentReferences, edr)
+	case "DocumentComment":
+		parser.doc.DocumentComment = value
+	default:
+		// move to Creation Info parser state
+		parser.st = psCreationInfo2_1
+		return parser.parsePairFromCreationInfo2_1(tag, value)
+	}
 
-	// and ask Creation Info subfunc to parse
-	return parser.parsePairFromCreationInfo2_1(tag, value)
+	return nil
 }
diff --git a/tvloader/parser2v1/parser_test.go b/tvloader/parser2v1/parser_test.go
index 9fe051f..e895445 100644
--- a/tvloader/parser2v1/parser_test.go
+++ b/tvloader/parser2v1/parser_test.go
@@ -24,14 +24,14 @@ func TestParser2_1CanParseTagValues(t *testing.T) {
 	if err != nil {
 		t.Errorf("got error when calling ParseTagValues: %v", err)
 	}
-	if doc.CreationInfo.SPDXVersion != "SPDX-2.1" {
-		t.Errorf("expected SPDXVersion to be SPDX-2.1, got %v", doc.CreationInfo.SPDXVersion)
+	if doc.SPDXVersion != "SPDX-2.1" {
+		t.Errorf("expected SPDXVersion to be SPDX-2.1, got %v", doc.SPDXVersion)
 	}
-	if doc.CreationInfo.DataLicense != "CC0-1.0" {
-		t.Errorf("expected DataLicense to be CC0-1.0, got %v", doc.CreationInfo.DataLicense)
+	if doc.DataLicense != "CC0-1.0" {
+		t.Errorf("expected DataLicense to be CC0-1.0, got %v", doc.DataLicense)
 	}
-	if doc.CreationInfo.SPDXIdentifier != "DOCUMENT" {
-		t.Errorf("expected SPDXIdentifier to be DOCUMENT, got %v", doc.CreationInfo.SPDXIdentifier)
+	if doc.SPDXIdentifier != "DOCUMENT" {
+		t.Errorf("expected SPDXIdentifier to be DOCUMENT, got %v", doc.SPDXIdentifier)
 	}
 
 }
@@ -58,18 +58,6 @@ func TestParser2_1HasDocumentAfterCallToParseFirstTag(t *testing.T) {
 	}
 }
 
-// ===== Parser start state change tests =====
-func TestParser2_1StartMovesToCreationInfoStateAfterParsingFirstTag(t *testing.T) {
-	parser := tvParser2_1{}
-	err := parser.parsePair2_1("SPDXVersion", "b")
-	if err != nil {
-		t.Errorf("got error when calling parsePair2_1: %v", err)
-	}
-	if parser.st != psCreationInfo2_1 {
-		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1)
-	}
-}
-
 func TestParser2_1StartFailsToParseIfInInvalidState(t *testing.T) {
 	parser := tvParser2_1{st: psReview2_1}
 	err := parser.parsePairFromStart2_1("SPDXVersion", "SPDX-2.1")