view release on metacpan or  search on metacpan

Jcode.pm  view on Meta::CPAN

#######################################

sub new{
    my $class = shift;
    my $self  = {};
    bless $self => $class;
    defined $_[0] or $_[0] = '';
    $self->set(@_);
}

sub set{

 view release on metacpan or  search on metacpan

lib/KSx/IndexManager.pm  view on Meta::CPAN

  $arg ||= {};
  $class->call_plugins(before_new => $arg);
  unless ($arg->{schema} ||= $class->schema_class) {
    Carp::croak "schema is mandatory for $class->new";
  }
  my $self = bless $arg => $class;
  $self->call_self_plugins('after_new');
  return $self;
}

sub path {

 view release on metacpan or  search on metacpan

lib/KeyedMutex/Memcached.pm  view on Meta::CPAN

    croak('cache value should be object and appeared add and delete methods.')
      unless ( $args->{cache}
        && UNIVERSAL::can( $args->{cache}, 'add' )
        && UNIVERSAL::can( $args->{cache}, 'delete' ) );

    bless $args => $class;
}

sub lock {
    my ( $self, $key, $use_raii ) = @_;

 view release on metacpan or  search on metacpan

lib/LV/Backend/Tie.pm  view on Meta::CPAN

		my $caller = (caller(2))[3];
		$get ||= sub { require Carp; Carp::croak("$caller is writeonly") };
		$set ||= sub { require Carp; Carp::croak("$caller is readonly") };
	}
	
	bless [$get, $set] => $class;
}

sub FETCH
{
	&{shift->[0]};

 view release on metacpan or  search on metacpan

lib/LaTeX/Easy/Templates.pm  view on Meta::CPAN

			'log' => {
				'logger_object' => undef,
			},
		},
	};
	bless $self => $class;

	# NOTE: up until now we do not have a logger, we either use STDERR or die()

	# do we have a logger specified in params?
	if( exists($params->{'logfile'}) && defined($params->{'logfile'}) ){

 view release on metacpan or  search on metacpan

lib/Sub/HandlesVia/Toolkit/SubAccessorSmall.pm  view on Meta::CPAN

our @ISA = 'Sub::HandlesVia::Toolkit';
$ISA[0]->VERSION( '0.025' );

sub new {
	my $class = shift;
	bless { @_ } => $class;
}

sub _attr {
	shift->{attr};
}

 view release on metacpan or  search on metacpan

t/Lowest.pm  view on Meta::CPAN

#

sub new {
    my $class = shift;

    bless {} => $class;
}

sub key1 {
    my $self = shift;
    $$self {key1};

 view release on metacpan or  search on metacpan

lib/Lingua/Boolean/Tiny.pm  view on Meta::CPAN

	our $VERSION   = '0.008';
	
	sub new
	{
		my $class = shift;
		bless [ grep defined, map "Lingua::Boolean::Tiny"->new_strict($_), @_ ] => $class;
	}
	
	sub boolean
	{
		my $self = shift;

 view release on metacpan or  search on metacpan

lib/Lingua/FreeLing3/ChartParser.pm  view on Meta::CPAN

        carp "Cannot find chart tagger data file. Tried [$file]\n";
        return undef;
    }

    my $self = $class->SUPER::new($file);
    return bless $self => $class
}

=head2 C<parse>

Alias to C<analyze>.

 view release on metacpan or  search on metacpan

lib/Lingua/Han/Cantonese.pm  view on Meta::CPAN

		my ($uni, $ct) = split(/\s+/);
		$ct{$uni} = $ct;
	}
	close(FH);
	$self->{'ct'} = \%ct;
	return bless $self => $class;
}

sub han2Cantonese {
	my ($self, $hanzi) = @_;

 view release on metacpan or  search on metacpan

lib/Lingua/Han/PinYin.pm  view on Meta::CPAN

    }
    close($fh);

    $args{'py'} = \%py;

    return bless \%args => $class;
}

