Sub::HandlesVia::HandlerLibrary::String3pm

append( $tail )

Arguments: Str.

Appends another string to the end of the current string and updates the attribute.

  my $object = My::Class->new( attr => 'foo' );
  $object->my_append( 'bar' );
  say $object->attr; ## ==> 'foobar'

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

chomp()

Like "chomp" from perlfunc.

chop()

Like "chop" from perlfunc.

clear()

Sets the string to the empty string.

  my $object = My::Class->new( attr => 'foo' );
  $object->my_clear;
  say $object->attr; ## nothing

cmp( $str )

Arguments: Str.

Returns "$object->attr cmp $str".

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

cmpi( $str )

Arguments: Str.

Returns "fc($object->attr) cmp fc($str)". Uses "lc" instead of "fc" in versions of Perl older than 5.16.

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

contains( $str )

Arguments: Str.

Returns true iff the string contains $str.

contains_i( $str )

Arguments: Str.

Returns true iff the string contains $str case-insensitvely.

ends_with( $tail )

Arguments: Str.

Returns true iff the string ends with $tail.

ends_with_i( $tail )

Arguments: Str.

Returns true iff the string ends with $tail case-insensitvely.

eq( $str )

Arguments: Str.

Returns "$object->attr eq $str".

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

eqi( $str )

Arguments: Str.

Returns "fc($object->attr) eq fc($str)". Uses "lc" instead of "fc" in versions of Perl older than 5.16.

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

fc()

Returns fc($object->attr).

ge( $str )

Arguments: Str.

Returns "$object->attr ge $str".

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

gei( $str )

Arguments: Str.

Returns "fc($object->attr) ge fc($str)". Uses "lc" instead of "fc" in versions of Perl older than 5.16.

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

get()

Gets the current value of the string.

  my $object = My::Class->new( attr => 'foo' );
  say $object->my_get; ## ==> 'foo'

gt( $str )

Arguments: Str.

Returns "$object->attr gt $str".

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

gti( $str )

Arguments: Str.

Returns "fc($object->attr) gt fc($str)". Uses "lc" instead of "fc" in versions of Perl older than 5.16.

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

inc()

Performs "++" on the string.

lc()

Returns lc($object->attr).

le( $str )

Arguments: Str.

Returns "$object->attr le $str".

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

lei( $str )

Arguments: Str.

Returns "fc($object->attr) le fc($str)". Uses "lc" instead of "fc" in versions of Perl older than 5.16.

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

length()

Like "length" from perlfunc.

  my $object = My::Class->new( attr => 'foo' );
  say $object->my_length; ## ==> 3

lt( $str )

Arguments: Str.

Returns "$object->attr lt $str".

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

lti( $str )

Arguments: Str.

Returns "fc($object->attr) lt fc($str)". Uses "lc" instead of "fc" in versions of Perl older than 5.16.

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

match( $regexp )

Arguments: Str|RegexpRef.

Returns true iff the string matches the regexp.

  my $object = My::Class->new( attr => 'foo' );
  if ( $object->my_match( '^f..$' ) ) {
    say 'matched!';
  }

match_i( $regexp )

Arguments: Str|RegexpRef.

Returns true iff the string matches the regexp case-insensitively.

  my $object = My::Class->new( attr => 'foo' );
  if ( $object->my_match_i( '^F..$' ) ) {
    say 'matched!';
  }

ne( $str )

Arguments: Str.

Returns "$object->attr ne $str".

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

nei( $str )

Arguments: Str.

Returns "fc($object->attr) ne fc($str)". Uses "lc" instead of "fc" in versions of Perl older than 5.16.

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

prepend( $head )

Arguments: Str.

Prepends another string to the start of the current string and updates the attribute.

  my $object = My::Class->new( attr => 'foo' );
  $object->my_prepend( 'bar' );
  say $object->attr; ## ==> 'barfoo'

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

"replace( $regexp, $replacement )"

