lib/SWE/DB.pm

package SWE::DB;
use strict;
use warnings;

sub new ($) {
  my $self = bless {}, shift;
  return $self;
} # new

sub db_dir_name : lvalue { $_[0]->{db_dir_name} }
sub global_lock_dir_name : lvalue { $_[0]->{global_lock_dir_name} }
sub id_dir_name : lvalue { $_[0]->{id_dir_name} }
sub name_dir_name : lvalue { $_[0]->{name_dir_name} }

sub graph_dir_name ($) {
  my $self = shift;
  return $self->db_dir_name . q[graph/];
} # graph_dir_name

sub global_dir_name ($) {
  my $self = shift;
  return $self->db_dir_name . q[global/];
} # global_dir_name

sub sw3db_dir_name : lvalue { $_[0]->{sw3db_dir_name} }

sub global_prop ($) {
  my $self = shift;

  return $self->{global_prop} ||= do {
    require SWE::DB::NamedText;
    my $global_prop_db = SWE::DB::NamedText->new;
    $global_prop_db->{root_directory_name} = $self->global_dir_name;
    $global_prop_db->{leaf_suffix} = '.dat';
    $global_prop_db;
  };
} # global_prop

sub name_inverted_index ($) {
  my $self = shift;
  
  return $self->{name_inverted_index} ||= do {
    require SWE::DB::HashedIndex;
    my $names_index_db = SWE::DB::HashedIndex->new;
    $names_index_db->{root_directory_name} = $self->name_dir_name;
    $names_index_db;
  };
} # name_inverted_index

sub name_history ($) {
  my $self = shift;

  return $self->{name_history} ||= do {
    require SWE::DB::HashedHistory;
    my $names_history_db = SWE::DB::HashedHistory->new;
    $names_history_db->{root_directory_name} = $self->name_dir_name;
    $names_history_db;
  };
} # name_history

sub id ($) {
  my $self = shift;
  
  return $self->{id} ||= do {
    require SWE::DB::IDGenerator;
    my $idgen = SWE::DB::IDGenerator->new;
    $idgen->{file_name} = $self->db_dir_name . 'nextid.dat';
    $idgen->{lock_file_name} = $self->global_lock_dir_name . 'nextid.lock';
    $idgen;
  };
} # id

sub id_tfidf ($) {
  my $self = shift;

  return $self->{id_tfidf} ||= do {
    require SWE::DB::IDText;
    my $tfidf_db = SWE::DB::IDText->new;
    $tfidf_db->{root_directory_name} = $self->id_dir_name;
    $tfidf_db->{leaf_suffix} = '.tfidf';
    $tfidf_db;
  };
} # id_tfidf

sub id_history ($) {
  my $self = shift;
  
  return $self->{id_history} ||= do {
    require SWE::DB::IDHistory;
    my $id_history_db = SWE::DB::IDHistory->new;
    $id_history_db->{root_directory_name} = $self->id_dir_name;
    $id_history_db;
  };
} # id_history

sub id_html_cache ($) {
  my $self = shift;
  
  return $self->{id_html_cache} ||= do {
    require SWE::DB::IDDOM;
    my $html_cache_db = SWE::DB::IDDOM->new;
    $html_cache_db->{root_directory_name} = $self->id_dir_name;
    $html_cache_db->{leaf_suffix} = '.htmlcache';
    $html_cache_db;
  };
} # id_html_cache

sub graph_prop ($) {
  my $self = shift;

  return $self->{graph_prop} ||= do {
    require SWE::DB::IDProps;
    my $graph_prop_db = SWE::DB::IDProps->new;
    $graph_prop_db->{root_directory_name} = $self->graph_dir_name;
    $graph_prop_db->{leaf_suffix} = '.node';
    $graph_prop_db;
  };
} # graph_prop

sub vc ($) {
  my $self = shift;

  require SWE::DB::VersionControl;
  return SWE::DB::VersionControl->new;
} # vc