sub han2pinyin1 {
    my ($self, $word) = @_;
    my $code = Unihan_value($word);

 view release on metacpan or  search on metacpan

lib/Lingua/Han/Stroke.pm  view on Meta::CPAN

		my ($uni, $st) = split(/\s+/);
		$st{$uni} = $st;
	}
	close(FH);
	$self->{'st'} = \%st;
	return bless $self => $class;
}

sub stroke {
	my ($self, $hanzi) = @_;
	my $code = Unihan_value($hanzi); # got the Unihan field 1

 view release on metacpan or  search on metacpan

lib/Lingua/Identifier.pm  view on Meta::CPAN

=cut

sub new {

    return bless { languages => $classes }, __PACKAGE__;
}

=head2 C<languages>

Returns the list of codes for the active languages.

 view release on metacpan or  search on metacpan

lib/Lingua/Identify/CLD.pm  view on Meta::CPAN

=cut

sub new {
    my ($class, %options) = @_;
    my $self = {%options};
    return bless $self => $class # amen
}

=head2 identify

Receives a string, returns a language name. Following the text a set

 view release on metacpan or  search on metacpan

lib/Lingua/LinkParser/FindPath.pm  view on Meta::CPAN

    my %arg = @_;
    if( ! ref $arg{parser} ){
        require Lingua::LinkParser;
        $arg{parser} = Lingua::LinkParser->new;
    }
    bless { parser => $arg{parser}, sentence => undef } => $class;
}

sub sentence {
    my $self = shift;
    $self->{sentence} = ref $_[0] ? shift : $self->{parser}->create_sentence(shift);

 view release on metacpan or  search on metacpan

lib/Lingua/NATools.pm  view on Meta::CPAN

        $self->{conf}->param("noLanguageIdentification" => 1);
    }

    $self->{conf}->write($self->{conf}->param("cfg"));

    return bless $self => $class
}



sub load {

 view release on metacpan or  search on metacpan

lib/Lingua/TFIDF/WordSegmenter/JA/MeCab.pm  view on Meta::CPAN

  args
    my $class => 'ClassName',
    my $mecab => +{ isa => 'Text::MeCab', optional => 1 };

  $mecab = Text::MeCab->new unless defined $mecab;
  bless +{ mecab => $mecab } => $class;
}

sub mecab { $_[0]->{mecab} }

sub segment {

 view release on metacpan or  search on metacpan

lib/Lingua/TreeTagger/Installer.pm  view on Meta::CPAN

    }

    $self->{verbose}++ if $ops{verbose};
    $self->{force}++   if $ops{force};

    return bless $self => $class
}