Arguments: Str|RegexpRef, Str|CodeRef.

Replaces the first regexp match within the string with the replacement string.

  my $object = My::Class->new( attr => 'foo' );
  $object->my_replace( 'o' => 'a' );
  say $object->attr; ## ==> 'fao'
  my $object2 = My::Class->new( attr => 'foo' );
  $object2->my_replace( qr/O/i => sub { return 'e' } );
  say $object2->attr; ## ==> 'feo'

"replace_globally( $regexp, $replacement )"

Arguments: Str|RegexpRef, Str|CodeRef.

Replaces the all regexp matches within the string with the replacement string.

  my $object = My::Class->new( attr => 'foo' );
  $object->my_replace_globally( 'o' => 'a' );
  say $object->attr; ## ==> 'faa'
  my $object2 = My::Class->new( attr => 'foo' );
  $object2->my_replace_globally( qr/O/i => sub { return 'e' } );
  say $object2->attr; ## ==> 'fee'

reset()

Resets the attribute to its default value, or an empty string if it has no default.

set( $value )

Arguments: Str.

Sets the string to a new value.

  my $object = My::Class->new( attr => 'foo' );
  $object->my_set( 'bar' );
  say $object->attr; ## ==> 'bar'

A faster XS implementation may be used if Sub::HandlesVia::XS is installed.

starts_with( $head )

Arguments: Str.

Returns true iff the string starts with $head.

starts_with_i( $head )

Arguments: Str.

Returns true iff the string starts with $head case-insensitvely.

"substr( $start, $length?, $replacement? )"

Arguments: Int, Optional[Int], Optional[Str].

Like "substr" from perlfunc, but is not an lvalue.

trim()

Like "trim" from builtin, but in-place.

uc()

Returns uc($object->attr).

Using eq for Enum

  use strict;
  use warnings;
  
  package My::Person {
    use Moo;
    use Sub::HandlesVia;
    use Types::Standard qw( Str Enum );
    
    has name => (
      is => 'ro',
      isa => Str,
      required => 1,
    );
    
    has status => (
      is => 'rwp',
      isa => Enum[ 'alive', 'dead' ],
      handles_via => 'String',
      handles => {
        is_alive => [ eq  => 'alive' ],
        is_dead  => [ eq  => 'dead' ],
        kill     => [ set => 'dead' ],
      },
      default => 'alive',
    );
    
    # Note: method modifiers work on delegated methods
    #
    before kill => sub {
      my $self = shift;
      warn "overkill" if $self->is_dead;
    };
  }
  
  my $bob = My::Person->new( name => 'Robert' );
  say $bob->is_alive; ## ==> true
  say $bob->is_dead;  ## ==> false
  $bob->kill;
  say $bob->is_alive; ## ==> false
  say $bob->is_dead;  ## ==> true

See also MooX::Enumeration and MooseX::Enumeration.

Match with curried regexp

  use strict;
  use warnings;
  
  package My::Component {
    use Moo;
    use Sub::HandlesVia;
    use Types::Standard qw( Str Int );
    
    has id => (
      is => 'ro',
      isa => Int,
      required => 1,
    );
    
    has name => (
      is => 'ro',
      isa => Str,
      required => 1,
      handles_via => 'String',
      handles => {
        name_is_safe_filename => [ match => qr/\A[A-Za-z0-9]+\z/ ],
        _lc_name => 'lc',
      },
    );
    
    sub config_filename {
      my $self = shift;
      if ( $self->name_is_safe_filename ) {
        return sprintf( '%s.ini', $self->_lc_name );
      }
      return sprintf( 'component-%d.ini', $self->id );
    }
  }
  
  my $foo = My::Component->new( id => 42, name => 'Foo' );
  say $foo->config_filename; ## ==> 'foo.ini'
  
  my $bar4 = My::Component->new( id => 99, name => 'Bar #4' );
  say $bar4->config_filename; ## ==> 'component-99.ini'