SuikaWiki/View/Implementation.pm


=head1 NAME

SuikaWiki::View::Implementation --- SuikaWiki: WikiView implementation

=cut

package SuikaWiki::View::Implementation;
use strict;
our $VERSION = do{my @r=(q$Revision: 1.6 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
our @CommonViewDefs;

=head1 METHODS

=over 4

=item $v = SuikaWiki::View->new

Constructs new instance of WikiView implementation

=cut

sub new ($%) {
  my $class = shift;
  my $self = bless {@_, definition => {}}, $class;
  
  $self;
}

sub select ($$$) {
  my ($self, $mode, $opt) = @_;
  my $views = $self->{definition}->{$mode} || [];
  my @views;
  VIEW: for my $view (@$views) {
    my $point = 0;
    COND: for (keys %{$view->{condition}}) {
      next if $_ eq 'mode';
      if (ref ($view->{condition}->{$_}) eq 'ARRAY') {
        for my $item (@{$view->{condition}->{$_}}) {
          if ($item eq $opt->{condition}->{$_}) {
            $point++;
            next COND;
          }
        }
        next VIEW; # no match
      } elsif ($opt->{condition}->{$_} eq $view->{condition}->{$_}) {
        $point++;
      } else {
        next VIEW; # no match
      }
    }
    $views[$point] ||= [];
    push @{$views[$point]}, $view;
  }
  
  for (reverse 0..$#views) {
    for my $view (@{$views[$_]||[]}) {
      return $view if !$view->{check} || &{$view->{check}} ($self, $opt);
    }
  }
  
  if ($mode ne '#default') { 
    return $self->select ('#default', $opt);
  } else {
    return undef;
  }
}

sub instantiate ($$$) {
  my ($self, $mode, $opt) = @_;
  my $view = $self->select ($mode, $opt) or return undef;
  unless (ref $view->{object}) {
    if ($view->{object_class}) {
      $view->{object} = $view->{object_class}->new (view => $self, 
                                                    viewdef => $view, 
                                                    opt => $opt);
    } else {
      $view->{object} = &{$view->{object_init}} ($self, $opt, $view);
    }
  }
  $view->{object}->{viewdef} = $view;
  return $view->{object};
}

                 
sub register_mode ($$$) {
  my ($self, $mode, $view) = @_;
  $view->{condition}->{mode} ||= $mode;
  $self->{definition}->{$mode} ||= [];
  push @{$self->{definition}->{$mode}}, $view;
}

                   
sub init_db ($$) {
  my ($self, $opt) = @_;
  $self->{wiki}->init_db;
}

sub register_common_modes ($) {
  my ($self) = @_;
  for (@CommonViewDefs) {
    $self->register_mode ($_->{condition}->{mode} => $_);
  }
}

our %TemplateFragment;
sub assemble_template ($$) {
  my ($self, $name) = @_;
  $name =~ tr/-/_/;
  my $template = join '',
    map {$_->{Main}}
    sort {$a->{Order} <=> $b->{Order}}
    @{$TemplateFragment{$name}||[]};
  $template;
}

sub exit ($) {
  my $self = shift;
  delete $self->{wiki};
  delete $self->{definition};
  $self->{exited} = 1;
  1;
}

sub DESTROY ($) {
  my $self = shift;
  $self->exit unless $self->{exited};
}

=item $v->{definition}->{ $mode } = [{ condition => {mode => $mode,...}, ... },...]

=item $v->{wiki}

Instance of wiki implementation

=back

=cut

package SuikaWiki::View::template;

sub new ($%) {
  my $class = shift;
  bless {@_}, $class;
}

sub main ($$) {
  my ($self, $opt) = @_;
  my $opt2 = {};
  $self->main_pre ($opt, $opt2)
    &&
  1
    &&
  $self->main_post ($opt, $opt2);
}

sub main_pre ($$$) {
  1;
}

sub main_post ($$$) {
  1;
}

package SuikaWiki::View::Implementation::error;
require Message::Util::Error;
our @ISA = 'Message::Util::Error';

sub ___error () {+{
  ERROR_REPORTED => {
    
  },
}}

=head1 LICENSE

Copyright 2003 Wakaba <[email protected]>

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=cut

1; # $Date: 2003/12/01 07:42:21 $
1	wakaba	1.1
2			=head1 NAME
3
4			SuikaWiki::View::Implementation --- SuikaWiki: WikiView implementation
5
6			=cut
7
8			package SuikaWiki::View::Implementation;
9			use strict;
10	wakaba	1.7	our $VERSION = do{my @r=(q$Revision: 1.6 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
11	wakaba	1.1	our @CommonViewDefs;
12
13			=head1 METHODS
14
15			=over 4
16
17			=item $v = SuikaWiki::View->new
18
19			Constructs new instance of WikiView implementation
20
21			=cut
22
23			sub new ($%) {
24			my $class = shift;
25			my $self = bless {@_, definition => {}}, $class;
26
27			$self;
28			}
29
30			sub select ($$$) {
31			my ($self, $mode, $opt) = @_;
32			my $views = $self->{definition}->{$mode} \|\| [];
33			my @views;
34			VIEW: for my $view (@$views) {
35			my $point = 0;
36	wakaba	1.2	COND: for (keys %{$view->{condition}}) {
37	wakaba	1.1	next if $_ eq 'mode';
38	wakaba	1.2	if (ref ($view->{condition}->{$_}) eq 'ARRAY') {
39			for my $item (@{$view->{condition}->{$_}}) {
40			if ($item eq $opt->{condition}->{$_}) {
41			$point++;
42			next COND;
43			}
44			}
45			next VIEW; # no match
46			} elsif ($opt->{condition}->{$_} eq $view->{condition}->{$_}) {
47	wakaba	1.1	$point++;
48			} else {
49	wakaba	1.2	next VIEW; # no match
50	wakaba	1.1	}
51			}
52			$views[$point] \|\|= [];
53			push @{$views[$point]}, $view;
54			}
55
56			for (reverse 0..$#views) {
57			for my $view (@{$views[$_]\|\|[]}) {
58			return $view if !$view->{check} \|\| &{$view->{check}} ($self, $opt);
59			}
60			}
61
62			if ($mode ne '#default') {
63			return $self->select ('#default', $opt);
64			} else {
65			return undef;
66			}
67			}
68
69			sub instantiate ($$$) {
70			my ($self, $mode, $opt) = @_;
71			my $view = $self->select ($mode, $opt) or return undef;
72			unless (ref $view->{object}) {
73			if ($view->{object_class}) {
74			$view->{object} = $view->{object_class}->new (view => $self,
75			viewdef => $view,
76			opt => $opt);
77			} else {
78			$view->{object} = &{$view->{object_init}} ($self, $opt, $view);
79			}
80			}
81			$view->{object}->{viewdef} = $view;
82			return $view->{object};
83			}
84
85
86			sub register_mode ($$$) {
87			my ($self, $mode, $view) = @_;
88			$view->{condition}->{mode} \|\|= $mode;
89			$self->{definition}->{$mode} \|\|= [];
90			push @{$self->{definition}->{$mode}}, $view;
91			}
92
93
94			sub init_db ($$) {
95			my ($self, $opt) = @_;
96			$self->{wiki}->init_db;
97			}
98
99			sub register_common_modes ($) {
100			my ($self) = @_;
101			for (@CommonViewDefs) {
102			$self->register_mode ($_->{condition}->{mode} => $_);
103			}
104			}
105
106	wakaba	1.2	our %TemplateFragment;
107			sub assemble_template ($$) {
108			my ($self, $name) = @_;
109	wakaba	1.4	$name =~ tr/-/_/;
110	wakaba	1.5	my $template = join '',
111	wakaba	1.2	map {$_->{Main}}
112			sort {$a->{Order} <=> $b->{Order}}
113	wakaba	1.3	@{$TemplateFragment{$name}\|\|[]};
114	wakaba	1.5	$template;
115	wakaba	1.2	}
116
117	wakaba	1.7	sub exit ($) {
118			my $self = shift;
119			delete $self->{wiki};
120			delete $self->{definition};
121			$self->{exited} = 1;
122			1;
123			}
124
125			sub DESTROY ($) {
126			my $self = shift;
127			$self->exit unless $self->{exited};
128			}
129
130	wakaba	1.1	=item $v->{definition}->{ $mode } = [{ condition => {mode => $mode,...}, ... },...]
131
132			=item $v->{wiki}
133
134			Instance of wiki implementation
135
136			=back
137
138			=cut
139
140			package SuikaWiki::View::template;
141
142			sub new ($%) {
143			my $class = shift;
144			bless {@_}, $class;
145			}
146
147			sub main ($$) {
148			my ($self, $opt) = @_;
149	wakaba	1.2	my $opt2 = {};
150			$self->main_pre ($opt, $opt2)
151			&&
152			1
153			&&
154			$self->main_post ($opt, $opt2);
155			}
156
157			sub main_pre ($$$) {
158			1;
159			}
160
161			sub main_post ($$$) {
162			1;
163	wakaba	1.1	}
164
165	wakaba	1.6	package SuikaWiki::View::Implementation::error;
166			require Message::Util::Error;
167			our @ISA = 'Message::Util::Error';
168
169			sub ___error () {+{
170			ERROR_REPORTED => {
171
172			},
173			}}
174
175	wakaba	1.1	=head1 LICENSE
176
177			Copyright 2003 Wakaba <[email protected]>
178
179			This program is free software; you can redistribute it and/or
180			modify it under the same terms as Perl itself.
181
182			=cut
183
184	wakaba	1.7	1; # $Date: 2003/12/01 07:42:21 $