1;
1	package SWE::DB;
2	use strict;
3	use warnings;
4
5	sub new ($) {
6	my $self = bless {}, shift;
7	return $self;
8	} # new
9
10	sub db_dir_name : lvalue { $_[0]->{db_dir_name} }
11	sub global_lock_dir_name : lvalue { $_[0]->{global_lock_dir_name} }
12	sub id_dir_name : lvalue { $_[0]->{id_dir_name} }
13	sub name_dir_name : lvalue { $_[0]->{name_dir_name} }
14
15	sub graph_dir_name ($) {
16	my $self = shift;
17	return $self->db_dir_name . q[graph/];
18	} # graph_dir_name
19
20	sub global_dir_name ($) {
21	my $self = shift;
22	return $self->db_dir_name . q[global/];
23	} # global_dir_name
24
25	sub sw3db_dir_name : lvalue { $_[0]->{sw3db_dir_name} }
26
27	sub global_prop ($) {
28	my $self = shift;
29
30	return $self->{global_prop} \|\|= do {
31	require SWE::DB::NamedText;
32	my $global_prop_db = SWE::DB::NamedText->new;
33	$global_prop_db->{root_directory_name} = $self->global_dir_name;
34	$global_prop_db->{leaf_suffix} = '.dat';
35	$global_prop_db;
36	};
37	} # global_prop
38
39	sub name_inverted_index ($) {
40	my $self = shift;
41
42	return $self->{name_inverted_index} \|\|= do {
43	require SWE::DB::HashedIndex;
44	my $names_index_db = SWE::DB::HashedIndex->new;
45	$names_index_db->{root_directory_name} = $self->name_dir_name;
46	$names_index_db;
47	};
48	} # name_inverted_index
49
50	sub name_history ($) {
51	my $self = shift;
52
53	return $self->{name_history} \|\|= do {
54	require SWE::DB::HashedHistory;
55	my $names_history_db = SWE::DB::HashedHistory->new;
56	$names_history_db->{root_directory_name} = $self->name_dir_name;
57	$names_history_db;
58	};
59	} # name_history
60
61	sub id ($) {
62	my $self = shift;
63
64	return $self->{id} \|\|= do {
65	require SWE::DB::IDGenerator;
66	my $idgen = SWE::DB::IDGenerator->new;
67	$idgen->{file_name} = $self->db_dir_name . 'nextid.dat';
68	$idgen->{lock_file_name} = $self->global_lock_dir_name . 'nextid.lock';
69	$idgen;
70	};
71	} # id
72
73	sub id_tfidf ($) {
74	my $self = shift;
75
76	return $self->{id_tfidf} \|\|= do {
77	require SWE::DB::IDText;
78	my $tfidf_db = SWE::DB::IDText->new;
79	$tfidf_db->{root_directory_name} = $self->id_dir_name;
80	$tfidf_db->{leaf_suffix} = '.tfidf';
81	$tfidf_db;
82	};
83	} # id_tfidf
84
85	sub id_history ($) {
86	my $self = shift;
87
88	return $self->{id_history} \|\|= do {
89	require SWE::DB::IDHistory;
90	my $id_history_db = SWE::DB::IDHistory->new;
91	$id_history_db->{root_directory_name} = $self->id_dir_name;
92	$id_history_db;
93	};
94	} # id_history
95
96	sub id_html_cache ($) {
97	my $self = shift;
98
99	return $self->{id_html_cache} \|\|= do {
100	require SWE::DB::IDDOM;
101	my $html_cache_db = SWE::DB::IDDOM->new;
102	$html_cache_db->{root_directory_name} = $self->id_dir_name;
103	$html_cache_db->{leaf_suffix} = '.htmlcache';
104	$html_cache_db;
105	};
106	} # id_html_cache
107
108	sub graph_prop ($) {
109	my $self = shift;
110
111	return $self->{graph_prop} \|\|= do {
112	require SWE::DB::IDProps;
113	my $graph_prop_db = SWE::DB::IDProps->new;
114	$graph_prop_db->{root_directory_name} = $self->graph_dir_name;
115	$graph_prop_db->{leaf_suffix} = '.node';
116	$graph_prop_db;
117	};
118	} # graph_prop
119
120	sub vc ($) {
121	my $self = shift;
122
123	require SWE::DB::VersionControl;
124	return SWE::DB::VersionControl->new;
125	} # vc
126
127	1;