replace all v2_1, v2_2 with new convention

Signed-off-by: Brandon Lum <lumjjb@gmail.com>

25 files changed, 282 insertions, 250 deletions

diff --git a/rdfloader/parser2v2/license_utils.go b/rdfloader/parser2v2/license_utils.go
index 0a823ef..41e8870 100644
--- a/rdfloader/parser2v2/license_utils.go
+++ b/rdfloader/parser2v2/license_utils.go
@@ -4,9 +4,10 @@ package parser2v2
 
 import (
 	"fmt"
-	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
 	"strings"
+
+	gordfParser "github.com/spdx/gordf/rdfloader/parser"
+	"github.com/spdx/tools-golang/spdx/common"
 )
 
 /* util methods for licenses and checksums below:*/
@@ -26,7 +27,7 @@ func getLicenseStringFromURI(uri string) string {
 // returns the checksum algorithm and it's value
 // In the newer versions, these two strings will be bound to a single checksum struct
 // whose pointer will be returned.
-func (parser *rdfParser2_2) getChecksumFromNode(checksumNode *gordfParser.Node) (algorithm spdx.ChecksumAlgorithm, value string, err error) {
+func (parser *rdfParser2_2) getChecksumFromNode(checksumNode *gordfParser.Node) (algorithm common.ChecksumAlgorithm, value string, err error) {
 	var checksumValue, checksumAlgorithm string
 	for _, checksumTriple := range parser.nodeToTriples(checksumNode) {
 		switch checksumTriple.Predicate.ID {
@@ -46,7 +47,7 @@ func (parser *rdfParser2_2) getChecksumFromNode(checksumNode *gordfParser.Node)
 			return
 		}
 	}
-	return spdx.ChecksumAlgorithm(checksumAlgorithm), checksumValue, nil
+	return common.ChecksumAlgorithm(checksumAlgorithm), checksumValue, nil
 }
 
 func getAlgorithmFromURI(algorithmURI string) (checksumAlgorithm string, err error) {
diff --git a/rdfloader/parser2v2/parse_annotation.go b/rdfloader/parser2v2/parse_annotation.go
index 18e4533..a5801b0 100644
--- a/rdfloader/parser2v2/parse_annotation.go
+++ b/rdfloader/parser2v2/parse_annotation.go
@@ -5,15 +5,16 @@ package parser2v2
 import (
 	"errors"
 	"fmt"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 // creates a new instance of annotation and sets the annotation attributes
 // associated with the given node.
 // The newly created annotation is appended to the doc.
 func (parser *rdfParser2_2) parseAnnotationFromNode(node *gordfParser.Node) (err error) {
-	ann := &spdx.Annotation2_2{}
+	ann := &v2_2.Annotation{}
 	for _, subTriple := range parser.nodeToTriples(node) {
 		switch subTriple.Predicate.ID {
 		case SPDX_ANNOTATOR:
@@ -41,19 +42,19 @@ func (parser *rdfParser2_2) parseAnnotationFromNode(node *gordfParser.Node) (err
 	return setAnnotationToParser(parser, ann)
 }
 
-func setAnnotationToParser(parser *rdfParser2_2, annotation *spdx.Annotation2_2) error {
+func setAnnotationToParser(parser *rdfParser2_2, annotation *v2_2.Annotation) error {
 	if parser.doc == nil {
 		return errors.New("uninitialized spdx document")
 	}
 	if parser.doc.Annotations == nil {
-		parser.doc.Annotations = []*spdx.Annotation2_2{}
+		parser.doc.Annotations = []*v2_2.Annotation{}
 	}
 	parser.doc.Annotations = append(parser.doc.Annotations, annotation)
 	return nil
 }
 
 // annotator is of type [Person|Organization|Tool]:String
-func setAnnotatorFromString(annotatorString string, ann *spdx.Annotation2_2) error {
+func setAnnotatorFromString(annotatorString string, ann *v2_2.Annotation) error {
 	subkey, subvalue, err := ExtractSubs(annotatorString, ":")
 	if err != nil {
 		return err
@@ -67,7 +68,7 @@ func setAnnotatorFromString(annotatorString string, ann *spdx.Annotation2_2) err
 }
 
 // it can be NS_SPDX+annotationType_[review|other]
-func setAnnotationType(annType string, ann *spdx.Annotation2_2) error {
+func setAnnotationType(annType string, ann *v2_2.Annotation) error {
 	switch annType {
 	case SPDX_ANNOTATION_TYPE_OTHER:
 		ann.AnnotationType = "OTHER"
diff --git a/rdfloader/parser2v2/parse_annotation_test.go b/rdfloader/parser2v2/parse_annotation_test.go
index 0226d85..114fc5d 100644
--- a/rdfloader/parser2v2/parse_annotation_test.go
+++ b/rdfloader/parser2v2/parse_annotation_test.go
@@ -3,13 +3,14 @@
 package parser2v2
 
 import (
-	"github.com/spdx/tools-golang/spdx"
 	"testing"
+
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 func Test_setAnnotatorFromString(t *testing.T) {
 	// TestCase 1: Empty String must raise an error
-	ann := &spdx.Annotation2_2{}
+	ann := &v2_2.Annotation{}
 	input := ""
 	err := setAnnotatorFromString(input, ann)
 	if err == nil {
@@ -17,7 +18,7 @@ func Test_setAnnotatorFromString(t *testing.T) {
 	}
 
 	// TestCase 2: Invalid annotator type
-	ann = &spdx.Annotation2_2{}
+	ann = &v2_2.Annotation{}
 	input = "Company: some_company"
 	err = setAnnotatorFromString(input, ann)
 	if err == nil {
@@ -25,7 +26,7 @@ func Test_setAnnotatorFromString(t *testing.T) {
 	}
 
 	// TestCase 3: Valid annotator
-	ann = &spdx.Annotation2_2{}
+	ann = &v2_2.Annotation{}
 	input = "Person: Rishabh"
 	err = setAnnotatorFromString(input, ann)
 	if err != nil {
@@ -40,7 +41,7 @@ func Test_setAnnotatorFromString(t *testing.T) {
 }
 
 func Test_setAnnotationType(t *testing.T) {
-	ann := &spdx.Annotation2_2{}
+	ann := &v2_2.Annotation{}
 	// TestCase 1: invalid input (empty annotationType)
 	err := setAnnotationType("", ann)
 	if err == nil {
@@ -76,7 +77,7 @@ func Test_setAnnotationToParser(t *testing.T) {
 	// TestCase 1: doc is nil (must raise an error)
 	parser, _ := parserFromBodyContent(``)
 	parser.doc = nil
-	err := setAnnotationToParser(parser, &spdx.Annotation2_2{})
+	err := setAnnotationToParser(parser, &v2_2.Annotation{})
 	if err == nil {
 		t.Errorf("empty doc should've raised an error")
 	}
@@ -85,7 +86,7 @@ func Test_setAnnotationToParser(t *testing.T) {
 	//			   list and append the input to it.
 	parser, _ = parserFromBodyContent(``)
 	parser.doc.Annotations = nil
-	err = setAnnotationToParser(parser, &spdx.Annotation2_2{})
+	err = setAnnotationToParser(parser, &v2_2.Annotation{})
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
diff --git a/rdfloader/parser2v2/parse_creation_info.go b/rdfloader/parser2v2/parse_creation_info.go
index dc4da77..b58149d 100644
--- a/rdfloader/parser2v2/parse_creation_info.go
+++ b/rdfloader/parser2v2/parse_creation_info.go
@@ -4,12 +4,14 @@ package parser2v2
 
 import (
 	"fmt"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 // Cardinality: Mandatory, one.
-func (parser *rdfParser2_2) parseCreationInfoFromNode(ci *spdx.CreationInfo2_2, node *gordfParser.Node) error {
+func (parser *rdfParser2_2) parseCreationInfoFromNode(ci *v2_2.CreationInfo, node *gordfParser.Node) error {
 	for _, triple := range parser.nodeToTriples(node) {
 		switch triple.Predicate.ID {
 		case SPDX_LICENSE_LIST_VERSION: // 2.7
@@ -35,13 +37,13 @@ func (parser *rdfParser2_2) parseCreationInfoFromNode(ci *spdx.CreationInfo2_2,
 	return nil
 }
 
-func setCreator(creatorStr string, ci *spdx.CreationInfo2_2) error {
+func setCreator(creatorStr string, ci *v2_2.CreationInfo) error {
 	entityType, entity, err := ExtractSubs(creatorStr, ":")
 	if err != nil {
 		return fmt.Errorf("error setting creator of a creation info: %s", err)
 	}
 
-	creator := spdx.Creator{Creator: entity}
+	creator := common.Creator{Creator: entity}
 
 	switch entityType {
 	case "Person", "Organization", "Tool":
diff --git a/rdfloader/parser2v2/parse_creation_info_test.go b/rdfloader/parser2v2/parse_creation_info_test.go
index 415d18e..81fceae 100644
--- a/rdfloader/parser2v2/parse_creation_info_test.go
+++ b/rdfloader/parser2v2/parse_creation_info_test.go
@@ -3,28 +3,29 @@
 package parser2v2
 
 import (
-	"github.com/spdx/tools-golang/spdx"
 	"testing"
+
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 func Test_setCreator(t *testing.T) {
 	// TestCase 1: invalid creator (empty)
 	input := ""
-	err := setCreator(input, &spdx.CreationInfo2_2{})
+	err := setCreator(input, &v2_2.CreationInfo{})
 	if err == nil {
 		t.Errorf("shoud've raised an error due to invalid input")
 	}
 
 	// TestCase 2: invalid entity type
 	input = "Company: some company"
-	err = setCreator(input, &spdx.CreationInfo2_2{})
+	err = setCreator(input, &v2_2.CreationInfo{})
 	if err == nil {
 		t.Errorf("shoud've raised an error due to unknown entity type")
 	}
 
 	// TestCase 3: valid input
 	input = "Person: Jane Doe"
-	ci := &spdx.CreationInfo2_2{}
+	ci := &v2_2.CreationInfo{}
 	err = setCreator(input, ci)
 	if err != nil {
 		t.Errorf("error parsing a valid input: %v", err)
@@ -48,7 +49,7 @@ func Test_rdfParser2_2_parseCreationInfoFromNode(t *testing.T) {
 		</spdx:CreationInfo>
 	`)
 	ciNode := parser.gordfParserObj.Triples[0].Subject
-	err := parser.parseCreationInfoFromNode(&spdx.CreationInfo2_2{}, ciNode)
+	err := parser.parseCreationInfoFromNode(&v2_2.CreationInfo{}, ciNode)
 	if err == nil {
 		t.Errorf("invalid creator must raise an error")
 	}
@@ -65,7 +66,7 @@ func Test_rdfParser2_2_parseCreationInfoFromNode(t *testing.T) {
 		</spdx:CreationInfo>
 	`)
 	ciNode = parser.gordfParserObj.Triples[0].Subject
-	err = parser.parseCreationInfoFromNode(&spdx.CreationInfo2_2{}, ciNode)
+	err = parser.parseCreationInfoFromNode(&v2_2.CreationInfo{}, ciNode)
 	if err == nil {
 		t.Errorf("unknown predicate must raise an error")
 	}
@@ -80,7 +81,7 @@ func Test_rdfParser2_2_parseCreationInfoFromNode(t *testing.T) {
 		</spdx:CreationInfo>
 	`)
 	ciNode = parser.gordfParserObj.Triples[0].Subject
-	ci := &spdx.CreationInfo2_2{}
+	ci := &v2_2.CreationInfo{}
 	err = parser.parseCreationInfoFromNode(ci, ciNode)
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
diff --git a/rdfloader/parser2v2/parse_file.go b/rdfloader/parser2v2/parse_file.go
index a149712..e807667 100644
--- a/rdfloader/parser2v2/parse_file.go
+++ b/rdfloader/parser2v2/parse_file.go
@@ -7,12 +7,13 @@ import (
 	"strings"
 
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 // returns a file instance and the error if any encountered.
-func (parser *rdfParser2_2) getFileFromNode(fileNode *gordfParser.Node) (file *spdx.File2_2, err error) {
-	file = &spdx.File2_2{}
+func (parser *rdfParser2_2) getFileFromNode(fileNode *gordfParser.Node) (file *v2_2.File, err error) {
+	file = &v2_2.File{}
 
 	currState := parser.cache[fileNode.ID]
 	if currState == nil {
@@ -23,7 +24,7 @@ func (parser *rdfParser2_2) getFileFromNode(fileNode *gordfParser.Node) (file *s
 		}
 	} else if currState.Color == GREY {
 		// we have already started parsing this file node and we needn't parse it again.
-		return currState.object.(*spdx.File2_2), nil
+		return currState.object.(*v2_2.File), nil
 	}
 
 	// setting color to grey to indicate that we've started parsing this node.
@@ -86,7 +87,7 @@ func (parser *rdfParser2_2) getFileFromNode(fileNode *gordfParser.Node) (file *s
 		// deprecated artifactOf (see sections 4.9, 4.10, 4.11)
 		case SPDX_ARTIFACT_OF:
 			// cardinality: min 0
-			var artifactOf *spdx.ArtifactOfProject2_2
+			var artifactOf *v2_2.ArtifactOfProject
 			artifactOf, err = parser.getArtifactFromNode(subTriple.Object)
 			file.ArtifactOfProjects = append(file.ArtifactOfProjects, artifactOf)
 		case RDFS_COMMENT: // 4.12
@@ -125,17 +126,17 @@ func (parser *rdfParser2_2) getFileFromNode(fileNode *gordfParser.Node) (file *s
 	return file, nil
 }
 
-func (parser *rdfParser2_2) setFileChecksumFromNode(file *spdx.File2_2, checksumNode *gordfParser.Node) error {
+func (parser *rdfParser2_2) setFileChecksumFromNode(file *v2_2.File, checksumNode *gordfParser.Node) error {
 	checksumAlgorithm, checksumValue, err := parser.getChecksumFromNode(checksumNode)
 	if err != nil {
 		return fmt.Errorf("error parsing checksumNode of a file: %v", err)
 	}
 	if file.Checksums == nil {
-		file.Checksums = []spdx.Checksum{}
+		file.Checksums = []common.Checksum{}
 	}
 	switch checksumAlgorithm {
-	case spdx.MD5, spdx.SHA1, spdx.SHA256:
-		file.Checksums = append(file.Checksums, spdx.Checksum{Algorithm: checksumAlgorithm, Value: checksumValue})
+	case common.MD5, common.SHA1, common.SHA256:
+		file.Checksums = append(file.Checksums, common.Checksum{Algorithm: checksumAlgorithm, Value: checksumValue})
 	case "":
 		return fmt.Errorf("empty checksum algorithm and value")
 	default:
@@ -144,8 +145,8 @@ func (parser *rdfParser2_2) setFileChecksumFromNode(file *spdx.File2_2, checksum
 	return nil
 }
 
-func (parser *rdfParser2_2) getArtifactFromNode(node *gordfParser.Node) (*spdx.ArtifactOfProject2_2, error) {
-	artifactOf := &spdx.ArtifactOfProject2_2{}
+func (parser *rdfParser2_2) getArtifactFromNode(node *gordfParser.Node) (*v2_2.ArtifactOfProject, error) {
+	artifactOf := &v2_2.ArtifactOfProject{}
 	// setting artifactOfProjectURI attribute (which is optional)
 	if node.NodeType == gordfParser.IRI {
 		artifactOf.URI = node.ID
@@ -186,7 +187,7 @@ func (parser *rdfParser2_2) setUnpackagedFiles() {
 	}
 }
 
-func setFileIdentifier(idURI string, file *spdx.File2_2) (err error) {
+func setFileIdentifier(idURI string, file *v2_2.File) (err error) {
 	idURI = strings.TrimSpace(idURI)
 	uriFragment := getLastPartOfURI(idURI)
 	file.FileSPDXIdentifier, err = ExtractElementID(uriFragment)
diff --git a/rdfloader/parser2v2/parse_file_test.go b/rdfloader/parser2v2/parse_file_test.go
index 8c5ea0d..2509351 100644
--- a/rdfloader/parser2v2/parse_file_test.go
+++ b/rdfloader/parser2v2/parse_file_test.go
@@ -10,7 +10,8 @@ import (
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	rdfloader2 "github.com/spdx/gordf/rdfloader/xmlreader"
 	gordfWriter "github.com/spdx/gordf/rdfwriter"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 // content is the tags within the rdf:RDF tag
@@ -143,9 +144,9 @@ func Test_rdfParser2_2_setUnpackagedFiles(t *testing.T) {
 	// unpackaged files are the files which are not associated with any package
 	// file associated with a package sets parser.assocWithPackage[fileID] to true.
 	rdfParser, _ := parserFromBodyContent(``)
-	file1 := &spdx.File2_2{FileSPDXIdentifier: spdx.ElementID("file1")}
-	file2 := &spdx.File2_2{FileSPDXIdentifier: spdx.ElementID("file2")}
-	file3 := &spdx.File2_2{FileSPDXIdentifier: spdx.ElementID("file3")}
+	file1 := &v2_2.File{FileSPDXIdentifier: common.ElementID("file1")}
+	file2 := &v2_2.File{FileSPDXIdentifier: common.ElementID("file2")}
+	file3 := &v2_2.File{FileSPDXIdentifier: common.ElementID("file3")}
 
 	// setting files to the document as if it were to be set when it was parsed using triples.
 	rdfParser.files[file1.FileSPDXIdentifier] = file1
@@ -174,7 +175,7 @@ func Test_rdfParser2_2_setUnpackagedFiles(t *testing.T) {
 }
 
 func Test_setFileIdentifier(t *testing.T) {
-	file := &spdx.File2_2{}
+	file := &v2_2.File{}
 
 	// TestCase 1: valid example
 	err := setFileIdentifier("http://spdx.org/documents/spdx-toolsv2.1.7-SNAPSHOT#SPDXRef-129", file)
@@ -201,7 +202,7 @@ func Test_rdfParser2_2_setFileChecksumFromNode(t *testing.T) {
 		</spdx:Checksum>
     `)
 	checksumNode := gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject
-	file := &spdx.File2_2{}
+	file := &v2_2.File{}
 	err := parser.setFileChecksumFromNode(file, checksumNode)
 	if err != nil {
 		t.Errorf("error parsing a valid checksum node")
@@ -209,15 +210,15 @@ func Test_rdfParser2_2_setFileChecksumFromNode(t *testing.T) {
 	checksumValue := "d2356e0fe1c0b85285d83c6b2ad51b5f"
 	for _, checksum := range file.Checksums {
 		switch checksum.Algorithm {
-		case spdx.SHA1:
+		case common.SHA1:
 			if checksum.Value != "" {
 				t.Errorf("incorrectly set sha1, should've been empty")
 			}
-		case spdx.SHA256:
+		case common.SHA256:
 			if checksum.Value != "" {
 				t.Errorf("incorrectly set sha256, should've been empty")
 			}
-		case spdx.MD5:
+		case common.MD5:
 			if checksum.Value != checksumValue {
 				t.Errorf("wrong checksum value for md5. Expected: %s, found: %s", checksumValue, checksum.Value)
 			}
@@ -232,22 +233,22 @@ func Test_rdfParser2_2_setFileChecksumFromNode(t *testing.T) {
 		</spdx:Checksum>
     `)
 	checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject
-	file = &spdx.File2_2{}
+	file = &v2_2.File{}
 	err = parser.setFileChecksumFromNode(file, checksumNode)
 	if err != nil {
 		t.Errorf("error parsing a valid checksum node")
 	}
 	for _, checksum := range file.Checksums {
 		switch checksum.Algorithm {
-		case spdx.SHA1:
+		case common.SHA1:
 			if checksum.Value != checksumValue {
 				t.Errorf("wrong checksum value for sha1. Expected: %s, found: %s", checksumValue, checksum.Value)
 			}
-		case spdx.SHA256:
+		case common.SHA256:
 			if checksum.Value != "" {
 				t.Errorf("incorrectly set sha256, should've been empty")
 			}
-		case spdx.MD5:
+		case common.MD5:
 			if checksum.Value != checksumValue {
 				t.Errorf("incorrectly set md5, should've been empty")
 			}
@@ -262,22 +263,22 @@ func Test_rdfParser2_2_setFileChecksumFromNode(t *testing.T) {
 		</spdx:Checksum>
     `)
 	checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject
-	file = &spdx.File2_2{}
+	file = &v2_2.File{}
 	err = parser.setFileChecksumFromNode(file, checksumNode)
 	if err != nil {
 		t.Errorf("error parsing a valid checksum node")
 	}
 	for _, checksum := range file.Checksums {
 		switch checksum.Algorithm {
-		case spdx.SHA1:
+		case common.SHA1:
 			if checksum.Value != checksumValue {
 				t.Errorf("incorrectly set sha1, should've been empty")
 			}
-		case spdx.SHA256:
+		case common.SHA256:
 			if checksum.Value != checksumValue {
 				t.Errorf("wrong checksum value for sha256. Expected: %s, found: %s", checksumValue, checksum.Value)
 			}
-		case spdx.MD5:
+		case common.MD5:
 			if checksum.Value != checksumValue {
 				t.Errorf("incorrectly set md5, should've been empty")
 			}
@@ -291,7 +292,7 @@ func Test_rdfParser2_2_setFileChecksumFromNode(t *testing.T) {
 		</spdx:Checksum>
     `)
 	checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject
-	file = &spdx.File2_2{}
+	file = &v2_2.File{}
 	err = parser.setFileChecksumFromNode(file, checksumNode)
 	if err == nil {
 		t.Errorf("should've raised an error parsing an invalid checksum node")
@@ -305,7 +306,7 @@ func Test_rdfParser2_2_setFileChecksumFromNode(t *testing.T) {
 		</spdx:Checksum>
     `)
 	checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject
-	file = &spdx.File2_2{}
+	file = &v2_2.File{}
 	err = parser.setFileChecksumFromNode(file, checksumNode)
 	if err == nil {
 		t.Errorf("should've raised an error parsing an invalid checksum node")
@@ -319,7 +320,7 @@ func Test_rdfParser2_2_setFileChecksumFromNode(t *testing.T) {
 		</spdx:Checksum>
     `)
 	checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject
-	file = &spdx.File2_2{}
+	file = &v2_2.File{}
 	err = parser.setFileChecksumFromNode(file, checksumNode)
 	if err == nil {
 		t.Errorf("should've raised an error parsing an invalid checksum algorithm for a file")
@@ -484,7 +485,7 @@ func Test_rdfParser2_2_getFileFromNode(t *testing.T) {
 	}
 	parser, _ = parserFromBodyContent(strings.Join(fileDefinitions, ""))
 
-	var file *spdx.File2_2
+	var file *v2_2.File
 	packageTypeTriples := gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_PACKAGE)
 	for _, typeTriple := range packageTypeTriples {
 		pkg, err := parser.getPackageFromNode(typeTriple.Subject)
@@ -602,7 +603,7 @@ func Test_rdfParser2_2_getFileFromNode(t *testing.T) {
 
 	for _, checksum := range file.Checksums {
 		switch checksum.Algorithm {
-		case spdx.SHA1:
+		case common.SHA1:
 			if checksum.Value != expectedChecksum {
 				t.Errorf("expected %s, found %s", expectedChecksum, checksum.Value)
 			}
diff --git a/rdfloader/parser2v2/parse_license.go b/rdfloader/parser2v2/parse_license.go
index 4b4ad46..71a1e4a 100644
--- a/rdfloader/parser2v2/parse_license.go
+++ b/rdfloader/parser2v2/parse_license.go
@@ -5,9 +5,10 @@ package parser2v2
 import (
 	"errors"
 	"fmt"
+	"strings"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	"github.com/spdx/gordf/rdfwriter"
-	"strings"
 )
 
 // AnyLicense is a baseClass for all the licenses
@@ -37,7 +38,7 @@ func (parser *rdfParser2_2) getAnyLicenseFromNode(node *gordfParser.Node) (AnyLi
 	parser.cache[node.ID].Color = GREY
 
 	// setting state color to black when we're done parsing this node.
-	defer func(){parser.cache[node.ID].Color = BLACK}()
+	defer func() { parser.cache[node.ID].Color = BLACK }()
 
 	associatedTriples := rdfwriter.FilterTriples(parser.gordfParserObj.Triples, &node.ID, nil, nil)
 	if len(associatedTriples) == 0 {
diff --git a/rdfloader/parser2v2/parse_license_test.go b/rdfloader/parser2v2/parse_license_test.go
index b519195..e2c684d 100644
--- a/rdfloader/parser2v2/parse_license_test.go
+++ b/rdfloader/parser2v2/parse_license_test.go
@@ -3,10 +3,11 @@
 package parser2v2
 
 import (
-	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	"reflect"
 	"sort"
 	"testing"
+
+	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 )
 
 func Test_rdfParser2_2_getAnyLicenseFromNode(t *testing.T) {
diff --git a/rdfloader/parser2v2/parse_other_license_info.go b/rdfloader/parser2v2/parse_other_license_info.go
index e7d1367..97dcf0c 100644
--- a/rdfloader/parser2v2/parse_other_license_info.go
+++ b/rdfloader/parser2v2/parse_other_license_info.go
@@ -4,9 +4,10 @@ package parser2v2
 
 import (
 	"fmt"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	"github.com/spdx/gordf/rdfwriter"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 func (parser *rdfParser2_2) getExtractedLicensingInfoFromNode(node *gordfParser.Node) (lic ExtractedLicensingInfo, err error) {
@@ -27,7 +28,7 @@ func (parser *rdfParser2_2) getExtractedLicensingInfoFromNode(node *gordfParser.
 	return lic, nil
 }
 
-func (parser *rdfParser2_2) extractedLicenseToOtherLicense(extLicense ExtractedLicensingInfo) (othLic spdx.OtherLicense2_2) {
+func (parser *rdfParser2_2) extractedLicenseToOtherLicense(extLicense ExtractedLicensingInfo) (othLic v2_2.OtherLicense) {
 	othLic.LicenseIdentifier = extLicense.licenseID
 	othLic.ExtractedText = extLicense.extractedText
 	othLic.LicenseComment = extLicense.comment
diff --git a/rdfloader/parser2v2/parse_other_license_info_test.go b/rdfloader/parser2v2/parse_other_license_info_test.go
index e606d50..cd7ad32 100644
--- a/rdfloader/parser2v2/parse_other_license_info_test.go
+++ b/rdfloader/parser2v2/parse_other_license_info_test.go
@@ -3,9 +3,10 @@
 package parser2v2
 
 import (
-	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	"reflect"
 	"testing"
+
+	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 )
 
 func Test_rdfParser2_2_getExtractedLicensingInfoFromNode(t *testing.T) {
diff --git a/rdfloader/parser2v2/parse_package.go b/rdfloader/parser2v2/parse_package.go
index 41ccab3..eff2e0f 100644
--- a/rdfloader/parser2v2/parse_package.go
+++ b/rdfloader/parser2v2/parse_package.go
@@ -7,11 +7,12 @@ import (
 	"strings"
 
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
-func (parser *rdfParser2_2) getPackageFromNode(packageNode *gordfParser.Node) (pkg *spdx.Package2_2, err error) {
-	pkg = &spdx.Package2_2{} // new package which will be returned
+func (parser *rdfParser2_2) getPackageFromNode(packageNode *gordfParser.Node) (pkg *v2_2.Package, err error) {
+	pkg = &v2_2.Package{} // new package which will be returned
 
 	currState := parser.cache[packageNode.ID]
 	if currState == nil {
@@ -23,7 +24,7 @@ func (parser *rdfParser2_2) getPackageFromNode(packageNode *gordfParser.Node) (p
 		}
 	} else if currState.Color == GREY {
 		// we have already started parsing this package node and we needn't parse it again.
-		return currState.object.(*spdx.Package2_2), nil
+		return currState.object.(*v2_2.Package), nil
 	}
 
 	// setting color of the state to grey to indicate that we've started to
@@ -166,8 +167,8 @@ func (parser *rdfParser2_2) getPackageFromNode(packageNode *gordfParser.Node) (p
 }
 
 // parses externalReference found in the package by the associated triple.
-func (parser *rdfParser2_2) getPackageExternalRef(node *gordfParser.Node) (externalDocRef *spdx.PackageExternalReference2_2, err error) {
-	externalDocRef = &spdx.PackageExternalReference2_2{}
+func (parser *rdfParser2_2) getPackageExternalRef(node *gordfParser.Node) (externalDocRef *v2_2.PackageExternalReference, err error) {
+	externalDocRef = &v2_2.PackageExternalReference{}
 	for _, triple := range parser.nodeToTriples(node) {
 		switch triple.Predicate.ID {
 		case SPDX_REFERENCE_CATEGORY:
@@ -205,7 +206,7 @@ func (parser *rdfParser2_2) getPackageExternalRef(node *gordfParser.Node) (exter
 	return
 }
 
-func (parser *rdfParser2_2) setPackageVerificationCode(pkg *spdx.Package2_2, node *gordfParser.Node) error {
+func (parser *rdfParser2_2) setPackageVerificationCode(pkg *v2_2.Package, node *gordfParser.Node) error {
 	for _, subTriple := range parser.nodeToTriples(node) {
 		switch subTriple.Predicate.ID {
 		case SPDX_PACKAGE_VERIFICATION_CODE_VALUE:
@@ -226,9 +227,9 @@ func (parser *rdfParser2_2) setPackageVerificationCode(pkg *spdx.Package2_2, nod
 
 // appends the file to the package and also sets the assocWithPackage for the
 // file to indicate the file is associated with a package
-func (parser *rdfParser2_2) setFileToPackage(pkg *spdx.Package2_2, file *spdx.File2_2) {
+func (parser *rdfParser2_2) setFileToPackage(pkg *v2_2.Package, file *v2_2.File) {
 	if pkg.Files == nil {
-		pkg.Files = []*spdx.File2_2{}
+		pkg.Files = []*v2_2.File{}
 	}
 	pkg.Files = append(pkg.Files, file)
 	parser.assocWithPackage[file.FileSPDXIdentifier] = true
@@ -237,9 +238,9 @@ func (parser *rdfParser2_2) setFileToPackage(pkg *spdx.Package2_2, file *spdx.Fi
 // given a supplierObject, sets the PackageSupplier attribute of the pkg.
 // Args:
 //    value: [NOASSERTION | [Person | Organization]: string]
-func setPackageSupplier(pkg *spdx.Package2_2, value string) error {
+func setPackageSupplier(pkg *v2_2.Package, value string) error {
 	value = strings.TrimSpace(value)
-	supplier := &spdx.Supplier{}
+	supplier := &common.Supplier{}
 	if strings.ToUpper(value) == "NOASSERTION" {
 		supplier.Supplier = "NOASSERTION"
 		pkg.PackageSupplier = supplier
@@ -266,9 +267,9 @@ func setPackageSupplier(pkg *spdx.Package2_2, value string) error {
 // given a OriginatorObject, sets the PackageOriginator attribute of the pkg.
 // Args:
 //    value: [NOASSERTION | [Person | Organization]: string]
-func setPackageOriginator(pkg *spdx.Package2_2, value string) error {
+func setPackageOriginator(pkg *v2_2.Package, value string) error {
 	value = strings.TrimSpace(value)
-	originator := &spdx.Originator{}
+	originator := &common.Originator{}
 	if strings.ToUpper(value) == "NOASSERTION" {
 		originator.Originator = "NOASSERTION"
 		pkg.PackageOriginator = originator
@@ -293,7 +294,7 @@ func setPackageOriginator(pkg *spdx.Package2_2, value string) error {
 }
 
 // validates the uri and sets the location if it is valid
-func setDocumentLocationFromURI(pkg *spdx.Package2_2, locationURI string) error {
+func setDocumentLocationFromURI(pkg *v2_2.Package, locationURI string) error {
 	switch locationURI {
 	case SPDX_NOASSERTION_CAPS, SPDX_NOASSERTION_SMALL:
 		pkg.PackageDownloadLocation = "NOASSERTION"
@@ -310,23 +311,23 @@ func setDocumentLocationFromURI(pkg *spdx.Package2_2, locationURI string) error
 
 // sets the FilesAnalyzed attribute to the given package
 // boolValue is a string of type "true" or "false"
-func setFilesAnalyzed(pkg *spdx.Package2_2, boolValue string) (err error) {
+func setFilesAnalyzed(pkg *v2_2.Package, boolValue string) (err error) {
 	pkg.IsFilesAnalyzedTagPresent = true
 	pkg.FilesAnalyzed, err = boolFromString(boolValue)
 	return err
 }
 
-func (parser *rdfParser2_2) setPackageChecksum(pkg *spdx.Package2_2, node *gordfParser.Node) error {
+func (parser *rdfParser2_2) setPackageChecksum(pkg *v2_2.Package, node *gordfParser.Node) error {
 	checksumAlgorithm, checksumValue, err := parser.getChecksumFromNode(node)
 	if err != nil {
 		return fmt.Errorf("error getting checksum algorithm and value from %v", node)
 	}
 	if pkg.PackageChecksums == nil {
-		pkg.PackageChecksums = make([]spdx.Checksum, 0, 1)
+		pkg.PackageChecksums = make([]common.Checksum, 0, 1)
 	}
 	switch checksumAlgorithm {
-	case spdx.MD5, spdx.SHA1, spdx.SHA256:
-		pkg.PackageChecksums = append(pkg.PackageChecksums, spdx.Checksum{Algorithm: checksumAlgorithm, Value: checksumValue})
+	case common.MD5, common.SHA1, common.SHA256:
+		pkg.PackageChecksums = append(pkg.PackageChecksums, common.Checksum{Algorithm: checksumAlgorithm, Value: checksumValue})
 	default:
 		return fmt.Errorf("unknown checksumAlgorithm %s while parsing a package", checksumAlgorithm)
 	}
diff --git a/rdfloader/parser2v2/parse_package_test.go b/rdfloader/parser2v2/parse_package_test.go
index c1bc7ed..0e01dbe 100644
--- a/rdfloader/parser2v2/parse_package_test.go
+++ b/rdfloader/parser2v2/parse_package_test.go
@@ -7,14 +7,15 @@ import (
 	"testing"
 
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 func Test_setPackageSupplier(t *testing.T) {
 	var err error
 
 	// TestCase 1: no assertion must set PackageSupplierNOASSERTION field to true
-	pkg := &spdx.Package2_2{}
+	pkg := &v2_2.Package{}
 	err = setPackageSupplier(pkg, "NOASSERTION")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -25,7 +26,7 @@ func Test_setPackageSupplier(t *testing.T) {
 
 	// TestCase 2: lower-case noassertion must also set the
 	// PackageSupplierNOASSERTION to true.
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = setPackageSupplier(pkg, "noassertion")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -35,7 +36,7 @@ func Test_setPackageSupplier(t *testing.T) {
 	}
 
 	// TestCase 3: invalid input without colon separator. must raise an error
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	input := "string without colon separator"
 	err = setPackageSupplier(pkg, input)
 	if err == nil {
@@ -43,7 +44,7 @@ func Test_setPackageSupplier(t *testing.T) {
 	}
 
 	// TestCase 4: Valid Person
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	personName := "Rishabh Bhatnagar"
 	input = "Person: " + personName
 	err = setPackageSupplier(pkg, input)
@@ -55,7 +56,7 @@ func Test_setPackageSupplier(t *testing.T) {
 	}
 
 	// TestCase 5: Valid Organization
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	orgName := "SPDX"
 	input = "Organization: " + orgName
 	err = setPackageSupplier(pkg, input)
@@ -67,7 +68,7 @@ func Test_setPackageSupplier(t *testing.T) {
 	}
 
 	// TestCase 6: Invalid EntityType
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	input = "InvalidEntity: entity"
 	err = setPackageSupplier(pkg, input)
 	if err == nil {
@@ -79,7 +80,7 @@ func Test_setPackageOriginator(t *testing.T) {
 	var err error
 
 	// TestCase 1: no assertion must set PackageSupplierNOASSERTION field to true
-	pkg := &spdx.Package2_2{}
+	pkg := &v2_2.Package{}
 	err = setPackageOriginator(pkg, "NOASSERTION")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -90,7 +91,7 @@ func Test_setPackageOriginator(t *testing.T) {
 
 	// TestCase 2: lower-case noassertion must also set the
 	// PackageOriginatorNOASSERTION to true.
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = setPackageOriginator(pkg, "noassertion")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -100,7 +101,7 @@ func Test_setPackageOriginator(t *testing.T) {
 	}
 
 	// TestCase 3: invalid input without colon separator. must raise an error
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	input := "string without colon separator"
 	err = setPackageOriginator(pkg, input)
 	if err == nil {
@@ -108,7 +109,7 @@ func Test_setPackageOriginator(t *testing.T) {
 	}
 
 	// TestCase 4: Valid Person
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	personName := "Rishabh Bhatnagar"
 	input = "Person: " + personName
 	err = setPackageOriginator(pkg, input)
@@ -120,7 +121,7 @@ func Test_setPackageOriginator(t *testing.T) {
 	}
 
 	// TestCase 5: Valid Organization
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	orgName := "SPDX"
 	input = "Organization: " + orgName
 	err = setPackageOriginator(pkg, input)
@@ -132,7 +133,7 @@ func Test_setPackageOriginator(t *testing.T) {
 	}
 
 	// TestCase 6: Invalid EntityType
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	input = "InvalidEntity: entity"
 	err = setPackageOriginator(pkg, input)
 	if err == nil {
@@ -143,19 +144,19 @@ func Test_setPackageOriginator(t *testing.T) {
 func Test_rdfParser2_2_setPackageVerificationCode(t *testing.T) {
 	var parser *rdfParser2_2
 	var node *gordfParser.Node
-	var pkg *spdx.Package2_2
+	var pkg *v2_2.Package
 	var err error
 
 	// TestCase 1: invalid predicate must raise an error
 	parser, _ = parserFromBodyContent(`
-		<spdx:PackageVerificationCode>
+		<spdx.PackageVerificationCode>
 			<spdx:invalidPredicate />
 			<spdx:packageVerificationCodeValue>cbceb8b5689b75a584efe35587b5d41bd48820ce</spdx:packageVerificationCodeValue>
 			<spdx:packageVerificationCodeExcludedFile>./package.spdx</spdx:packageVerificationCodeExcludedFile>
-		</spdx:PackageVerificationCode>
+		</spdx.PackageVerificationCode>
 	`)
 	node = parser.gordfParserObj.Triples[0].Subject
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = parser.setPackageVerificationCode(pkg, node)
 	if err == nil {
 		t.Errorf("expected an error due to invalid predicate, got <nil>")
@@ -163,13 +164,13 @@ func Test_rdfParser2_2_setPackageVerificationCode(t *testing.T) {
 
 	// TestCase 2: valid input
 	parser, _ = parserFromBodyContent(`
-		<spdx:PackageVerificationCode>
+		<spdx.PackageVerificationCode>
 			<spdx:packageVerificationCodeValue>cbceb8b5689b75a584efe35587b5d41bd48820ce</spdx:packageVerificationCodeValue>
 			<spdx:packageVerificationCodeExcludedFile>./package.spdx</spdx:packageVerificationCodeExcludedFile>
-		</spdx:PackageVerificationCode>
+		</spdx.PackageVerificationCode>
 	`)
 	node = parser.gordfParserObj.Triples[0].Subject
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = parser.setPackageVerificationCode(pkg, node)
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
@@ -185,7 +186,7 @@ func Test_rdfParser2_2_setPackageVerificationCode(t *testing.T) {
 }
 
 func Test_rdfParser2_2_getPackageExternalRef(t *testing.T) {
-	var extRef *spdx.PackageExternalReference2_2
+	var extRef *v2_2.PackageExternalReference
 	var err error
 	var parser *rdfParser2_2
 	var node *gordfParser.Node
@@ -239,7 +240,7 @@ func Test_rdfParser2_2_getPackageExternalRef(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error parsing a valid example: %v", err)
 	}
-	expectedExtRef := &spdx.PackageExternalReference2_2{
+	expectedExtRef := &v2_2.PackageExternalReference{
 		Locator:            "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*",
 		RefType:            "http://spdx.org/rdf/references/cpe23Type",
 		Category:           "SECURITY",
@@ -265,7 +266,7 @@ func Test_rdfParser2_2_getPackageExternalRef(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error parsing a valid example: %v", err)
 	}
-	expectedExtRef = &spdx.PackageExternalReference2_2{
+	expectedExtRef = &v2_2.PackageExternalReference{
 		Locator:            "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*",
 		RefType:            "http://spdx.org/rdf/references/cpe23Type",
 		Category:           "PACKAGE-MANAGER",
@@ -291,7 +292,7 @@ func Test_rdfParser2_2_getPackageExternalRef(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error parsing a valid example: %v", err)
 	}
-	expectedExtRef = &spdx.PackageExternalReference2_2{
+	expectedExtRef = &v2_2.PackageExternalReference{
 		Locator:            "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*",
 		RefType:            "http://spdx.org/rdf/references/cpe23Type",
 		Category:           "OTHER",
@@ -503,10 +504,10 @@ func Test_rdfParser2_2_getPackageFromNode(t *testing.T) {
 			<spdx:downloadLocation rdf:resource="http://spdx.org/rdf/terms#noassertion" />
 			<spdx:filesAnalyzed>true</spdx:filesAnalyzed>
 			<spdx:packageVerificationCode>
-                <spdx:PackageVerificationCode>
+                <spdx.PackageVerificationCode>
                     <spdx:packageVerificationCodeValue>cbceb8b5689b75a584efe35587b5d41bd48820ce</spdx:packageVerificationCodeValue>
 					<spdx:packageVerificationCodeExcludedFile>./package.spdx</spdx:packageVerificationCodeExcludedFile>
-                </spdx:PackageVerificationCode>
+                </spdx.PackageVerificationCode>
             </spdx:packageVerificationCode>
 			<spdx:checksum>
                 <spdx:Checksum>
@@ -564,14 +565,14 @@ func Test_rdfParser2_2_getPackageFromNode(t *testing.T) {
 }
 
 func Test_rdfParser2_2_setFileToPackage(t *testing.T) {
-	var pkg *spdx.Package2_2
-	var file *spdx.File2_2
+	var pkg *v2_2.Package
+	var file *v2_2.File
 	var parser *rdfParser2_2
 
 	// TestCase 1: setting to a nil files attribute shouldn't panic.
 	parser, _ = parserFromBodyContent(``)
-	pkg = &spdx.Package2_2{}
-	file = &spdx.File2_2{}
+	pkg = &v2_2.Package{}
+	file = &v2_2.File{}
 	parser.setFileToPackage(pkg, file)
 	if len(pkg.Files) != 1 {
 		t.Errorf("expected given package to have one file after setting, got %d", len(pkg.Files))
@@ -584,7 +585,7 @@ func Test_rdfParser2_2_setFileToPackage(t *testing.T) {
 func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 	var parser *rdfParser2_2
 	var node *gordfParser.Node
-	var pkg *spdx.Package2_2
+	var pkg *v2_2.Package
 	var expectedChecksumValue string
 	var err error
 
@@ -595,7 +596,7 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 			<spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha999"/>
 		</spdx:Checksum>
 	`)
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setPackageChecksum(pkg, node)
 	if err == nil {
@@ -609,7 +610,7 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 			<spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha384"/>
 		</spdx:Checksum>
 	`)
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setPackageChecksum(pkg, node)
 	if err == nil {
@@ -623,7 +624,7 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 			<spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha1"/>
 		</spdx:Checksum>
 	`)
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setPackageChecksum(pkg, node)
 	if err != nil {
@@ -633,7 +634,7 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 
 	for _, checksum := range pkg.PackageChecksums {
 		switch checksum.Algorithm {
-		case spdx.SHA1:
+		case common.SHA1:
 			if checksum.Value != expectedChecksumValue {
 				t.Errorf("expected %v, got: %v", expectedChecksumValue, checksum.Value)
 			}
@@ -647,7 +648,7 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 			<spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha256"/>
 		</spdx:Checksum>
 	`)
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setPackageChecksum(pkg, node)
 	if err != nil {
@@ -656,7 +657,7 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 	expectedChecksumValue = "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"
 	for _, checksum := range pkg.PackageChecksums {
 		switch checksum.Algorithm {
-		case spdx.SHA256:
+		case common.SHA256:
 			if checksum.Value != expectedChecksumValue {
 				t.Errorf("expected %v, got: %v", expectedChecksumValue, checksum.Value)
 			}
@@ -670,7 +671,7 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 			<spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_md5"/>
 		</spdx:Checksum>
 	`)
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setPackageChecksum(pkg, node)
 	if err != nil {
@@ -679,7 +680,7 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 	expectedChecksumValue = "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"
 	for _, checksum := range pkg.PackageChecksums {
 		switch checksum.Algorithm {
-		case spdx.MD5:
+		case common.MD5:
 			if checksum.Value != expectedChecksumValue {
 				t.Errorf("expected %v, got: %v", expectedChecksumValue, checksum.Value)
 			}
@@ -688,14 +689,14 @@ func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
 }
 
 func Test_setDocumentLocationFromURI(t *testing.T) {
-	var pkg *spdx.Package2_2
+	var pkg *v2_2.Package
 	var expectedDocumentLocation, gotDocumentLocation string
 	var inputURI string
 	var err error
 
 	// TestCase 1: NOASSERTION
 	inputURI = SPDX_NOASSERTION_SMALL
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = setDocumentLocationFromURI(pkg, inputURI)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -708,7 +709,7 @@ func Test_setDocumentLocationFromURI(t *testing.T) {
 
 	// TestCase 2: NONE
 	inputURI = SPDX_NONE_CAPS
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = setDocumentLocationFromURI(pkg, inputURI)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -721,7 +722,7 @@ func Test_setDocumentLocationFromURI(t *testing.T) {
 
 	// TestCase 3: valid uri
 	inputURI = "https://www.gnu.org/software/texinfo/"
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = setDocumentLocationFromURI(pkg, inputURI)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -734,7 +735,7 @@ func Test_setDocumentLocationFromURI(t *testing.T) {
 
 	// TestCase 3: invalid uri
 	inputURI = " "
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = setDocumentLocationFromURI(pkg, inputURI)
 	if err == nil {
 		t.Fatalf("expected an error due to invalid uri, got %v", err)
@@ -742,18 +743,18 @@ func Test_setDocumentLocationFromURI(t *testing.T) {
 }
 
 func Test_setFilesAnalyzed(t *testing.T) {
-	var pkg *spdx.Package2_2
+	var pkg *v2_2.Package
 	var err error
 
 	// TestCase 1: not a valid bool value:
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = setFilesAnalyzed(pkg, "no")
 	if err == nil {
 		t.Errorf("expected an error due to invalid bool input, got %v", err)
 	}
 
 	// TestCase 2: valid input
-	pkg = &spdx.Package2_2{}
+	pkg = &v2_2.Package{}
 	err = setFilesAnalyzed(pkg, "true")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
diff --git a/rdfloader/parser2v2/parse_relationship.go b/rdfloader/parser2v2/parse_relationship.go
index c4e8540..49f1025 100644
--- a/rdfloader/parser2v2/parse_relationship.go
+++ b/rdfloader/parser2v2/parse_relationship.go
@@ -4,10 +4,12 @@ package parser2v2
 
 import (
 	"fmt"
+	"strings"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	"github.com/spdx/gordf/rdfwriter"
-	"github.com/spdx/tools-golang/spdx"
-	"strings"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 // parsing the relationship that exists in the rdf document.
@@ -15,7 +17,7 @@ import (
 // parsing the relationship appends the relationship to the current document's
 // Relationships Slice.
 func (parser *rdfParser2_2) parseRelationship(triple *gordfParser.Triple) (err error) {
-	reln := spdx.Relationship2_2{}
+	reln := v2_2.Relationship{}
 
 	reln.RefA, err = getReferenceFromURI(triple.Subject.ID)
 	if err != nil {
@@ -40,7 +42,7 @@ func (parser *rdfParser2_2) parseRelationship(triple *gordfParser.Triple) (err e
 	parser.cache[triple.Object.ID].Color = GREY
 
 	// setting state color to black to indicate when we're done parsing this node.
-	defer func(){parser.cache[triple.Object.ID].Color = BLACK}();
+	defer func() { parser.cache[triple.Object.ID].Color = BLACK }()
 
 	for _, subTriple := range parser.nodeToTriples(triple.Object) {
 		switch subTriple.Predicate.ID {
@@ -85,7 +87,7 @@ func (parser *rdfParser2_2) parseRelationship(triple *gordfParser.Triple) (err e
 	return nil
 }
 
-func (parser *rdfParser2_2) parseRelatedElementFromTriple(reln *spdx.Relationship2_2, triple *gordfParser.Triple) error {
+func (parser *rdfParser2_2) parseRelatedElementFromTriple(reln *v2_2.Relationship, triple *gordfParser.Triple) error {
 	// iterate over relatedElement Type and check which SpdxElement it is.
 	var err error
 	switch triple.Object.ID {
@@ -94,7 +96,7 @@ func (parser *rdfParser2_2) parseRelatedElementFromTriple(reln *spdx.Relationshi
 		if err != nil {
 			return fmt.Errorf("error setting a file: %v", err)
 		}
-		reln.RefB = spdx.DocElementID{
+		reln.RefB = common.DocElementID{
 			DocumentRefID: "",
 			ElementRefID:  file.FileSPDXIdentifier,
 		}
@@ -104,7 +106,7 @@ func (parser *rdfParser2_2) parseRelatedElementFromTriple(reln *spdx.Relationshi
 		if err != nil {
 			return fmt.Errorf("error setting a package inside a relationship: %v", err)
 		}
-		reln.RefB = spdx.DocElementID{
+		reln.RefB = common.DocElementID{
 			DocumentRefID: "",
 			ElementRefID:  pkg.PackageSPDXIdentifier,
 		}
@@ -123,13 +125,13 @@ func (parser *rdfParser2_2) parseRelatedElementFromTriple(reln *spdx.Relationshi
 }
 
 // references like RefA and RefB of any relationship
-func getReferenceFromURI(uri string) (spdx.DocElementID, error) {
+func getReferenceFromURI(uri string) (common.DocElementID, error) {
 	fragment := getLastPartOfURI(uri)
 	switch strings.ToLower(strings.TrimSpace(fragment)) {
 	case "noassertion", "none":
-		return spdx.DocElementID{
+		return common.DocElementID{
 			DocumentRefID: "",
-			ElementRefID:  spdx.ElementID(strings.ToUpper(fragment)),
+			ElementRefID:  common.ElementID(strings.ToUpper(fragment)),
 		}, nil
 	}
 	return ExtractDocElementID(fragment)
diff --git a/rdfloader/parser2v2/parse_relationship_test.go b/rdfloader/parser2v2/parse_relationship_test.go
index 14f4c12..fd66d14 100644
--- a/rdfloader/parser2v2/parse_relationship_test.go
+++ b/rdfloader/parser2v2/parse_relationship_test.go
@@ -3,10 +3,12 @@
 package parser2v2
 
 import (
-	"github.com/spdx/gordf/rdfwriter"
-	"github.com/spdx/tools-golang/spdx"
 	"reflect"
 	"testing"
+
+	"github.com/spdx/gordf/rdfwriter"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 func Test_getReferenceFromURI(t *testing.T) {
@@ -81,20 +83,20 @@ func Test_rdfParser2_2_parseRelatedElementFromTriple(t *testing.T) {
 			</spdx:relatedSpdxElement>
 		</spdx:Relationship>
 	`)
-	reln := &spdx.Relationship2_2{}
+	reln := &v2_2.Relationship{}
 	triple := rdfwriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_PACKAGE)[0]
 	err := parser.parseRelatedElementFromTriple(reln, triple)
 	if err != nil {
 		t.Errorf("error parsing a valid example")
 	}
-	expectedRefA := spdx.DocElementID{
+	expectedRefA := common.DocElementID{
 		DocumentRefID: "",
 		ElementRefID:  "",
 	}
 	if !reflect.DeepEqual(expectedRefA, reln.RefA) {
 		t.Errorf("expected %+v, found %+v", expectedRefA, reln.RefA)
 	}
-	expectedRefB := spdx.DocElementID{
+	expectedRefB := common.DocElementID{
 		DocumentRefID: "",
 		ElementRefID:  "Saxon",
 	}
@@ -110,7 +112,7 @@ func Test_rdfParser2_2_parseRelatedElementFromTriple(t *testing.T) {
 			</spdx:relatedSpdxElement>
 		</spdx:Relationship>
 	`)
-	reln = &spdx.Relationship2_2{}
+	reln = &v2_2.Relationship{}
 	triple = rdfwriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_PACKAGE)[0]
 	err = parser.parseRelatedElementFromTriple(reln, triple)
 	if err == nil {
@@ -125,20 +127,20 @@ func Test_rdfParser2_2_parseRelatedElementFromTriple(t *testing.T) {
 			</spdx:relatedSpdxElement>
 		</spdx:Relationship>
 	`)
-	reln = &spdx.Relationship2_2{}
+	reln = &v2_2.Relationship{}
 	triple = rdfwriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0]
 	err = parser.parseRelatedElementFromTriple(reln, triple)
 	if err != nil {
 		t.Errorf("error parsing a valid example")
 	}
-	expectedRefA = spdx.DocElementID{
+	expectedRefA = common.DocElementID{
 		DocumentRefID: "",
 		ElementRefID:  "",
 	}
 	if !reflect.DeepEqual(expectedRefA, reln.RefA) {
 		t.Errorf("expected %+v, found %+v", expectedRefA, reln.RefA)
 	}
-	expectedRefB = spdx.DocElementID{
+	expectedRefB = common.DocElementID{
 		DocumentRefID: "",
 		ElementRefID:  "Saxon",
 	}
@@ -154,7 +156,7 @@ func Test_rdfParser2_2_parseRelatedElementFromTriple(t *testing.T) {
 			</spdx:relatedSpdxElement>
 		</spdx:Relationship>
 	`)
-	reln = &spdx.Relationship2_2{}
+	reln = &v2_2.Relationship{}
 	triple = rdfwriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0]
 	err = parser.parseRelatedElementFromTriple(reln, triple)
 	if err == nil {
@@ -169,20 +171,20 @@ func Test_rdfParser2_2_parseRelatedElementFromTriple(t *testing.T) {
 			</spdx:relatedSpdxElement>
 		</spdx:Relationship>
 	`)
-	reln = &spdx.Relationship2_2{}
+	reln = &v2_2.Relationship{}
 	triple = rdfwriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_SPDX_ELEMENT)[0]
 	err = parser.parseRelatedElementFromTriple(reln, triple)
 	if err != nil {
 		t.Errorf("error parsing a valid example")
 	}
-	expectedRefA = spdx.DocElementID{
+	expectedRefA = common.DocElementID{
 		DocumentRefID: "",
 		ElementRefID:  "",
 	}
 	if !reflect.DeepEqual(expectedRefA, reln.RefA) {
 		t.Errorf("expected %+v, found %+v", expectedRefA, reln.RefA)
 	}
-	expectedRefB = spdx.DocElementID{
+	expectedRefB = common.DocElementID{
 		DocumentRefID: "",
 		ElementRefID:  "File",
 	}
@@ -198,7 +200,7 @@ func Test_rdfParser2_2_parseRelatedElementFromTriple(t *testing.T) {
 			</spdx:relatedSpdxElement>
 		</spdx:Relationship>
 	`)
-	reln = &spdx.Relationship2_2{}
+	reln = &v2_2.Relationship{}
 	triple = rdfwriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_SPDX_ELEMENT)[0]
 	err = parser.parseRelatedElementFromTriple(reln, triple)
 	if err == nil {
@@ -374,14 +376,14 @@ func Test_rdfParser2_2_parseRelationship(t *testing.T) {
 	if reln.Relationship != expectedRelnType {
 		t.Errorf("expected %s, found %s", expectedRelnType, reln.Relationship)
 	}
-	expectedRefA := spdx.DocElementID{
+	expectedRefA := common.DocElementID{
 		DocumentRefID: "",
 		ElementRefID:  "File",
 	}
 	if !reflect.DeepEqual(expectedRefA, reln.RefA) {
 		t.Errorf("expected %+v, found %+v", expectedRefA, reln.RefA)
 	}
-	expectedRefB := spdx.DocElementID{
+	expectedRefB := common.DocElementID{
 		DocumentRefID: "",
 		ElementRefID:  "Saxon",
 	}
diff --git a/rdfloader/parser2v2/parse_review.go b/rdfloader/parser2v2/parse_review.go
index 437042d..40c87d3 100644
--- a/rdfloader/parser2v2/parse_review.go
+++ b/rdfloader/parser2v2/parse_review.go
@@ -4,12 +4,13 @@ package parser2v2
 
 import (
 	"fmt"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 func (parser *rdfParser2_2) setReviewFromNode(reviewedNode *gordfParser.Node) error {
-	review := spdx.Review2_2{}
+	review := v2_2.Review{}
 	for _, triple := range parser.nodeToTriples(reviewedNode) {
 		switch triple.Predicate.ID {
 		case RDF_TYPE:
diff --git a/rdfloader/parser2v2/parse_snippet_info.go b/rdfloader/parser2v2/parse_snippet_info.go
index a09d671..5e80944 100644
--- a/rdfloader/parser2v2/parse_snippet_info.go
+++ b/rdfloader/parser2v2/parse_snippet_info.go
@@ -4,16 +4,18 @@ package parser2v2
 
 import (
 	"fmt"
+	"strconv"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	"github.com/spdx/gordf/rdfwriter"
-	"github.com/spdx/tools-golang/spdx"
-	"strconv"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 // Snippet Information
 // Cardinality: Optional, Many
-func (parser *rdfParser2_2) getSnippetInformationFromNode2_2(node *gordfParser.Node) (si *spdx.Snippet2_2, err error) {
-	si = &spdx.Snippet2_2{}
+func (parser *rdfParser2_2) getSnippetInformationFromNode2_2(node *gordfParser.Node) (si *v2_2.Snippet, err error) {
+	si = &v2_2.Snippet{}
 
 	err = setSnippetID(node.ID, si)
 	if err != nil {
@@ -72,14 +74,14 @@ func (parser *rdfParser2_2) getSnippetInformationFromNode2_2(node *gordfParser.N
 }
 
 // given is the id of the file, sets the snippet to the file in parser.
-func (parser *rdfParser2_2) setSnippetToFileWithID(snippet *spdx.Snippet2_2, fileID spdx.ElementID) error {
+func (parser *rdfParser2_2) setSnippetToFileWithID(snippet *v2_2.Snippet, fileID common.ElementID) error {
 	if parser.files[fileID] == nil {
 		return fmt.Errorf("snippet refers to an undefined file with ID: %s", fileID)
 	}
 
 	// initializing snippet of the files if it is not defined already
 	if parser.files[fileID].Snippets == nil {
-		parser.files[fileID].Snippets = map[spdx.ElementID]*spdx.Snippet2_2{}
+		parser.files[fileID].Snippets = map[common.ElementID]*v2_2.Snippet{}
 	}
 
 	// setting the snippet to the file.
@@ -88,7 +90,7 @@ func (parser *rdfParser2_2) setSnippetToFileWithID(snippet *spdx.Snippet2_2, fil
 	return nil
 }
 
-func (parser *rdfParser2_2) setSnippetRangeFromNode(node *gordfParser.Node, si *spdx.Snippet2_2) error {
+func (parser *rdfParser2_2) setSnippetRangeFromNode(node *gordfParser.Node, si *v2_2.Snippet) error {
 	// for a range object, we can have only 3 associated triples:
 	//		node -> RDF_TYPE     -> Object
 	//      node -> startPointer -> Object
@@ -132,9 +134,9 @@ func (parser *rdfParser2_2) setSnippetRangeFromNode(node *gordfParser.Node, si *
 		return fmt.Errorf("start and end range type doesn't match")
 	}
 
-	si.Ranges = []spdx.SnippetRange{{
-		StartPointer: spdx.SnippetRangePointer{FileSPDXIdentifier: si.SnippetFromFileSPDXIdentifier},
-		EndPointer:   spdx.SnippetRangePointer{FileSPDXIdentifier: si.SnippetFromFileSPDXIdentifier},
+	si.Ranges = []common.SnippetRange{{
+		StartPointer: common.SnippetRangePointer{FileSPDXIdentifier: si.SnippetFromFileSPDXIdentifier},
+		EndPointer:   common.SnippetRangePointer{FileSPDXIdentifier: si.SnippetFromFileSPDXIdentifier},
 	}}
 
 	if startRangeType == LINE_RANGE {
@@ -147,7 +149,7 @@ func (parser *rdfParser2_2) setSnippetRangeFromNode(node *gordfParser.Node, si *
 	return nil
 }
 
-func (parser *rdfParser2_2) getPointerFromNode(node *gordfParser.Node, si *spdx.Snippet2_2) (rt RangeType, number int, err error) {
+func (parser *rdfParser2_2) getPointerFromNode(node *gordfParser.Node, si *v2_2.Snippet) (rt RangeType, number int, err error) {
 	for _, triple := range parser.nodeToTriples(node) {
 		switch triple.Predicate.ID {
 		case RDF_TYPE:
@@ -172,7 +174,7 @@ func (parser *rdfParser2_2) getPointerFromNode(node *gordfParser.Node, si *spdx.
 	return
 }
 
-func (parser *rdfParser2_2) parseRangeReference(node *gordfParser.Node, snippet *spdx.Snippet2_2) error {
+func (parser *rdfParser2_2) parseRangeReference(node *gordfParser.Node, snippet *v2_2.Snippet) error {
 	// reference is supposed to be either a resource reference to an already
 	// defined or a new file. Unfortunately, I didn't find field where this can be set in the tools-golang data model.
 	// todo: set this reference to the snippet
@@ -187,7 +189,7 @@ func (parser *rdfParser2_2) parseRangeReference(node *gordfParser.Node, snippet
 	return nil
 }
 
-func setSnippetID(uri string, si *spdx.Snippet2_2) (err error) {
+func setSnippetID(uri string, si *v2_2.Snippet) (err error) {
 	fragment := getLastPartOfURI(uri)
 	si.SnippetSPDXIdentifier, err = ExtractElementID(fragment)
 	if err != nil {
diff --git a/rdfloader/parser2v2/parse_snippet_info_test.go b/rdfloader/parser2v2/parse_snippet_info_test.go
index 47e999e..df0bb70 100644
--- a/rdfloader/parser2v2/parse_snippet_info_test.go
+++ b/rdfloader/parser2v2/parse_snippet_info_test.go
@@ -3,9 +3,11 @@
 package parser2v2
 
 import (
-	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
 	"testing"
+
+	gordfParser "github.com/spdx/gordf/rdfloader/parser"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 func Test_rdfParser2_2_getSnippetInformationFromTriple2_2(t *testing.T) {
@@ -129,13 +131,13 @@ func Test_rdfParser2_2_getSnippetInformationFromTriple2_2(t *testing.T) {
 
 func Test_setSnippetID(t *testing.T) {
 	// TestCase 1: invalid input (empty)
-	err := setSnippetID("", &spdx.Snippet2_2{})
+	err := setSnippetID("", &v2_2.Snippet{})
 	if err == nil {
 		t.Errorf("should've raised an error for empty input")
 	}
 
 	// TestCase 2: valid input
-	si := &spdx.Snippet2_2{}
+	si := &v2_2.Snippet{}
 	err = setSnippetID("http://spdx.org/spdxdocs/spdx-example#SPDXRef-Snippet", si)
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
@@ -149,10 +151,10 @@ func Test_rdfParser2_2_parseRangeReference(t *testing.T) {
 	var err error
 	var node *gordfParser.Node
 	var parser *rdfParser2_2
-	var si *spdx.Snippet2_2
+	var si *v2_2.Snippet
 
 	// TestCase 1: ResourceLiteral node without a new file shouldn't raise any error.
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	parser, _ = parserFromBodyContent(``)
 	node = &gordfParser.Node{
 		NodeType: gordfParser.RESOURCELITERAL,
@@ -164,7 +166,7 @@ func Test_rdfParser2_2_parseRangeReference(t *testing.T) {
 	}
 
 	// TestCase 2: invalid file in the reference should raise an error
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	parser, _ = parserFromBodyContent(`
 		<spdx:File rdf:about="http://spdx.org/spdxdocs/spdx-example-444504E0-4F89-41D3-9A0C-0305E82C3301#DoapSource">
 			<spdx:fileName> test file </spdx:fileName>
@@ -177,7 +179,7 @@ func Test_rdfParser2_2_parseRangeReference(t *testing.T) {
 	}
 
 	// TestCase 3: A valid reference must set the file to the files map of the parser.
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	parser, _ = parserFromBodyContent(`
 		<spdx:File rdf:about="http://spdx.org/spdxdocs/spdx-example-444504E0-4F89-41D3-9A0C-0305E82C3301#SPDXRef-DoapSource">
 			<spdx:fileName> test file </spdx:fileName>
@@ -196,7 +198,7 @@ func Test_rdfParser2_2_parseRangeReference(t *testing.T) {
 func Test_rdfParser2_2_getPointerFromNode(t *testing.T) {
 	var parser *rdfParser2_2
 	var node *gordfParser.Node
-	var si *spdx.Snippet2_2
+	var si *v2_2.Snippet
 	var err error
 	var rt RangeType
 	var number int
@@ -278,7 +280,7 @@ func Test_rdfParser2_2_getPointerFromNode(t *testing.T) {
 func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 	var parser *rdfParser2_2
 	var err error
-	var si *spdx.Snippet2_2
+	var si *v2_2.Snippet
 	var node *gordfParser.Node
 
 	// TestCase 1: range with less one pointer less must raise an error
@@ -294,7 +296,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
             </j.0:StartEndPointer>
         
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setSnippetRangeFromNode(node, si)
 	if err == nil {
@@ -320,7 +322,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
             </j.0:StartEndPointer>
         
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	dummyTriple := parser.gordfParserObj.Triples[0]
 	// resetting the node to be associated with 3 triples which will have
@@ -350,7 +352,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 			</j.0:endPointer>
 		</j.0:StartEndPointer>
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setSnippetRangeFromNode(node, si)
 	if err == nil {
@@ -374,7 +376,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 			</j.0:endPointer>
 		</j.0:StartEndPointer>
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setSnippetRangeFromNode(node, si)
 	if err == nil {
@@ -398,7 +400,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 			</j.0:endPointer>
 		</j.0:StartEndPointer>
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setSnippetRangeFromNode(node, si)
 	if err == nil {
@@ -422,7 +424,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 			</j.0:endPointer>
 		</j.0:StartEndPointer> 
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setSnippetRangeFromNode(node, si)
 	if err == nil {
@@ -446,7 +448,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 			</j.0:endPointer>
 		</j.0:StartEndPointer>
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setSnippetRangeFromNode(node, si)
 	if err == nil {
@@ -470,7 +472,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 			</j.0:endPointer>
 		</j.0:StartEndPointer>
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setSnippetRangeFromNode(node, si)
 	if err != nil {
@@ -494,7 +496,7 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 			</j.0:endPointer>
 		</j.0:StartEndPointer>
 	`)
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	node = parser.gordfParserObj.Triples[0].Subject
 	err = parser.setSnippetRangeFromNode(node, si)
 	if err != nil {
@@ -504,22 +506,22 @@ func Test_rdfParser2_2_setSnippetRangeFromNode(t *testing.T) {
 
 func Test_rdfParser2_2_setSnippetToFileWithID(t *testing.T) {
 	var parser *rdfParser2_2
-	var fileId spdx.ElementID
-	var si *spdx.Snippet2_2
-	var file *spdx.File2_2
+	var fileId common.ElementID
+	var si *v2_2.Snippet
+	var file *v2_2.File
 	var err error
 
 	// TestCase 1: file id which is not associated with any file must raise an error.
 	parser, _ = parserFromBodyContent("")
-	si = &spdx.Snippet2_2{}
+	si = &v2_2.Snippet{}
 	err = parser.setSnippetToFileWithID(si, fileId)
 	if err == nil {
 		t.Errorf("expected an error saying undefined file")
 	}
 
 	// TestCase 2: file exists, but snippet of the file doesn't ( it mustn't raise any error )
-	fileId = spdx.ElementID("File1")
-	file = &spdx.File2_2{
+	fileId = common.ElementID("File1")
+	file = &v2_2.File{
 		FileSPDXIdentifier: fileId,
 	}
 	parser.files[fileId] = file
diff --git a/rdfloader/parser2v2/parse_spdx_document.go b/rdfloader/parser2v2/parse_spdx_document.go
index 6159317..481e8cc 100644
--- a/rdfloader/parser2v2/parse_spdx_document.go
+++ b/rdfloader/parser2v2/parse_spdx_document.go
@@ -4,8 +4,10 @@ package parser2v2
 
 import (
 	"fmt"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 func (parser *rdfParser2_2) parseSpdxDocumentNode(spdxDocNode *gordfParser.Node) (err error) {
@@ -18,8 +20,8 @@ func (parser *rdfParser2_2) parseSpdxDocumentNode(spdxDocNode *gordfParser.Node)
 	if err != nil {
 		return err
 	}
-	parser.doc.DocumentNamespace = baseUri             // 2.5
-	parser.doc.SPDXIdentifier = spdx.ElementID(offset) // 2.3
+	parser.doc.DocumentNamespace = baseUri               // 2.5
+	parser.doc.SPDXIdentifier = common.ElementID(offset) // 2.3
 
 	// parse other associated triples.
 	for _, subTriple := range parser.nodeToTriples(spdxDocNode) {
@@ -42,7 +44,7 @@ func (parser *rdfParser2_2) parseSpdxDocumentNode(spdxDocNode *gordfParser.Node)
 			parser.doc.DocumentName = objectValue
 		case SPDX_EXTERNAL_DOCUMENT_REF: // 2.6: externalDocumentReferences
 			// cardinality: min 0
-			var extRef spdx.ExternalDocumentRef2_2
+			var extRef v2_2.ExternalDocumentRef
 			extRef, err = parser.getExternalDocumentRefFromNode(subTriple.Object)
 			if err != nil {
 				return err
@@ -59,7 +61,7 @@ func (parser *rdfParser2_2) parseSpdxDocumentNode(spdxDocNode *gordfParser.Node)
 			err = parser.setReviewFromNode(subTriple.Object)
 		case SPDX_DESCRIBES_PACKAGE: // describes Package
 			// cardinality: min 0
-			var pkg *spdx.Package2_2
+			var pkg *v2_2.Package
 			pkg, err = parser.getPackageFromNode(subTriple.Object)
 			if err != nil {
 				return err
@@ -89,7 +91,7 @@ func (parser *rdfParser2_2) parseSpdxDocumentNode(spdxDocNode *gordfParser.Node)
 	return nil
 }
 
-func (parser *rdfParser2_2) getExternalDocumentRefFromNode(node *gordfParser.Node) (edr spdx.ExternalDocumentRef2_2, err error) {
+func (parser *rdfParser2_2) getExternalDocumentRefFromNode(node *gordfParser.Node) (edr v2_2.ExternalDocumentRef, err error) {
 	for _, triple := range parser.nodeToTriples(node) {
 		switch triple.Predicate.ID {
 		case SPDX_EXTERNAL_DOCUMENT_ID:
diff --git a/rdfloader/parser2v2/parse_spdx_document_test.go b/rdfloader/parser2v2/parse_spdx_document_test.go
index a313479..9d22faa 100644
--- a/rdfloader/parser2v2/parse_spdx_document_test.go
+++ b/rdfloader/parser2v2/parse_spdx_document_test.go
@@ -3,8 +3,9 @@
 package parser2v2
 
 import (
-	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	"testing"
+
+	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 )
 
 func Test_rdfParser2_2_getExternalDocumentRefFromNode(t *testing.T) {
diff --git a/rdfloader/parser2v2/parser.go b/rdfloader/parser2v2/parser.go
index 6329dc4..4b3b62c 100644
--- a/rdfloader/parser2v2/parser.go
+++ b/rdfloader/parser2v2/parser.go
@@ -5,9 +5,11 @@ package parser2v2
 import (
 	"errors"
 	"fmt"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	gordfWriter "github.com/spdx/gordf/rdfwriter"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 // returns a new instance of rdfParser2_2 given the gordf object and nodeToTriples mapping
@@ -15,18 +17,18 @@ func NewParser2_2(gordfParserObj *gordfParser.Parser, nodeToTriples map[string][
 	parser := rdfParser2_2{
 		gordfParserObj:      gordfParserObj,
 		nodeStringToTriples: nodeToTriples,
-		doc: &spdx.Document2_2{
-			ExternalDocumentReferences: []spdx.ExternalDocumentRef2_2{},
-			CreationInfo:               &spdx.CreationInfo2_2{},
-			Packages:                   []*spdx.Package2_2{},
-			Files:                      []*spdx.File2_2{},
-			OtherLicenses:              []*spdx.OtherLicense2_2{},
-			Relationships:              []*spdx.Relationship2_2{},
-			Annotations:                []*spdx.Annotation2_2{},
-			Reviews:                    []*spdx.Review2_2{},
+		doc: &v2_2.Document{
+			ExternalDocumentReferences: []v2_2.ExternalDocumentRef{},
+			CreationInfo:               &v2_2.CreationInfo{},
+			Packages:                   []*v2_2.Package{},
+			Files:                      []*v2_2.File{},
+			OtherLicenses:              []*v2_2.OtherLicense{},
+			Relationships:              []*v2_2.Relationship{},
+			Annotations:                []*v2_2.Annotation{},
+			Reviews:                    []*v2_2.Review{},
 		},
-		files:            map[spdx.ElementID]*spdx.File2_2{},
-		assocWithPackage: map[spdx.ElementID]bool{},
+		files:            map[common.ElementID]*v2_2.File{},
+		assocWithPackage: map[common.ElementID]bool{},
 		cache:            map[string]*nodeState{},
 	}
 	return &parser
@@ -34,7 +36,7 @@ func NewParser2_2(gordfParserObj *gordfParser.Parser, nodeToTriples map[string][
 
 // main function which takes in a gordfParser and returns
 // a spdxDocument model or the error encountered while parsing it
-func LoadFromGoRDFParser(gordfParserObj *gordfParser.Parser) (*spdx.Document2_2, error) {
+func LoadFromGoRDFParser(gordfParserObj *gordfParser.Parser) (*v2_2.Document, error) {
 	// nodeToTriples is a mapping from a node to list of triples.
 	// for every node in the set of subjects of all the triples,
 	// it provides a list of triples that are associated with that subject node.
diff --git a/rdfloader/parser2v2/types.go b/rdfloader/parser2v2/types.go
index 4d16344..dbb50d5 100644
--- a/rdfloader/parser2v2/types.go
+++ b/rdfloader/parser2v2/types.go
@@ -4,7 +4,8 @@ package parser2v2
 
 import (
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
+	"github.com/spdx/tools-golang/spdx/common"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 type rdfParser2_2 struct {
@@ -14,11 +15,11 @@ type rdfParser2_2 struct {
 	nodeStringToTriples map[string][]*gordfParser.Triple
 
 	// document into which data is being parsed
-	doc *spdx.Document2_2
+	doc *v2_2.Document
 
 	// map of packages and files.
-	files            map[spdx.ElementID]*spdx.File2_2
-	assocWithPackage map[spdx.ElementID]bool
+	files            map[common.ElementID]*v2_2.File
+	assocWithPackage map[common.ElementID]bool
 
 	// mapping of nodeStrings to parsed object to save double computation.
 	cache map[string]*nodeState
@@ -27,16 +28,16 @@ type rdfParser2_2 struct {
 type Color int
 
 const (
-	GREY Color = iota // represents that the node is being visited
-	WHITE             // unvisited node
-	BLACK             // visited node
+	GREY  Color = iota // represents that the node is being visited
+	WHITE              // unvisited node
+	BLACK              // visited node
 )
 
 type nodeState struct {
 	// object will be pointer to the parsed or element being parsed.
 	object interface{}
 	// color of a state represents if the node is visited/unvisited/being-visited.
-	Color  Color
+	Color Color
 }
 
 type AnyLicenseInfo interface {
diff --git a/rdfloader/parser2v2/utils.go b/rdfloader/parser2v2/utils.go
index 27207d2..9f51a3c 100644
--- a/rdfloader/parser2v2/utils.go
+++ b/rdfloader/parser2v2/utils.go
@@ -5,11 +5,12 @@ package parser2v2
 import (
 	"errors"
 	"fmt"
+	"strings"
+
 	gordfParser "github.com/spdx/gordf/rdfloader/parser"
 	"github.com/spdx/gordf/rdfwriter"
 	urilib "github.com/spdx/gordf/uri"
-	"github.com/spdx/tools-golang/spdx"
-	"strings"
+	"github.com/spdx/tools-golang/spdx/common"
 )
 
 // a uri is of type baseURI#fragment or baseFragment/subFragment
@@ -67,7 +68,7 @@ func boolFromString(boolString string) (bool, error) {
 
 // used to extract DocumentRef and SPDXRef values from an SPDX Identifier
 // which can point either to this document or to a different one
-func ExtractDocElementID(value string) (spdx.DocElementID, error) {
+func ExtractDocElementID(value string) (common.DocElementID, error) {
 	docRefID := ""
 	idStr := value
 
@@ -77,16 +78,16 @@ func ExtractDocElementID(value string) (spdx.DocElementID, error) {
 		strs := strings.Split(idStr, ":")
 		// should be exactly two, part before and part after
 		if len(strs) < 2 {
-			return spdx.DocElementID{}, fmt.Errorf("no colon found although DocumentRef- prefix present")
+			return common.DocElementID{}, fmt.Errorf("no colon found although DocumentRef- prefix present")
 		}
 		if len(strs) > 2 {
-			return spdx.DocElementID{}, fmt.Errorf("more than one colon found")
+			return common.DocElementID{}, fmt.Errorf("more than one colon found")
 		}
 
 		// trim the prefix and confirm non-empty
 		docRefID = strings.TrimPrefix(strs[0], "DocumentRef-")
 		if docRefID == "" {
-			return spdx.DocElementID{}, fmt.Errorf("document identifier has nothing after prefix")
+			return common.DocElementID{}, fmt.Errorf("document identifier has nothing after prefix")
 		}
 		// and use remainder for element ID parsing
 		idStr = strs[1]
@@ -94,48 +95,48 @@ func ExtractDocElementID(value string) (spdx.DocElementID, error) {
 
 	// check prefix to confirm it's got the right prefix for element IDs
 	if !strings.HasPrefix(idStr, "SPDXRef-") {
-		return spdx.DocElementID{}, fmt.Errorf("missing SPDXRef- prefix for element identifier")
+		return common.DocElementID{}, fmt.Errorf("missing SPDXRef- prefix for element identifier")
 	}
 
 	// make sure no colons are present
 	if strings.Contains(idStr, ":") {
 		// we know this means there was no DocumentRef- prefix, because
 		// we would have handled multiple colons above if it was
-		return spdx.DocElementID{}, fmt.Errorf("invalid colon in element identifier")
+		return common.DocElementID{}, fmt.Errorf("invalid colon in element identifier")
 	}
 
 	// trim the prefix and confirm non-empty
 	eltRefID := strings.TrimPrefix(idStr, "SPDXRef-")
 	if eltRefID == "" {
-		return spdx.DocElementID{}, fmt.Errorf("element identifier has nothing after prefix")
+		return common.DocElementID{}, fmt.Errorf("element identifier has nothing after prefix")
 	}
 
 	// we're good
-	return spdx.DocElementID{DocumentRefID: docRefID, ElementRefID: spdx.ElementID(eltRefID)}, nil
+	return common.DocElementID{DocumentRefID: docRefID, ElementRefID: common.ElementID(eltRefID)}, nil
 }
 
 // used to extract SPDXRef values only from an SPDX Identifier which can point
 // to this document only. Use extractDocElementID for parsing IDs that can
 // refer either to this document or a different one.
-func ExtractElementID(value string) (spdx.ElementID, error) {
+func ExtractElementID(value string) (common.ElementID, error) {
 	// check prefix to confirm it's got the right prefix for element IDs
 	if !strings.HasPrefix(value, "SPDXRef-") {
-		return spdx.ElementID(""), fmt.Errorf("missing SPDXRef- prefix for element identifier")
+		return common.ElementID(""), fmt.Errorf("missing SPDXRef- prefix for element identifier")
 	}
 
 	// make sure no colons are present
 	if strings.Contains(value, ":") {
-		return spdx.ElementID(""), fmt.Errorf("invalid colon in element identifier")
+		return common.ElementID(""), fmt.Errorf("invalid colon in element identifier")
 	}
 
 	// trim the prefix and confirm non-empty
 	eltRefID := strings.TrimPrefix(value, "SPDXRef-")
 	if eltRefID == "" {
-		return spdx.ElementID(""), fmt.Errorf("element identifier has nothing after prefix")
+		return common.ElementID(""), fmt.Errorf("element identifier has nothing after prefix")
 	}
 
 	// we're good
-	return spdx.ElementID(eltRefID), nil
+	return common.ElementID(eltRefID), nil
 }
 
 // used to extract key / value from embedded substrings
diff --git a/rdfloader/parser2v2/utils_test.go b/rdfloader/parser2v2/utils_test.go
index 797143b..c0cc574 100644
--- a/rdfloader/parser2v2/utils_test.go
+++ b/rdfloader/parser2v2/utils_test.go
@@ -3,10 +3,11 @@
 package parser2v2
 
 import (
-	gordfParser "github.com/spdx/gordf/rdfloader/parser"
-	"github.com/spdx/tools-golang/spdx"
 	"reflect"
 	"testing"
+
+	gordfParser "github.com/spdx/gordf/rdfloader/parser"
+	"github.com/spdx/tools-golang/spdx/common"
 )
 
 func Test_getLastPartOfURI(t *testing.T) {
@@ -223,7 +224,7 @@ func helperForExtractDocElementID(t *testing.T, tst string, wantErr bool, wantDo
 			t.Errorf("testing %v: want %v for DocumentRefID, got %v", tst, wantDoc, deID.DocumentRefID)
 		}
 	}
-	if deID.ElementRefID != spdx.ElementID(wantElt) {
+	if deID.ElementRefID != common.ElementID(wantElt) {
 		if wantElt == "" {
 			t.Errorf("testing %v: want emptyString for ElementRefID, got %v", tst, deID.ElementRefID)
 		} else {
@@ -259,7 +260,7 @@ func helperForExtractElementID(t *testing.T, tst string, wantErr bool, wantElt s
 	if err == nil && wantErr == true {
 		t.Errorf("testing %v: expected non-nil error, got nil", tst)
 	}
-	if eID != spdx.ElementID(wantElt) {
+	if eID != common.ElementID(wantElt) {
 		if wantElt == "" {
 			t.Errorf("testing %v: want emptyString for ElementRefID, got %v", tst, eID)
 		} else {
diff --git a/rdfloader/rdfloader.go b/rdfloader/rdfloader.go
index d06bd40..838b0d7 100644
--- a/rdfloader/rdfloader.go
+++ b/rdfloader/rdfloader.go
@@ -3,15 +3,16 @@
 package rdfloader
 
 import (
+	"io"
+
 	"github.com/spdx/gordf/rdfloader"
 	"github.com/spdx/tools-golang/rdfloader/parser2v2"
-	"github.com/spdx/tools-golang/spdx"
-	"io"
+	"github.com/spdx/tools-golang/spdx/v2_2"
 )
 
 // Takes in a file Reader and returns the pertaining spdx document
 // or the error if any is encountered while setting the doc.
-func Load2_2(content io.Reader) (*spdx.Document2_2, error) {
+func Load2_2(content io.Reader) (*v2_2.Document, error) {
 	var rdfParserObj, err = rdfloader.LoadFromReaderObject(content)
 	if err != nil {
 		return nil, err