view release on metacpan or search on metacpan
lib/Module/Generic.pm view on Meta::CPAN
}
};
return( $new );
}
sub new_glob
{
my $that = shift( @_ );
my $class = ref( $that ) || $that;
no warnings 'once';
my $self = bless( \do{ local *FH } => $class );
*$self = {};
if( defined( ${ "${class}\::LOG_DEBUG" } ) )
{
*$self->{log_debug} = ${ "${class}::LOG_DEBUG" };
}
if( Want::want( 'OBJECT' ) )
{
return( $self->init( @_ ) );
}
my $new = $self->init( @_ );
lib/Module/Generic/DateTime.pm view on Meta::CPAN
if( CORE::ref( $self ) )
{
foreach( CORE::keys( %$hash ) )
{
$self->{ $_ } = CORE::delete( $hash->{ $_ } );
}
$new = $self;
}
else
{
$new = CORE::bless( $hash => $class );
}
CORE::return( $new );
}
sub TO_JSON
{
my $self = CORE::shift( @_ );
CORE::return( '' ) if( !$self->{dt} || !Scalar::Util::blessed( $self->{dt} ) );
CORE::return( $self->{dt}->stringify );
}
lib/Module/Generic/Dynamic.pm view on Meta::CPAN
our $VERSION = 'v1.2.4';
};
use strict;
no warnings 'redefine';
sub new
{
my $this = shift( @_ );
my $class = ref( $this ) || $this;
my $self = bless( {} => $class );
my $data = $self->{_data} = {};
# A Module::Generic object standard parameter
$self->{_data_repo} = '_data';
my $hash = {};
@_ = () if( scalar( @_ ) == 1 && !defined( $_[0] ) );
if( scalar( @_ ) == 1 && ( Scalar::Util::reftype( $_[0] ) // '' ) eq 'HASH' )
{
$hash = shift( @_ );
$self->{debug} = $DEBUG if( $DEBUG && !CORE::exists( $hash->{debug} ) );
}
lib/Module/Generic/File.pm view on Meta::CPAN
if( CORE::ref( $self ) )
{
foreach( CORE::keys( %$hash ) )
{
$self->{ $_ } = CORE::delete( $hash->{ $_ } );
}
$new = $self;
}
else
{
$new = CORE::bless( $hash => $class );
}
CORE::return( $new );
}
sub TO_JSON { return( shift->filepath ); }
# NOTE: IO::File class modification
{
package
IO::File;
lib/Module/Generic/File/IO.pm view on Meta::CPAN
#
# sub STORABLE_thaw { return( shift->THAW( @_ ) ); }
# NOTE: STORABLE_freeze_pre_processing called by Storable::Improved
sub STORABLE_freeze_pre_processing
{
my $self = CORE::shift( @_ );
my $class = CORE::ref( $self ) || $self;
my $args = $self->args;
# We change the glob object into a regular hash-based one to be Storable-friendly
my $this = CORE::bless( { args => $args, class => $class } => $class );
CORE::return( $this );
}
sub STORABLE_thaw_post_processing
{
my $self = CORE::shift( @_ );
my $args = ( CORE::exists( $self->{args} ) && CORE::ref( $self->{args} ) eq 'ARRAY' )
? $self->{args}
: [];
my $class = ( CORE::exists( $self->{class} ) && CORE::defined( $self->{class} ) && CORE::length( $self->{class} ) )
lib/Module/Generic/File/Mmap.pm view on Meta::CPAN
if( CORE::ref( $self ) )
{
foreach( CORE::keys( %$hash ) )
{
$self->{ $_ } = CORE::delete( $hash->{ $_ } );
}
$new = $self;
}
else
{
$new = CORE::bless( $hash => $class );
}
if( CORE::defined( $cache_data ) &&
CORE::defined( $cache_file ) )
{
my $f = Module::Generic::File->new( $cache_file ) || do
{
warn( "Unable to get a file object for \"$cache_file\": ", Module::Generic::File->error, "\n" ) if( $self->_warnings_is_enabled() );
return( $new );
};
$new->{cache_file} = $f;
lib/Module/Generic/Finfo.pm view on Meta::CPAN
if( CORE::ref( $self ) )
{
foreach( CORE::keys( %$hash ) )
{
$self->{ $_ } = CORE::delete( $hash->{ $_ } );
}
$new = $self;
}
else
{
$new = CORE::bless( $hash => $class );
}
CORE::return( $new );
}
sub TO_JSON { CORE::return( CORE::shift->filepath ); }
sub _datetime
{
my $self = shift( @_ );
my $t = shift( @_ );
lib/Module/Generic/Hash.pm view on Meta::CPAN
my %hash = ();
# This enables access to the hash just like a real hash while still the user an call our object methods
my $obj = tie( %hash, 'Module::Generic::TieHash', {
# disable => ['Module::Generic'],
debug => $DEBUG,
enable => 0,
# Should we allow objects to be used as key? Default to false
key_object => $KEY_OBJECT,
});
my $self = bless( \%hash => $class );
$obj->enable(1);
if( scalar( @_ ) == 1 )
{
my $data = shift( @_ );
return( $that->error( "I was expecting an hash, but instead got '", ( $data // 'undef' ), "'." ) ) if( Scalar::Util::reftype( $data // '' ) ne 'HASH' );
my $tied = tied( %$data );
return( $that->error( "Hash provided is already tied to ", ref( $tied ), " and our package $class cannot use it, or it would disrupt the tie." ) ) if( $tied );
my @keys = CORE::keys( %$data );
@hash{ @keys } = @$data{ @keys };
lib/Module/Generic/HeaderValue.pm view on Meta::CPAN
if( CORE::ref( $self ) )
{
foreach( CORE::keys( %$hash ) )
{
$self->{ $_ } = CORE::delete( $hash->{ $_ } );
}
$new = $self;
}
else
{
$new = CORE::bless( $hash => $class );
}
CORE::return( $new );
}
1;
# NOTE: POD
__END__
=encoding utf-8
lib/Module/Generic/Iterator.pm view on Meta::CPAN
if( CORE::ref( $self ) )
{
foreach( CORE::keys( %$hash ) )
{
$self->{ $_ } = CORE::delete( $hash->{ $_ } );
}
$new = $self;
}
else
{
$new = CORE::bless( $hash => $class );
}
CORE::return( $new );
}
1;
__END__
lib/Module/Generic/Null.pm view on Meta::CPAN
no warnings 'redefine';
sub new
{
my $this = shift( @_ );
my $class = ref( $this ) || $this;
my $error_object;
$error_object = shift( @_ ) if( Scalar::Util::blessed( $_[0] ) );
my $hash = ( @_ == 1 && ref( $_[0] ) ? shift( @_ ) : { @_ } );
$hash->{has_error} = $error_object;
return( bless( $hash => $class ) );
}
sub _obj_eq
{
no overloading;
my $self = shift( @_ );
my $other = shift( @_ );
my $me;
if( Scalar::Util::blessed( $other ) && $other->isa( 'Module::Generic::Null' ) )
{
lib/Module/Generic/Scalar.pm view on Meta::CPAN
# set up earlier by another method; or
# with an hash containing just one argument class => 'Some::ExceptionClass'
if( !CORE::defined( $err ) && ( !CORE::scalar( @_ ) || CORE::defined( $class ) ) )
{
if( !CORE::defined( $ERRORS->{ $addr } ) )
{
warnings::warnif( "No error object provided and no previous error set either! It seems the previous method call returned a simple undef\n" );
}
else
{
$err = ( CORE::defined( $class ) ? bless( $ERRORS->{ $addr } => $class ) : $ERRORS->{ $addr } );
}
}
elsif( CORE::defined( $err ) &&
Scalar::Util::blessed( $err ) &&
( CORE::scalar( @_ ) == 1 ||
( CORE::scalar( @_ ) == 2 && CORE::defined( $class ) )
) )
{
$ERRORS->{ $addr } = $ERROR = ( CORE::defined( $class ) ? bless( $err => $class ) : $err );
}
# If the error provided is not an object, we call error to create one
else
{
return( $self->error( @_ ) );
}
if( want( 'OBJECT' ) )
{
require Module::Generic::Null;
lib/Module/Generic/SharedMemXS.pm view on Meta::CPAN
if( CORE::ref( $self ) )
{
foreach( CORE::keys( %$hash ) )
{
$self->{ $_ } = CORE::delete( $hash->{ $_ } );
}
$new = $self;
}
else
{
$new = CORE::bless( $hash => $class );
}
if( $was_opened )
{
my $size = ( defined( $new->{size} ) && length( $new->{size} ) ) ? $new->{size} : SHM_BUFSIZ;
my $flags = ( defined( $new->{flags} ) && length( $new->{flags} ) ) ? $new->{flags} : &IPC::SysV::S_IRWXU;
$flags |= &IPC::SysV::IPC_CREAT if( defined( $new->{create} ) && $new->{create} );
my $key = $new->{key};
# try-catch
local $@;
eval
view all matches for this distributionview release on metacpan - search on metacpan