File Coverage

blib/lib/Lib/Pepper/OptionList.pm

Criterion	Covered	Total	%
statement	41	177	23.1
branch	0	38	0.0
condition	0	12	0.0
subroutine	14	26	53.8
pod	11	11	100.0
total	66	264	25.0

package Lib::Pepper::OptionList;
#---AUTOPRAGMASTART---
use v5.42;
use strict;
use diagnostics;
use mro 'c3';
use English;
use Carp qw[carp croak confess cluck longmess shortmess];
our $VERSION = 0.5;
use autodie qw( close );
use Array::Contains;
use utf8;
use Data::Dumper;
use Data::Printer;
#---AUTOPRAGMAEND---


use Lib::Pepper;
use Lib::Pepper::Exception;
use Lib::Pepper::Constants qw(:special);

sub new($class, $handle = undef) {
    my $self = {
        handle => undef,
        owned  => 0,
    };

    bless $self, $class;

    if(defined $handle) {
        # Wrap an existing handle
        $self->{handle} = $handle;
        $self->{owned} = 0;
    } else {
        # Create a new option list
        my ($result, $newHandle) = Lib::Pepper::pepOptionListCreate();
        Lib::Pepper::Exception->checkResult($result, 'pepOptionListCreate');
        $self->{handle} = $newHandle;
        $self->{owned} = 1;
    }

    return $self;
}

sub getHandle($self) {
    return $self->{handle};
}

sub getString($self, $key) {
    if(!defined $key) {
        croak('getString: key parameter is required');
    }

    my ($result, $value) = Lib::Pepper::pepOptionListGetStringElement($self->{handle}, $key);
    Lib::Pepper::Exception->checkResult($result, "getString('$key')");

    return $value;
}

sub getInt($self, $key) {
    if(!defined $key) {
        croak('getInt: key parameter is required');
    }

    my ($result, $value) = Lib::Pepper::pepOptionListGetIntElement($self->{handle}, $key);
    Lib::Pepper::Exception->checkResult($result, "getInt('$key')");

    return $value;
}

sub getChild($self, $key) {
    if(!defined $key) {
        croak('getChild: key parameter is required');
    }

    my ($result, $childHandle) = Lib::Pepper::pepOptionListGetChildOptionListElement($self->{handle}, $key);
    Lib::Pepper::Exception->checkResult($result, "getChild('$key')");

    # Wrap the child handle in a new OptionList object (non-owned)
    return Lib::Pepper::OptionList->new($childHandle);
}

sub addString($self, $key, $value) {
    if(!defined $key) {
        croak('addString: key parameter is required');
    }
    if(!defined $value) {
        croak('addString: value parameter is required');
    }

    my $result = Lib::Pepper::pepOptionListAddStringElement($self->{handle}, $key, $value);
    Lib::Pepper::Exception->checkResult($result, "addString('$key')");

    return $self;
}

sub addInt($self, $key, $value) {
    if(!defined $key) {
        croak('addInt: key parameter is required');
    }
    if(!defined $value) {
        croak('addInt: value parameter is required');
    }

    my $result = Lib::Pepper::pepOptionListAddIntElement($self->{handle}, $key, $value);
    Lib::Pepper::Exception->checkResult($result, "addInt('$key')");

    return $self;
}

sub addChild($self, $key, $childOptionList) {
    if(!defined $key) {
        croak('addChild: key parameter is required');
    }
    if(!defined $childOptionList || !ref($childOptionList) || !$childOptionList->isa('Lib::Pepper::OptionList')) {
        croak('addChild: childOptionList must be a Lib::Pepper::OptionList object');
    }

    my $childHandle = $childOptionList->getHandle();
    my $result = Lib::Pepper::pepOptionListAddChildOptionListElement($self->{handle}, $key, $childHandle);
    Lib::Pepper::Exception->checkResult($result, "addChild('$key')");

    return $self;
}

sub getElementList($self) {
    my ($result, $elementList) = Lib::Pepper::pepOptionListGetElementList($self->{handle});
    Lib::Pepper::Exception->checkResult($result, 'getElementList');

    # Parse comma-separated list
    if(!defined $elementList || $elementList eq '') {
        return [];
    }

    my @elements = split(/,/, $elementList);
    return \@elements;
}

sub toHashref($self) {
    my $elements = $self->getElementList();
    my $hashref = {};

    for my $key (@{$elements}) {
        # Try to get as int first
        my ($result, $value) = Lib::Pepper::pepOptionListGetIntElement($self->{handle}, $key);

        if(Lib::Pepper::Exception->isSuccess($result)) {
            $hashref->{$key} = $value;
            next;
        }

        # Try as string
        ($result, $value) = Lib::Pepper::pepOptionListGetStringElement($self->{handle}, $key);

        if(Lib::Pepper::Exception->isSuccess($result)) {
            $hashref->{$key} = $value;
            next;
        }

        # Try as child option list
        ($result, my $childHandle) = Lib::Pepper::pepOptionListGetChildOptionListElement($self->{handle}, $key);

        if(Lib::Pepper::Exception->isSuccess($result)) {
            my $childList = Lib::Pepper::OptionList->new($childHandle);
            $hashref->{$key} = $childList->toHashref();
            next;
        }

        # If we get here, we couldn't get the value
        carp("Warning: Could not retrieve value for key '$key'");
    }

    return $hashref;
}

sub fromHashref($class, $hashref) {
    if(!defined $hashref || ref($hashref) ne 'HASH') {
        croak('fromHashref: hashref parameter must be a hash reference');
    }

    my $optionList = $class->new();

    for my $key (sort keys %{$hashref}) {
        my $value = $hashref->{$key};

        if(!defined $value) {
            # Skip undefined values
            next;
        } elsif(ref($value) eq 'HASH') {
            # Nested hash - create child option list
            my $childList = $class->fromHashref($value);
            $optionList->addChild($key, $childList);
        } elsif(ref($value) eq '') {
            # Scalar value - use key prefix to determine type: i=int, s=string, h=handle/child
            if($key =~ /^i/) {
                $optionList->addInt($key, $value);
            } else {
                $optionList->addString($key, $value);
            }
        } else {
            croak("fromHashref: unsupported value type for key '$key': " . ref($value));
        }
    }

    return $optionList;
}

sub DESTROY($self) {
    # Note: We don't free the handle here because the Pepper library
    # manages option list memory internally. Option lists are typically
    # freed when the instance they're associated with is freed.
    # Only free if we explicitly own it (future enhancement)
    return;
}

1;

__END__