Overhaul structs, refactor JSON parser and saver

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

14 files changed, 461 insertions, 561 deletions

diff --git a/tvloader/parser2v2/parse_annotation.go b/tvloader/parser2v2/parse_annotation.go
index 8cd5b76..4c5188e 100644
--- a/tvloader/parser2v2/parse_annotation.go
+++ b/tvloader/parser2v2/parse_annotation.go
@@ -18,8 +18,8 @@ func (parser *tvParser2_2) parsePairForAnnotation2_2(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/parser2v2/parse_annotation_test.go b/tvloader/parser2v2/parse_annotation_test.go
index 7a12adf..cdd0541 100644
--- a/tvloader/parser2v2/parse_annotation_test.go
+++ b/tvloader/parser2v2/parse_annotation_test.go
@@ -70,11 +70,11 @@ func TestParser2_2CanParseAnnotationTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.ann.Annotator != "John Doe" {
-		t.Errorf("got %v for Annotator, expected John Doe", parser.ann.Annotator)
+	if parser.ann.Annotator.Annotator != "John Doe" {
+		t.Errorf("got %+v for Annotator, expected John Doe", parser.ann.Annotator.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
diff --git a/tvloader/parser2v2/parse_creation_info.go b/tvloader/parser2v2/parse_creation_info.go
index c2bfe40..f8406fc 100644
--- a/tvloader/parser2v2/parse_creation_info.go
+++ b/tvloader/parser2v2/parse_creation_info.go
@@ -17,39 +17,11 @@ func (parser *tvParser2_2) parsePairFromCreationInfo2_2(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_2{
-			ExternalDocumentReferences: map[string]spdx.ExternalDocumentRef2_2{},
-		}
+		parser.doc.CreationInfo = &spdx.CreationInfo2_2{}
 	}
 
 	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_2{
-			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_2) parsePairFromCreationInfo2_2(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_2) parsePairFromCreationInfo2_2(tag string, value string
 		return parser.parsePairFromPackage2_2(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_2
 		parser.pkg = nil
 		return parser.parsePairFromFile2_2(tag, value)
diff --git a/tvloader/parser2v2/parse_creation_info_test.go b/tvloader/parser2v2/parse_creation_info_test.go
index e12fc01..7121346 100644
--- a/tvloader/parser2v2/parse_creation_info_test.go
+++ b/tvloader/parser2v2/parse_creation_info_test.go
@@ -58,7 +58,7 @@ func TestParser2_2CIMovesToFileAfterParsingFileNameTagWithNoPackages(t *testing.
 		t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2)
 	}
 	// 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_2HasCreationInfoAfterCallToParseFirstTag(t *testing.T) {
 		doc: &spdx.Document2_2{},
 		st:  psCreationInfo2_2,
 	}
-	err := parser.parsePairFromCreationInfo2_2("SPDXVersion", "SPDX-2.2")
+	err := parser.parsePairFromCreationInfo2_2("LicenseListVersion", "3.9")
 	if err != nil {
 		t.Errorf("got error when calling parsePairFromCreationInfo2_2: %v", err)
 	}
@@ -194,96 +194,8 @@ func TestParser2_2CanParseCreationInfoTags(t *testing.T) {
 		st:  psCreationInfo2_2,
 	}
 
-	// SPDX Version
-	err := parser.parsePairFromCreationInfo2_2("SPDXVersion", "SPDX-2.2")
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	if parser.doc.CreationInfo.SPDXVersion != "SPDX-2.2" {
-		t.Errorf("got %v for SPDXVersion", parser.doc.CreationInfo.SPDXVersion)
-	}
-
-	// Data License
-	err = parser.parsePairFromCreationInfo2_2("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_2("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_2("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_2("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_2{
-		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_2{
-		DocumentRefID: "xyz-2.1.2",
-		URI:           "http://example.com/xyz-2.1.2",
-		Alg:           "SHA1",
-		Checksum:      "d6a770ba38583ed4bb4525bd96e50461655d2760",
-	}
-	err = parser.parsePairFromCreationInfo2_2("ExternalDocumentRef", refs[0])
-	if err != nil {
-		t.Errorf("expected nil error, got %v", err)
-	}
-	err = parser.parsePairFromCreationInfo2_2("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_2("LicenseListVersion", "2.2")
+	err := parser.parsePairFromCreationInfo2_2("LicenseListVersion", "2.2")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
@@ -304,10 +216,10 @@ func TestParser2_2CanParseCreationInfoTags(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 CreatorPersons", parser.doc.CreationInfo.Creators)
 	}
 
 	// Creators: Organizations
@@ -323,10 +235,10 @@ func TestParser2_2CanParseCreationInfoTags(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_2CanParseCreationInfoTags(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_2CanParseCreationInfoTags(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_2("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_2InvalidCreatorTagsFail(t *testing.T) {
diff --git a/tvloader/parser2v2/parse_file.go b/tvloader/parser2v2/parse_file.go
index 27ec6a4..e564147 100644
--- a/tvloader/parser2v2/parse_file.go
+++ b/tvloader/parser2v2/parse_file.go
@@ -49,37 +49,37 @@ func (parser *tvParser2_2) parsePairFromFile2_2(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_2{}
+			if parser.doc.Files == nil {
+				parser.doc.Files = []*spdx.File2_2{}
 			}
-			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_2{}
+				parser.pkg.Files = []*spdx.File2_2{}
 			}
-			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
 		}
-		if parser.file.FileChecksums == nil {
-			parser.file.FileChecksums = map[spdx.ChecksumAlgorithm]spdx.Checksum{}
+		if parser.file.Checksums == nil {
+			parser.file.Checksums = []spdx.Checksum{}
 		}
-		switch subkey {
+		switch spdx.ChecksumAlgorithm(subkey) {
 		case spdx.SHA1, spdx.SHA256, spdx.MD5:
 			algorithm := spdx.ChecksumAlgorithm(subkey)
-			parser.file.FileChecksums[algorithm] = spdx.Checksum{Algorithm: algorithm, Value: subvalue}
+			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_2) parsePairFromFile2_2(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)
 	case "FileAttributionText":
diff --git a/tvloader/parser2v2/parse_file_test.go b/tvloader/parser2v2/parse_file_test.go
index 689a2df..30f9f5e 100644
--- a/tvloader/parser2v2/parse_file_test.go
+++ b/tvloader/parser2v2/parse_file_test.go
@@ -13,23 +13,23 @@ func TestParser2_2FileStartsNewFileAfterParsingFileNameTag(t *testing.T) {
 	fileOldName := "f1.txt"
 
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2FileStartsNewFileAfterParsingFileNameTag(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_2FileStartsNewFileAfterParsingFileNameTag(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_2FileAddsToPackageOrUnpackagedFiles(t *testing.T) {
 		t.Errorf("got error when calling parsePair2_2: %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_2("PackageName", "package1")
@@ -127,19 +127,19 @@ func TestParser2_2FileAddsToPackageOrUnpackagedFiles(t *testing.T) {
 	if err != nil {
 		t.Errorf("got error when calling parsePair2_2: %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_2FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
 	f1Name := "f1.txt"
 
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: p1Name, PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: p1Name, PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2FileStartsNewPackageAfterParsingPackageNameTag(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_2FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
 
 func TestParser2_2FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("SnippetSPDXID", "SPDXRef-Test1")
@@ -242,13 +242,13 @@ func TestParser2_2FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) {
 
 func TestParser2_2FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 	}
-	parser.doc.Packages["test"] = parser.pkg
-	parser.pkg.Files["f2"] = parser.file
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
+	parser.pkg.Files = append(parser.pkg.Files, parser.file)
 
 	err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic")
 	if err != nil {
@@ -261,13 +261,13 @@ func TestParser2_2FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T)
 
 func TestParser2_2FileMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("Reviewer", "Person: John Doe")
 	if err != nil {
@@ -280,13 +280,13 @@ func TestParser2_2FileMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_2FileStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
 	if err != nil {
@@ -309,13 +309,13 @@ func TestParser2_2FileStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_2FileStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("Annotator", "Person: John Doe ()")
 	if err != nil {
@@ -361,11 +361,11 @@ func TestParser2_2FileStaysAfterParsingAnnotationTags(t *testing.T) {
 // ===== File data section tests =====
 func TestParser2_2CanParseFileTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psFile2_2,
-		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// File Name
 	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
@@ -393,8 +393,8 @@ func TestParser2_2CanParseFileTags(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_2CanParseFileTags(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,7 +443,7 @@ func TestParser2_2CanParseFileTags(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	for _, checksum := range parser.file.FileChecksums {
+	for _, checksum := range parser.file.Checksums {
 		switch checksum.Algorithm {
 		case spdx.SHA1:
 			if checksum.Value != codeSha1 {
@@ -482,18 +482,18 @@ func TestParser2_2CanParseFileTags(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
@@ -631,18 +631,18 @@ func TestParser2_2CanParseFileTags(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
@@ -703,13 +703,13 @@ func TestParser2_2CanParseFileTags(t *testing.T) {
 
 func TestParser2_2FileCreatesRelationshipInDocument(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever")
 	if err != nil {
@@ -725,13 +725,13 @@ func TestParser2_2FileCreatesRelationshipInDocument(t *testing.T) {
 
 func TestParser2_2FileCreatesAnnotationInDocument(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("Annotator", "Person: John Doe ()")
 	if err != nil {
@@ -747,13 +747,13 @@ func TestParser2_2FileCreatesAnnotationInDocument(t *testing.T) {
 
 func TestParser2_2FileUnknownTagFails(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("blah", "something")
 	if err == nil {
@@ -763,13 +763,13 @@ func TestParser2_2FileUnknownTagFails(t *testing.T) {
 
 func TestFileAOPPointerChangesAfterTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("ArtifactOfProjectName", "project1")
 	if err != nil {
@@ -820,11 +820,11 @@ func TestFileAOPPointerChangesAfterTags(t *testing.T) {
 
 func TestParser2_2FailsIfInvalidSPDXIDInFileSection(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psFile2_2,
-		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
@@ -840,11 +840,11 @@ func TestParser2_2FailsIfInvalidSPDXIDInFileSection(t *testing.T) {
 
 func TestParser2_2FailsIfInvalidChecksumFormatInFileSection(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psFile2_2,
-		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
@@ -860,11 +860,11 @@ func TestParser2_2FailsIfInvalidChecksumFormatInFileSection(t *testing.T) {
 
 func TestParser2_1FailsIfUnknownChecksumTypeInFileSection(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psFile2_2,
-		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
@@ -880,11 +880,11 @@ func TestParser2_1FailsIfUnknownChecksumTypeInFileSection(t *testing.T) {
 
 func TestParser2_2FailsIfArtifactHomePageBeforeArtifactName(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psFile2_2,
-		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
@@ -900,11 +900,11 @@ func TestParser2_2FailsIfArtifactHomePageBeforeArtifactName(t *testing.T) {
 
 func TestParser2_2FailsIfArtifactURIBeforeArtifactName(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psFile2_2,
-		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 	}
-	parser.doc.Packages["test"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	// start with File Name
 	err := parser.parsePairFromFile2_2("FileName", "f1.txt")
@@ -921,7 +921,7 @@ func TestParser2_2FailsIfArtifactURIBeforeArtifactName(t *testing.T) {
 func TestParser2_2FilesWithoutSpdxIdThrowError(t *testing.T) {
 	// case 1: The previous file (packaged or unpackaged) does not contain spdx ID
 	parser1 := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psFile2_2,
 		file: &spdx.File2_2{FileName: "FileName"},
 	}
diff --git a/tvloader/parser2v2/parse_other_license_test.go b/tvloader/parser2v2/parse_other_license_test.go
index ebf4170..e0607ee 100644
--- a/tvloader/parser2v2/parse_other_license_test.go
+++ b/tvloader/parser2v2/parse_other_license_test.go
@@ -14,9 +14,9 @@ func TestParser2_2OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T)
 	olname1 := "License 11"
 
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psOtherLicense2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: olid1,
@@ -24,8 +24,8 @@ func TestParser2_2OLStartsNewOtherLicenseAfterParsingLicenseIDTag(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_2OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T)
 
 func TestParser2_2OLMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psOtherLicense2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("Reviewer", "Person: John Doe")
@@ -110,17 +110,17 @@ func TestParser2_2OLMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_2OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psOtherLicense2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			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_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
@@ -152,17 +152,17 @@ func TestParser2_2OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_2OtherLicenseStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psOtherLicense2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			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_2("Annotator", "Person: John Doe ()")
@@ -209,24 +209,24 @@ func TestParser2_2OtherLicenseStaysAfterParsingAnnotationTags(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_2OLFailsAfterParsingOtherSectionTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psOtherLicense2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			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_2OLFailsAfterParsingOtherSectionTags(t *testing.T) {
 // ===== Other License data section tests =====
 func TestParser2_2CanParseOtherLicenseTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psOtherLicense2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2CanParseOtherLicenseTags(t *testing.T) {
 
 func TestParser2_2OLUnknownTagFails(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psOtherLicense2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{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_2("blah", "something")
diff --git a/tvloader/parser2v2/parse_package.go b/tvloader/parser2v2/parse_package.go
index 15f7dc6..4d6caf9 100644
--- a/tvloader/parser2v2/parse_package.go
+++ b/tvloader/parser2v2/parse_package.go
@@ -45,47 +45,51 @@ func (parser *tvParser2_2) parsePairFromPackage2_2(tag string, value string) err
 		}
 		parser.pkg.PackageSPDXIdentifier = eID
 		if parser.doc.Packages == nil {
-			parser.doc.Packages = map[spdx.ElementID]*spdx.Package2_2{}
+			parser.doc.Packages = []*spdx.Package2_2{}
 		}
-		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":
+		supplier := &spdx.Supplier{Supplier: value}
 		if value == "NOASSERTION" {
-			parser.pkg.PackageSupplierNOASSERTION = true
+			parser.pkg.PackageSupplier = supplier
 			break
 		}
+
 		subkey, subvalue, err := extractSubs(value)
 		if err != nil {
 			return err
 		}
 		switch subkey {
-		case "Person":
-			parser.pkg.PackageSupplierPerson = subvalue
-		case "Organization":
-			parser.pkg.PackageSupplierOrganization = subvalue
+		case "Person", "Organization":
+			supplier.Supplier = subvalue
+			supplier.SupplierType = subkey
 		default:
 			return fmt.Errorf("unrecognized PackageSupplier type %v", subkey)
 		}
+		parser.pkg.PackageSupplier = supplier
 	case "PackageOriginator":
+		originator := &spdx.Originator{Originator: value}
 		if value == "NOASSERTION" {
-			parser.pkg.PackageOriginatorNOASSERTION = true
+			parser.pkg.PackageOriginator = originator
 			break
 		}
+
 		subkey, subvalue, err := extractSubs(value)
 		if err != nil {
 			return err
 		}
 		switch subkey {
-		case "Person":
-			parser.pkg.PackageOriginatorPerson = subvalue
-		case "Organization":
-			parser.pkg.PackageOriginatorOrganization = subvalue
+		case "Person", "Organization":
+			originator.Originator = subvalue
+			originator.OriginatorType = subkey
 		default:
 			return fmt.Errorf("unrecognized PackageOriginator type %v", subkey)
 		}
+		parser.pkg.PackageOriginator = originator
 	case "PackageDownloadLocation":
 		parser.pkg.PackageDownloadLocation = value
 	case "FilesAnalyzed":
@@ -96,21 +100,19 @@ func (parser *tvParser2_2) parsePairFromPackage2_2(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
 		}
 		if parser.pkg.PackageChecksums == nil {
-			parser.pkg.PackageChecksums = make(map[spdx.ChecksumAlgorithm]spdx.Checksum, 9)
+			parser.pkg.PackageChecksums = []spdx.Checksum{}
 		}
-		switch subkey {
+		switch spdx.ChecksumAlgorithm(subkey) {
 		case spdx.SHA1, spdx.SHA256, spdx.MD5:
 			algorithm := spdx.ChecksumAlgorithm(subkey)
-			parser.pkg.PackageChecksums[algorithm] = spdx.Checksum{Algorithm: algorithm, Value: subvalue}
+			parser.pkg.PackageChecksums = append(parser.pkg.PackageChecksums, spdx.Checksum{Algorithm: algorithm, Value: subvalue})
 		default:
 			return fmt.Errorf("got unknown checksum type %s", subkey)
 		}
@@ -186,13 +188,13 @@ func (parser *tvParser2_2) parsePairFromPackage2_2(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
@@ -200,7 +202,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/parser2v2/parse_package_test.go b/tvloader/parser2v2/parse_package_test.go
index 5809931..6b58d0f 100644
--- a/tvloader/parser2v2/parse_package_test.go
+++ b/tvloader/parser2v2/parse_package_test.go
@@ -13,15 +13,15 @@ func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T
 	pkgOldName := "p1"
 
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{PackageName: pkgOldName, PackageSPDXIdentifier: "p1"},
 	}
 	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))
@@ -57,8 +57,8 @@ func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTag(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 +67,9 @@ func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T
 
 func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpackaged(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_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psFile2_2,
 		pkg: nil,
 	}
@@ -112,11 +112,11 @@ func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpack
 
 func TestParser2_2PackageMovesToFileAfterParsingFileNameTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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_2("FileName", "testFile")
@@ -135,11 +135,11 @@ func TestParser2_2PackageMovesToFileAfterParsingFileNameTag(t *testing.T) {
 
 func TestParser2_2PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic")
 	if err != nil {
@@ -152,11 +152,11 @@ func TestParser2_2PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.
 
 func TestParser2_2PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_2("Reviewer", "Person: John Doe")
 	if err != nil {
@@ -169,11 +169,11 @@ func TestParser2_2PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_2PackageStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
 	if err != nil {
@@ -196,11 +196,11 @@ func TestParser2_2PackageStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_2PackageStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
 	if err != nil {
@@ -246,7 +246,7 @@ func TestParser2_2PackageStaysAfterParsingAnnotationTags(t *testing.T) {
 // ===== Package data section tests =====
 func TestParser2_2CanParsePackageTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -282,8 +282,8 @@ func TestParser2_2CanParsePackageTags(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
@@ -589,119 +589,119 @@ func TestParser2_2CanParsePackageTags(t *testing.T) {
 
 func TestParser2_2CanParsePackageSupplierPersonTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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_2("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_2CanParsePackageSupplierOrganizationTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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_2("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_2CanParsePackageSupplierNOASSERTIONTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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_2("PackageSupplier", "NOASSERTION")
 	if err != nil {
 		t.Errorf("expected nil error, got %v", err)
 	}
-	if parser.pkg.PackageSupplierNOASSERTION != true {
-		t.Errorf("got false for PackageSupplierNOASSERTION")
+	if parser.pkg.PackageSupplier.Supplier != "NOASSERTION" {
+		t.Errorf("got value for Supplier, expected NOASSERTION")
 	}
 }
 
 func TestParser2_2CanParsePackageOriginatorPersonTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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_2("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 PackageOriginator", parser.pkg.PackageOriginator.Originator)
 	}
 }
 
 func TestParser2_2CanParsePackageOriginatorOrganizationTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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_2("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 PackageOriginator", parser.pkg.PackageOriginator.Originator)
 	}
 }
 
 func TestParser2_2CanParsePackageOriginatorNOASSERTIONTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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_2("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_2CanParsePackageVerificationCodeTagWithExcludes(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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"
@@ -711,22 +711,22 @@ func TestParser2_2CanParsePackageVerificationCodeTagWithExcludes(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_2CanParsePackageVerificationCodeTagWithoutExcludes(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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"
@@ -734,22 +734,22 @@ func TestParser2_2CanParsePackageVerificationCodeTagWithoutExcludes(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 TestParser2_2PackageExternalRefPointerChangesAfterTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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_2("ExternalRef", ref1)
@@ -790,11 +790,11 @@ func TestParser2_2PackageExternalRefPointerChangesAfterTags(t *testing.T) {
 
 func TestParser2_2PackageCreatesRelationshipInDocument(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever")
 	if err != nil {
@@ -810,11 +810,11 @@ func TestParser2_2PackageCreatesRelationshipInDocument(t *testing.T) {
 
 func TestParser2_2PackageCreatesAnnotationInDocument(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePair2_2("Annotator", "Person: John Doe ()")
 	if err != nil {
@@ -830,11 +830,11 @@ func TestParser2_2PackageCreatesAnnotationInDocument(t *testing.T) {
 
 func TestParser2_2PackageUnknownTagFails(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"},
 	}
-	parser.doc.Packages["p1"] = parser.pkg
+	parser.doc.Packages = append(parser.doc.Packages, parser.pkg)
 
 	err := parser.parsePairFromPackage2_2("blah", "something")
 	if err == nil {
@@ -844,7 +844,7 @@ func TestParser2_2PackageUnknownTagFails(t *testing.T) {
 
 func TestParser2_2FailsIfInvalidSPDXIDInPackageSection(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -863,7 +863,7 @@ func TestParser2_2FailsIfInvalidSPDXIDInPackageSection(t *testing.T) {
 
 func TestParser2_2FailsIfInvalidPackageSupplierFormat(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -882,7 +882,7 @@ func TestParser2_2FailsIfInvalidPackageSupplierFormat(t *testing.T) {
 
 func TestParser2_2FailsIfUnknownPackageSupplierType(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -901,7 +901,7 @@ func TestParser2_2FailsIfUnknownPackageSupplierType(t *testing.T) {
 
 func TestParser2_2FailsIfInvalidPackageOriginatorFormat(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -920,7 +920,7 @@ func TestParser2_2FailsIfInvalidPackageOriginatorFormat(t *testing.T) {
 
 func TestParser2_2FailsIfUnknownPackageOriginatorType(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -939,7 +939,7 @@ func TestParser2_2FailsIfUnknownPackageOriginatorType(t *testing.T) {
 
 func TestParser2_2SetsFilesAnalyzedTagsCorrectly(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -964,7 +964,7 @@ func TestParser2_2SetsFilesAnalyzedTagsCorrectly(t *testing.T) {
 
 func TestParser2_2FailsIfInvalidPackageChecksumFormat(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -983,7 +983,7 @@ func TestParser2_2FailsIfInvalidPackageChecksumFormat(t *testing.T) {
 
 func TestParser2_2FailsIfInvalidPackageChecksumType(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -1002,7 +1002,7 @@ func TestParser2_2FailsIfInvalidPackageChecksumType(t *testing.T) {
 
 func TestParser2_2FailsIfInvalidExternalRefFormat(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -1021,7 +1021,7 @@ func TestParser2_2FailsIfInvalidExternalRefFormat(t *testing.T) {
 
 func TestParser2_2FailsIfExternalRefCommentBeforeExternalRef(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{},
 	}
@@ -1045,12 +1045,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)
 	}
 }
 
@@ -1107,15 +1107,15 @@ func TestParser2_2PackageWithoutSpdxIdentifierThrowsError(t *testing.T) {
 	// More than one package, the previous package doesn't contain an SPDX ID
 	pkgOldName := "p1"
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psPackage2_2,
 		pkg: &spdx.Package2_2{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/parser2v2/parse_review_test.go b/tvloader/parser2v2/parse_review_test.go
index f482184..de73ede 100644
--- a/tvloader/parser2v2/parse_review_test.go
+++ b/tvloader/parser2v2/parse_review_test.go
@@ -12,9 +12,9 @@ func TestParser2_2ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) {
 	// create the first review
 	rev1 := "John Doe"
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -25,8 +25,8 @@ func TestParser2_2ReviewStartsNewReviewAfterParsingReviewerTag(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_2ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_2ReviewStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -95,8 +95,8 @@ func TestParser2_2ReviewStaysAfterParsingRelationshipTags(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_2ReviewStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_2ReviewStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -142,8 +142,8 @@ func TestParser2_2ReviewStaysAfterParsingAnnotationTags(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_2ReviewStaysAfterParsingAnnotationTags(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_2ReviewFailsAfterParsingOtherSectionTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -208,8 +208,8 @@ func TestParser2_2ReviewFailsAfterParsingOtherSectionTags(t *testing.T) {
 		},
 		rev: &spdx.Review2_2{},
 	}
-	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_2ReviewFailsAfterParsingOtherSectionTags(t *testing.T) {
 // ===== Review data section tests =====
 func TestParser2_2CanParseReviewTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -245,8 +245,8 @@ func TestParser2_2CanParseReviewTags(t *testing.T) {
 		},
 		rev: &spdx.Review2_2{},
 	}
-	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_2CanParseReviewTags(t *testing.T) {
 
 func TestParser2_2CanParseReviewerPersonTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -284,8 +284,8 @@ func TestParser2_2CanParseReviewerPersonTag(t *testing.T) {
 		},
 		rev: &spdx.Review2_2{},
 	}
-	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_2CanParseReviewerPersonTag(t *testing.T) {
 
 func TestParser2_2CanParseReviewerOrganizationTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -314,8 +314,8 @@ func TestParser2_2CanParseReviewerOrganizationTag(t *testing.T) {
 		},
 		rev: &spdx.Review2_2{},
 	}
-	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_2CanParseReviewerOrganizationTag(t *testing.T) {
 
 func TestParser2_2CanParseReviewerToolTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -344,8 +344,8 @@ func TestParser2_2CanParseReviewerToolTag(t *testing.T) {
 		},
 		rev: &spdx.Review2_2{},
 	}
-	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,7 +364,7 @@ func TestParser2_2CanParseReviewerToolTag(t *testing.T) {
 
 func TestParser2_2FailsIfReviewerInvalidFormat(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psReview2_2,
 		rev: &spdx.Review2_2{},
 	}
@@ -378,7 +378,7 @@ func TestParser2_2FailsIfReviewerInvalidFormat(t *testing.T) {
 
 func TestParser2_2FailsIfReviewerUnknownType(t *testing.T) {
 	parser := tvParser2_2{
-		doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc: &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:  psReview2_2,
 		rev: &spdx.Review2_2{},
 	}
@@ -392,9 +392,9 @@ func TestParser2_2FailsIfReviewerUnknownType(t *testing.T) {
 
 func TestParser2_2ReviewUnknownTagFails(t *testing.T) {
 	parser := tvParser2_2{
-		doc:  &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:  &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:   psReview2_2,
-		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:  &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"},
 		otherLic: &spdx.OtherLicense2_2{
 			LicenseIdentifier: "LicenseRef-Lic11",
@@ -402,8 +402,8 @@ func TestParser2_2ReviewUnknownTagFails(t *testing.T) {
 		},
 		rev: &spdx.Review2_2{},
 	}
-	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)
 
diff --git a/tvloader/parser2v2/parse_snippet.go b/tvloader/parser2v2/parse_snippet.go
index 7f58604..d3bac47 100644
--- a/tvloader/parser2v2/parse_snippet.go
+++ b/tvloader/parser2v2/parse_snippet.go
@@ -51,7 +51,7 @@ func (parser *tvParser2_2) parsePairFromSnippet2_2(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_2) parsePairFromSnippet2_2(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_2) parsePairFromSnippet2_2(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/parser2v2/parse_snippet_test.go b/tvloader/parser2v2/parse_snippet_test.go
index d019a0c..545595a 100644
--- a/tvloader/parser2v2/parse_snippet_test.go
+++ b/tvloader/parser2v2/parse_snippet_test.go
@@ -12,15 +12,15 @@ func TestParser2_2SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing
 	// create the first snippet
 	sid1 := spdx.ElementID("s1")
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{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_2SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing
 
 func TestParser2_2SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{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_2SnippetStartsNewPackageAfterParsingPackageNameTag(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_2SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T
 func TestParser2_2SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) {
 	f1Name := "f1.txt"
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{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_2SnippetMovesToFileAfterParsingFileNameTag(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_2SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) {
 
 func TestParser2_2SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{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_2("LicenseID", "LicenseRef-TestLic")
@@ -219,14 +219,14 @@ func TestParser2_2SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.
 
 func TestParser2_2SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{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_2("Reviewer", "Person: John Doe")
@@ -240,14 +240,14 @@ func TestParser2_2SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) {
 
 func TestParser2_2SnippetStaysAfterParsingRelationshipTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{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_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else")
@@ -279,14 +279,14 @@ func TestParser2_2SnippetStaysAfterParsingRelationshipTags(t *testing.T) {
 
 func TestParser2_2SnippetStaysAfterParsingAnnotationTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{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_2("Annotator", "Person: John Doe ()")
@@ -333,7 +333,7 @@ func TestParser2_2SnippetStaysAfterParsingAnnotationTags(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_2SnippetStaysAfterParsingAnnotationTags(t *testing.T) {
 // ===== Snippet data section tests =====
 func TestParser2_2CanParseSnippetTags(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{},
 	}
-	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_2("SnippetSPDXID", "SPDXRef-s1")
@@ -365,7 +365,7 @@ func TestParser2_2CanParseSnippetTags(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_2CanParseSnippetTags(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_2CanParseSnippetTags(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
@@ -497,14 +497,14 @@ func TestParser2_2CanParseSnippetTags(t *testing.T) {
 
 func TestParser2_2SnippetUnknownTagFails(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{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_2("blah", "something")
 	if err == nil {
@@ -514,14 +514,14 @@ func TestParser2_2SnippetUnknownTagFails(t *testing.T) {
 
 func TestParser2_2FailsForInvalidSnippetSPDXID(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{},
 	}
-	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_2("SnippetSPDXID", "whoops")
@@ -532,14 +532,14 @@ func TestParser2_2FailsForInvalidSnippetSPDXID(t *testing.T) {
 
 func TestParser2_2FailsForInvalidSnippetFromFileSPDXID(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{},
 	}
-	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_2("SnippetSPDXID", "SPDXRef-s1")
@@ -555,14 +555,14 @@ func TestParser2_2FailsForInvalidSnippetFromFileSPDXID(t *testing.T) {
 
 func TestParser2_2FailsForInvalidSnippetByteValues(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{},
 	}
-	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_2("SnippetSPDXID", "SPDXRef-s1")
@@ -586,14 +586,14 @@ func TestParser2_2FailsForInvalidSnippetByteValues(t *testing.T) {
 
 func TestParser2_2FailsForInvalidSnippetLineValues(t *testing.T) {
 	parser := tvParser2_2{
-		doc:     &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}},
+		doc:     &spdx.Document2_2{Packages: []*spdx.Package2_2{}},
 		st:      psSnippet2_2,
-		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}},
+		pkg:     &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_2{}},
 		file:    &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}},
 		snippet: &spdx.Snippet2_2{},
 	}
-	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_2("SnippetSPDXID", "SPDXRef-s1")
diff --git a/tvloader/parser2v2/parser.go b/tvloader/parser2v2/parser.go
index 9886874..1d9f8e9 100644
--- a/tvloader/parser2v2/parser.go
+++ b/tvloader/parser2v2/parser.go
@@ -58,12 +58,42 @@ func (parser *tvParser2_2) parsePairFromStart2_2(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_2{}
+		parser.doc = &spdx.Document2_2{ExternalDocumentReferences: []spdx.ExternalDocumentRef2_2{}}
 	}
 
-	// move to Creation Info parser state
-	parser.st = psCreationInfo2_2
+	switch tag {
+	case "DocumentComment":
+		parser.doc.DocumentComment = value
+	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_2{
+			DocumentRefID: documentRefID,
+			URI:           uri,
+			Checksum:      spdx.Checksum{Algorithm: spdx.ChecksumAlgorithm(alg), Value: checksum},
+		}
+		parser.doc.ExternalDocumentReferences = append(parser.doc.ExternalDocumentReferences, edr)
+	default:
+		// move to Creation Info parser state
+		parser.st = psCreationInfo2_2
+		return parser.parsePairFromCreationInfo2_2(tag, value)
+	}
 
-	// and ask Creation Info subfunc to parse
-	return parser.parsePairFromCreationInfo2_2(tag, value)
+	return nil
 }
diff --git a/tvloader/parser2v2/parser_test.go b/tvloader/parser2v2/parser_test.go
index 4cd5228..148264d 100644
--- a/tvloader/parser2v2/parser_test.go
+++ b/tvloader/parser2v2/parser_test.go
@@ -24,14 +24,14 @@ func TestParser2_2CanParseTagValues(t *testing.T) {
 	if err != nil {
 		t.Errorf("got error when calling ParseTagValues: %v", err)
 	}
-	if doc.CreationInfo.SPDXVersion != "SPDX-2.2" {
-		t.Errorf("expected SPDXVersion to be SPDX-2.2, got %v", doc.CreationInfo.SPDXVersion)
+	if doc.SPDXVersion != "SPDX-2.2" {
+		t.Errorf("expected SPDXVersion to be SPDX-2.2, 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_2HasDocumentAfterCallToParseFirstTag(t *testing.T) {
 	}
 }
 
-// ===== Parser start state change tests =====
-func TestParser2_2StartMovesToCreationInfoStateAfterParsingFirstTag(t *testing.T) {
-	parser := tvParser2_2{}
-	err := parser.parsePair2_2("SPDXVersion", "b")
-	if err != nil {
-		t.Errorf("got error when calling parsePair2_2: %v", err)
-	}
-	if parser.st != psCreationInfo2_2 {
-		t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2)
-	}
-}
-
 func TestParser2_2StartFailsToParseIfInInvalidState(t *testing.T) {
 	parser := tvParser2_2{st: psReview2_2}
 	err := parser.parsePairFromStart2_2("SPDXVersion", "SPDX-2.2")