Mercurial > repos > mahtabm > ensembl
comparison variant_effect_predictor/Bio/EnsEMBL/Utils/ConfigRegistry.pm @ 0:1f6dce3d34e0
Uploaded
author | mahtabm |
---|---|
date | Thu, 11 Apr 2013 02:01:53 -0400 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:1f6dce3d34e0 |
---|---|
1 =head1 LICENSE | |
2 | |
3 Copyright (c) 1999-2012 The European Bioinformatics Institute and | |
4 Genome Research Limited. All rights reserved. | |
5 | |
6 This software is distributed under a modified Apache license. | |
7 For license details, please see | |
8 | |
9 http://www.ensembl.org/info/about/code_licence.html | |
10 | |
11 =head1 CONTACT | |
12 | |
13 Please email comments or questions to the public Ensembl | |
14 developers list at <dev@ensembl.org>. | |
15 | |
16 Questions may also be sent to the Ensembl help desk at | |
17 <helpdesk@ensembl.org>. | |
18 | |
19 =cut | |
20 | |
21 =head1 NAME | |
22 | |
23 Bio::EnsEMBL::Utils::ConfigRegistry; | |
24 | |
25 =head1 SYNOPSIS | |
26 | |
27 | |
28 Bio::EnsEMBL::Utils::ConfigRegistry->load_core($dba); | |
29 | |
30 | |
31 =head1 DESCRIPTION | |
32 | |
33 The ConfigRegistry will "Register" a set of adaptors based on the type | |
34 of database that is being loaded. | |
35 | |
36 =head1 METHODS | |
37 | |
38 =cut | |
39 | |
40 package Bio::EnsEMBL::Utils::ConfigRegistry; | |
41 | |
42 use strict; | |
43 use warnings; | |
44 | |
45 use Bio::EnsEMBL::Registry; | |
46 my $reg = "Bio::EnsEMBL::Registry"; | |
47 use Bio::EnsEMBL::Utils::Argument qw(rearrange); | |
48 use Bio::EnsEMBL::DBSQL::DBConnection; | |
49 use Bio::EnsEMBL::DBSQL::DBAdaptor; | |
50 | |
51 use Bio::EnsEMBL::Utils::Exception qw(warning throw deprecate stack_trace_dump); | |
52 | |
53 | |
54 | |
55 sub gen_load { | |
56 my ($dba) = @_; | |
57 my $config_sub; | |
58 | |
59 # At some point we hope to set the group in the DBadaptor, hence this | |
60 # long check etc. should be simpler. | |
61 | |
62 if ( $dba->isa('Bio::EnsEMBL::Compara::DBSQL::DBAdaptor') ) { | |
63 if ( !defined( $dba->group() ) ) { | |
64 $dba->group('compara'); | |
65 } | |
66 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_compara; | |
67 } elsif ( $dba->isa('Bio::EnsEMBL::Lite::DBAdaptor') ) { | |
68 if ( !defined( $dba->group() ) ) { | |
69 $dba->group('lite'); | |
70 } | |
71 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_lite; | |
72 } elsif ( $dba->isa('Bio::EnsEMBL::External::BlastAdaptor') ) { | |
73 if ( !defined( $dba->group() ) ) { | |
74 $dba->group('blast'); | |
75 } | |
76 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_blast; | |
77 } elsif ( $dba->isa('Bio::EnsEMBL::ExternalData::SNPSQL::DBAdaptor') ) | |
78 { | |
79 if ( !defined( $dba->group() ) ) { | |
80 $dba->group('SNP'); | |
81 } | |
82 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_SNP; | |
83 } elsif ( $dba->isa('Bio::EnsEMBL::Pipeline::DBSQL::DBAdaptor') ) { | |
84 if ( !defined( $dba->group() ) ) { | |
85 $dba->group('pipeline'); | |
86 } | |
87 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_pipeline; | |
88 } elsif ( $dba->isa('Bio::EnsEMBL::Hive::DBSQL::DBAdaptor') ) { | |
89 if ( !defined( $dba->group() ) ) { | |
90 $dba->group('hive'); | |
91 } | |
92 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_hive; | |
93 } elsif ( | |
94 $dba->isa('Bio::EnsEMBL::ExternalData::Haplotype::DBAdaptor') ) | |
95 { | |
96 if ( !defined( $dba->group() ) ) { | |
97 $dba->group('haplotype'); | |
98 } | |
99 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_haplotype; | |
100 } elsif ( $dba->isa('Bio::EnsEMBL::Variation::DBSQL::DBAdaptor') ) { | |
101 if ( !defined( $dba->group() ) ) { | |
102 $dba->group('variation'); | |
103 } | |
104 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_variation; | |
105 } elsif ( $dba->isa('Bio::EnsEMBL::Funcgen::DBSQL::DBAdaptor') ) { | |
106 if ( !defined( $dba->group() ) ) { | |
107 $dba->group('funcgen'); | |
108 } | |
109 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_funcgen; | |
110 } elsif ( $dba->isa('Bio::Ensembl::DBSQL::OntologyTermAdaptor') ) { | |
111 if ( !defined( $dba->group() ) ) { | |
112 $dba->group('ontology'); | |
113 } | |
114 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_ontology; | |
115 } elsif ( $dba->isa('Bio::EnsEMBL::DBSQL::DBAdaptor') ) { | |
116 #vega uses the core DBAdaptor so test if vega is in the dbname | |
117 if ( !defined( $dba->group() ) ) { | |
118 $dba->group('core'); | |
119 } | |
120 | |
121 if ( $dba->group eq "estgene" ) { | |
122 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_estgene; | |
123 } elsif ( $dba->group eq "otherfeatures" ) { | |
124 $config_sub = | |
125 \&Bio::EnsEMBL::Utils::ConfigRegistry::load_otherfeatures; | |
126 } elsif ( $dba->group eq 'vega' || $dba->group eq 'vega_update' ) { | |
127 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_vega; | |
128 } else { | |
129 $config_sub = \&Bio::EnsEMBL::Utils::ConfigRegistry::load_core; | |
130 } | |
131 | |
132 } else { | |
133 # none standard DBA adaptor | |
134 if ( !defined( $dba->group() ) ) { | |
135 $dba->group('none_standard'); | |
136 } | |
137 $config_sub = | |
138 \&Bio::EnsEMBL::Utils::ConfigRegistry::load_and_attach_dnadb_to_core; | |
139 # throw("Unknown DBAdaptor type $dba\n"); | |
140 } | |
141 | |
142 # return if the connection and species, group are the same | |
143 | |
144 if ( defined( $dba->species ) ) { | |
145 my $db_reg = $reg->get_DBAdaptor( $dba->species, $dba->group, 1 ); | |
146 if ( defined($db_reg) ) { | |
147 if ( $dba->dbc->equals( $db_reg->dbc ) ) { return $db_reg } | |
148 else { | |
149 my $msg = | |
150 sprintf( 'WARN: Species (%s) and group (%s) ' | |
151 . 'same for two seperate databases', | |
152 $dba->species(), $dba->group() ); | |
153 | |
154 warn "${msg}\nModify species name for one of these\n"; | |
155 $dba->species( | |
156 find_unique_species( $dba->species, $dba->group ) ); | |
157 } | |
158 } | |
159 } else { # no species | |
160 | |
161 my @db_reg = | |
162 @{ $reg->get_all_DBAdaptors_by_connection( $dba->dbc ) }; | |
163 | |
164 foreach my $db_adaptor (@db_reg) { | |
165 if ( $db_adaptor->group eq $dba->group ) { | |
166 # found same db connection and group | |
167 return $db_adaptor; | |
168 } | |
169 } | |
170 | |
171 $dba->species( find_unique_species( "DEFAULT", $dba->group ) ); | |
172 if ( $dba->species ne "DEFAULT" ) { | |
173 warn "WARN: For multiple species " | |
174 . "use species attribute in DBAdaptor->new()\n"; | |
175 } | |
176 } | |
177 | |
178 Bio::EnsEMBL::Registry->add_DBAdaptor( $dba->species(), $dba->group(), | |
179 $dba ); | |
180 | |
181 #call the loading subroutine. (add the adaptors to the DBAdaptor) | |
182 &{$config_sub}($dba); | |
183 | |
184 return $dba; | |
185 } ## end sub gen_load | |
186 | |
187 | |
188 | |
189 sub find_unique_species { | |
190 my ( $species, $group ) = @_; | |
191 | |
192 $reg->add_alias( $species, $species ); | |
193 | |
194 my $i = 0; | |
195 my $free = 0; | |
196 | |
197 while ( !$free ) { | |
198 if ( $i == 0 ) { | |
199 if ( !defined( $reg->get_DBAdaptor( $species, $group ) ) ) { | |
200 $free = 1; | |
201 $i = ""; | |
202 } else { | |
203 $i = 1; | |
204 } | |
205 } else { | |
206 # set needed self alias | |
207 $reg->add_alias( $species . $i, $species . $i ); | |
208 | |
209 if ( !defined( $reg->get_DBAdaptor( $species . $i, $group ) ) ) { | |
210 $free = 1; | |
211 } else { | |
212 $i++; | |
213 } | |
214 } | |
215 } | |
216 | |
217 $species .= $i; | |
218 return ($species); | |
219 } ## end sub find_unique_species | |
220 | |
221 | |
222 | |
223 sub load_adaptors { | |
224 my ($dba) = @_; | |
225 | |
226 my %pairs = %{ $dba->get_available_adaptors() }; | |
227 | |
228 while ( my ( $key, $value ) = each(%pairs) ) { | |
229 Bio::EnsEMBL::Registry->add_adaptor( $dba->species(), $dba->group(), | |
230 $key, $value ); | |
231 } | |
232 } | |
233 | |
234 sub load_and_attach_dnadb_to_core { | |
235 my ($dba) = @_; | |
236 | |
237 load_adaptors($dba); | |
238 $reg->add_DNAAdaptor( $dba->species(), $dba->group(), $dba->species(), | |
239 'core' ); | |
240 } | |
241 | |
242 | |
243 =head2 load_core | |
244 Arg [1] : DBAdaptor with DBConnection already attached | |
245 Returntype : DBAdaptor | |
246 Exceptions : none | |
247 =cut | |
248 sub load_core { load_adaptors(@_) } | |
249 | |
250 | |
251 # | |
252 # 1) core. no need to add dnadb | |
253 # 2) not core add dnadb | |
254 # 3) | |
255 # | |
256 | |
257 =head2 load_compara | |
258 Arg [1] : DBAdaptor with DBConnection already attached | |
259 Returntype : DBAdaptor | |
260 Exceptions : none | |
261 =cut | |
262 sub load_compara { load_adaptors(@_) } | |
263 | |
264 =head2 load_hive | |
265 Arg [1] : DBAdaptor with DBConnection already attached | |
266 Returntype : DBAdaptor | |
267 Exceptions : none | |
268 =cut | |
269 sub load_hive { load_adaptors(@_) } | |
270 | |
271 =head2 load_pipeline | |
272 Arg [1] : DBAdaptor with DBConnection already attached | |
273 Returntype : DBAdaptor | |
274 Exceptions : none | |
275 =cut | |
276 sub load_pipeline { load_adaptors(@_) } | |
277 | |
278 =head2 load_SNP | |
279 Arg [1] : DBAdaptor with DBConnection already attached | |
280 Returntype : DBAdaptor | |
281 Exceptions : none | |
282 =cut | |
283 sub load_SNP { load_adaptors(@_) } | |
284 | |
285 sub load_haplotype { load_adaptors(@_) } | |
286 | |
287 sub load_ontology { load_adaptors(@_) } | |
288 | |
289 | |
290 # these that need to attach to the core to get the sequence data | |
291 | |
292 sub load_estgene { load_and_attach_dnadb_to_core(@_) } | |
293 | |
294 sub load_variation { load_and_attach_dnadb_to_core(@_) } | |
295 | |
296 sub load_funcgen { load_and_attach_dnadb_to_core(@_) } | |
297 | |
298 =head2 load_otherfeatures | |
299 Arg [1] : DBAdaptor with DBConnection alredy attached | |
300 Returntype : DBAdaptor | |
301 Exceptions : none | |
302 | |
303 =cut | |
304 sub load_otherfeatures { load_and_attach_dnadb_to_core(@_) } | |
305 | |
306 =head2 load_vega | |
307 Arg [1] : DBAdaptor with DBConnection already attached | |
308 Returntype : DBAdaptor | |
309 Exceptions : none | |
310 =cut | |
311 sub load_vega { load_and_attach_dnadb_to_core(@_) } | |
312 | |
313 | |
314 sub add_alias { | |
315 my ( $class, @args ) = @_; | |
316 | |
317 my ( $species, $aliases ) = rearrange( [qw(SPECIES ALIAS)], @args ); | |
318 | |
319 # Make sure it exists itself | |
320 Bio::EnsEMBL::Registry->add_alias( $species, $species ); | |
321 | |
322 if ( defined($aliases) ) { | |
323 foreach my $ali (@$aliases) { | |
324 Bio::EnsEMBL::Registry->add_alias( $species, $ali ); | |
325 } | |
326 } | |
327 } | |
328 | |
329 # | |
330 # overwrite/load new types. Done this way to enable no changes to CVS for | |
331 # external users. External users should add there own "GROUPS" in the file | |
332 # User_defined_load. | |
333 # | |
334 | |
335 eval{ require Bio::EnsEMBL::Utils::User_defined_load }; | |
336 | |
337 1; |