## Manipulating Ontology Terms

1. Manipulating Ontology Terms (names, IDs, xref's, definitions, and so forth).

1. Manipulating Ontology Terms (names, IDs, xref's, definitions, and so forth):

       			use OBO::Core::Term;
       			use OBO::Core::Def;
       			use OBO::Util::DbxrefSet;
       			use OBO::Core::Dbxref;
       			use OBO::Core::Synonym;
       			use strict;

       			# three new terms
       			my $n1 = OBO::Core::Term->new();
       			my $n2 = OBO::Core::Term->new();
       			my $n3 = OBO::Core::Term->new();

       			# setting up id's
       			$n1->id("APO:P0000001");
       			$n2->id("APO:P0000002");
       			$n3->id("APO:P0000003");

       			# name, namespace, code for term n1
       			my $my_idspace = $n1->idspace();      # should be "APO"
       			my $my_subns   = $n1->subnamespace(); # should be "P"
       			my $my_code    = $n1->code();         # should be "0000001"

       			# alt_id
       			$n1->alt_id("APO:P0000001_alt_id");
       			$n2->alt_id("APO:P0000002_alt_id1", "APO:P0000002_alt_id2", "APO:P0000002_alt_id3", "APO:P0000002_alt_id4");

       			my @n2_alt_ids = $n2->alt_id()->get_set(); # get all the alternative ids of n2

       			# n3 has no alt ids; therefore, $n3->alt_id()->get_set() is empty

       			# subset
       			$n1->subset("APO:P0000001_subset");
       			$n2->subset("APO:P0000002_subset1", "APO:P0000002_subset2", "APO:P0000002_subset3", "APO:P0000002_subset4");

       			my @n2_subsets = $n2->subset(); # get all the subsets of n2

       			# n3 has no subsets; therefore, $n3->subsets() is empty

       			# name
       			$n1->name("One");
       			$n2->name("Two");
       			$n3->name("Three");

       			if (!$n1->is_obsolete()) { # if n1 is not obsolete
       				$n1->is_obsolete(1);   # make it obsolete
       			}

       			if ($n1->is_obsolete()) { # if n1 is obsolete
       				$n1->is_obsolete(0);  # make it non-obsolete
       			}

       			if (!$n1->is_anonymous()) { # if n1 is not anonymous
       				$n1->is_anonymous(1);   # make it anonymous
       			}

       			if ($n1->is_anonymous()) { # if n1 is anonymous
       				$n1->is_anonymous(0);  # make it non-anonymous
       			}

       			# synonyms
       			my $syn1 = OBO::Core::Synonym->new();
       			$syn1->type('EXACT');         # set the type of synonym

       			my $def1 = OBO::Core::Def->new();
       			$def1->text("Hola mundo1");   # set a definition

       			my $sref1 = OBO::Core::Dbxref->new();
       			$sref1->name("APO:vm");       # set the DB and ACC of the dbxref

       			my $srefs_set1 = OBO::Util::DbxrefSet->new();
       			$srefs_set1->add($sref1);
       			$def1->dbxref_set($srefs_set1);
       			$syn1->def($def1);
       			$n1->synonym_set($syn1);

       			my $syn2 = OBO::Core::Synonym->new();
       			$syn2->type('BROAD');         # set the type of synonym

       			my $def2 = OBO::Core::Def->new();
       			$def2->text("Hola mundo2");   # set a definition

       			my $sref2 = OBO::Core::Dbxref->new();
       			$sref2->name("APO:ls");       # set the DB and ACC of the dbxref

       			$srefs_set1->add_all($sref1);
       			my $srefs_set2 = OBO::Util::DbxrefSet->new();
       			$srefs_set2->add_all($sref1, $sref2);
       			$def2->dbxref_set($srefs_set2);
       			$syn2->def($def2);
       			$n2->synonym_set($syn2);

       			# n3 has no synonyms so far; therefore, $n3->synonym_set() is empty, let's add some...

       			my $syn3 = OBO::Core::Synonym->new();
       			$syn3->type('BROAD');

       			my $def3 = OBO::Core::Def->new();
       			$def3->text("Hola mundo2");

       			my $sref3 = OBO::Core::Dbxref->new();
       			$sref3->name("APO:ls");

       			my $srefs_set3 = OBO::Util::DbxrefSet->new();
       			$srefs_set3->add_all($sref1, $sref2);
       			$def3->dbxref_set($srefs_set3);
       			$syn3->def($def3);
       			$n3->synonym_set($syn3);

       			# getting synonyms
       			if (($n1->synonym_set())[0]->equals($syn1)) {
       				# the synonym has been properly set
       			}

       			if (($n2->synonym_set())[0]->equals($syn2)) {
       				# the synonym has been properly set
       			}

       			if (($n3->synonym_set())[0]->equals($syn3)) {
       				# the synonym has been properly set
       			}

       			if (($n2->synonym_set())[0]->type() eq 'BROAD') {
       				# the synonym type has been properly set
       			}

       			if (($n2->synonym_set())[0]->def()->equals(($n3->synonym_set())[0]->def())) {
       				# the definition of the synonym has been properly set
       			}

       			if (($n2->synonym_set())[0]->equals(($n3->synonym_set())[0])) {
       				# both sets hold the same synonyms
       			}

       			# checking the synonym as strings
       			if (($n2->synonym_as_string())[0] eq "\"Hola mundo2\" [APO:ls, APO:vm]") {
       				# should enter here
       			}

       			# setting a sysnonym as string
       			$n2->synonym_as_string("Hello world2", "[APO:vm2, APO:ls2]", "EXACT");
       			# as a result, the following should be TRUE:
       			(($n2->synonym_as_string())[0] eq "\"Hello world2\" [APO:ls2, APO:vm2]");
       			(($n2->synonym_as_string())[1] eq "\"Hola mundo2\" [APO:ls, APO:vm]");

       			# xref
       			my $xref1 = OBO::Core::Dbxref->new();
       			my $xref2 = OBO::Core::Dbxref->new();
       			my $xref3 = OBO::Core::Dbxref->new();
       			my $xref4 = OBO::Core::Dbxref->new();
       			my $xref5 = OBO::Core::Dbxref->new();

       			$xref1->name("XAPO:vm");
       			$xref2->name("XAPO:ls");
       			$xref3->name("XAPO:ea");
       			$xref4->name("XAPO:vm");
       			$xref5->name("XAPO:ls");

       			my $xrefs_set = OBO::Util::DbxrefSet->new();
       			$xrefs_set->add_all($xref1, $xref2, $xref3, $xref4, $xref5);
       			$n1->xref_set($xrefs_set);
       			if ($n1->xref_set()->contains($xref3)){
       				# should enter here
       			}
       			my $xref_length = $n1->xref_set()->size(); # should be 3

       			# xref_set_as_string
       			my @empty_refs = $n2->xref_set_as_string(); # no refs so far
       			$n2->xref_set_as_string("[YAPO:vm, YAPO:ls, YAPO:ea \"Erick Antezana\"] {opt=first}");
       			# then get them back:
       			my @xrefs_n2 = $n2->xref_set()->get_set();

       			# def
       			my $def = OBO::Core::Def->new();
       			$def->text("Hola mundo");
       			my $ref1 = OBO::Core::Dbxref->new();
       			my $ref2 = OBO::Core::Dbxref->new();
       			my $ref3 = OBO::Core::Dbxref->new();

       			$ref1->name("APO:vm");
       			$ref2->name("APO:ls");
       			$ref3->name("APO:ea");

       			my $refs_set = OBO::Util::DbxrefSet->new();
       			$refs_set->add_all($ref1,$ref2,$ref3);
       			$def->dbxref_set($refs_set);
       			$n1->def($def);
       			my $hola_numdo = $n1->def()->text(); should be "Hola mundo"

       			my $ dbxref_set_size = $n1->def()->dbxref_set()->size(); # should be 3

       			#set definition
       			$n2->def($def);

       			# def as string
       			my $n2_def_as_string = $n2->def_as_string(); # should be "Hola mundo" [APO:ea, APO:ls, APO:vm]

       			$n2->def_as_string("This is a dummy definition", "[APO:vm, APO:ls, APO:ea \"Erick Antezana\" {opt=first}]");
       			my $n2_def_text = $n2->def()->text(); # should be "This is a dummy definition"

       			# get them back:
       			my @refs_n2 = $n2->def()->dbxref_set()->get_set();

       			# definition as string
       			$n2_def_as_string = $n2->def_as_string(); # should be "This is a dummy definition" [APO:ea "Erick Antezana" {opt=first}, APO:ls, APO:vm]

       			# OBO tag: 'disjoint_from'
       			$n2->disjoint_from($n1->id(), $n3->id());
       			my @dis = sort {$a cmp $b} $n2->disjoint_from(); # two elements