sub verbose {
    my ($self, @message) = @_;
    if ($self->{verbose}) {

 view release on metacpan or  search on metacpan

lib/Linux/Input.pm  view on Meta::CPAN

# instaniate a new input device
sub new {
  my $class    = shift;
  my $filename = shift;
  my $self     = { };
  bless ($self => $class);

  $self->{fh} = IO::File->new("< $filename");
  die($!) unless ($self->{fh});

  return $self;

 view release on metacpan or  search on metacpan

lib/List/Gen.pm  view on Meta::CPAN

        List::Gen::DwimCode;
        my %save;
        sub new {
            my ($class, $gen) = @_;
            my $code = \&$gen;
            bless $code => $class;
            $save{$code} = $gen;
            $code
        }
        sub DESTROY {
            delete $save{$_[0]}

 view release on metacpan or  search on metacpan

lib/Locale/Intl.pm  view on Meta::CPAN

        {
            warn( "No error object provided and no previous error set either! It seems the previous method call returned a simple undef" );
        }
        else
        {
            $err = ( defined( $class ) ? bless( $error => $class ) : $error );
            $err->code( $code ) if( defined( $code ) );
        }
    }
    elsif( defined( $err ) && 
           Scalar::Util::blessed( $err ) && 
           ( scalar( @_ ) == 1 || 
             ( scalar( @_ ) == 2 && defined( $class ) ) 
           ) )
    {
        $self->{error} = ${ $pack . '::ERROR' } = ( defined( $class ) ? bless( $err => $class ) : $err );
        $self->{error}->code( $code ) if( defined( $code ) && $self->{error}->can( 'code' ) );
        
        if( $self->{fatal} || ( defined( ${"${class}\::FATAL_EXCEPTIONS"} ) && ${"${class}\::FATAL_EXCEPTIONS"} ) )
        {
            die( $self->{error} );

 view release on metacpan or  search on metacpan

lib/Locale/Unicode.pm  view on Meta::CPAN

        {
            warn( "No error object provided and no previous error set either! It seems the previous method call returned a simple undef" );
        }
        else
        {
            $err = ( defined( $class ) ? bless( $error => $class ) : $error );
            $err->code( $code ) if( defined( $code ) );
        }
    }
    elsif( defined( $err ) && 
           Scalar::Util::blessed( $err ) && 
           ( scalar( @_ ) == 1 || 
             ( scalar( @_ ) == 2 && defined( $class ) ) 
           ) )
    {
        $self->{error} = ${ $pack . '::ERROR' } = ( defined( $class ) ? bless( $err => $class ) : $err );
        $self->{error}->code( $code ) if( defined( $code ) && $self->{error}->can( 'code' ) );
        
        if( $self->{fatal} || ( defined( ${"${class}\::FATAL_EXCEPTIONS"} ) && ${"${class}\::FATAL_EXCEPTIONS"} ) )
        {
            die( $self->{error} );

 view release on metacpan or  search on metacpan

lib/Log/Dispatch/Array.pm  view on Meta::CPAN

  my ($class, %arg) = @_;
  $arg{array} ||= [];

  my $self = { array => $arg{array} };

  bless $self => $class;

  # this is our duty as a well-behaved Log::Dispatch plugin
  $self->_basic_init(%arg);

  return $self;

 view release on metacpan or  search on metacpan

lib/Log/Dispatch/Message/Passing.pm  view on Meta::CPAN

  confess("output => $output must be an object which can ->consume")
    unless blessed($output) && $output->can('consume');

  my $self = { output => $output };

  bless $self => $class;

  # this is our duty as a well-behaved Log::Dispatch plugin
  $self->_basic_init(%arg);

  return $self;

 view release on metacpan or  search on metacpan

lib/Log/Dispatch/TextTable.pm  view on Meta::CPAN

    table    => $table,
    send_to  => $arg{send_to},
    flush_if => $arg{flush_if},
  };

  bless $self => $class;

  # this is our duty as a well-behaved Log::Dispatch plugin
  $self->_basic_init(%arg);

  return $self;

 view release on metacpan or  search on metacpan

lib/Log/Dispatch/UnixSyslog.pm  view on Meta::CPAN

  my $self = {
    ident     => $arg{ident},
    facility  => scalar $const->(),
  };

  bless $self => $class;

  # this is our duty as a well-behaved Log::Dispatch plugin
  $self->_basic_init(%arg);

  # hand wringing: What if someone is re-openlog-ing after this?  Well, they

 view release on metacpan or  search on metacpan

lib/Log/Dispatchouli/Proxy.pm  view on Meta::CPAN

    debug  => $arg->{debug},
    proxy_prefix => $arg->{proxy_prefix},
    proxy_ctx    => $arg->{proxy_ctx},
  };

  bless $guts => $class;
}

sub proxy  {
  my ($self, $arg) = @_;
  $arg ||= {};

 view release on metacpan or  search on metacpan

lib/Log/Fine/Levels/Java.pm  view on Meta::CPAN

sub new
{

        my $class = shift;
        return bless { levelclass => $class }, $class;

}          # new()

# Autoloader
# --------------------------------------------------------------------