# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

package LIMAL;
use base qw(Exporter);
use base qw(DynaLoader);
package LIMALc;
bootstrap LIMAL;
package LIMAL;
@EXPORT = qw();

# ---------- BASE METHODS -------------

package LIMAL;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package LIMAL;


############# Class : LIMAL::Logger ##############

package LIMAL::Logger;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LIMAL );
%OWNER = ();
%ITERATORS = ();
*createCerrLogger = *LIMALc::Logger_createCerrLogger;
*createSyslogLogger = *LIMALc::Logger_createSyslogLogger;
*createFileLogger = *LIMALc::Logger_createFileLogger;
*createNullLogger = *LIMALc::Logger_createNullLogger;
sub new {
    my $pkg = shift;
    my $self = LIMALc::new_Logger(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LIMALc::delete_Logger($self);
        delete $OWNER{$self};
    }
}

*setDefaultLogger = *LIMALc::Logger_setDefaultLogger;
*setThreadLogger = *LIMALc::Logger_setThreadLogger;
*getDefaultLogger = *LIMALc::Logger_getDefaultLogger;
*getCurrentLogger = *LIMALc::Logger_getCurrentLogger;
*logMessage = *LIMALc::Logger_logMessage;
*isEnabledFor = *LIMALc::Logger_isEnabledFor;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LIMAL::ByteBuffer ##############

package LIMAL::ByteBuffer;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LIMAL );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LIMALc::new_ByteBuffer(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LIMALc::delete_ByteBuffer($self);
        delete $OWNER{$self};
    }
}

*clear = *LIMALc::ByteBuffer_clear;
*empty = *LIMALc::ByteBuffer_empty;
*size = *LIMALc::ByteBuffer_size;
*data = *LIMALc::ByteBuffer_data;
*at = *LIMALc::ByteBuffer_at;
*append = *LIMALc::ByteBuffer_append;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LIMAL::StringArray ##############

package LIMAL::StringArray;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LIMAL );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LIMALc::new_StringArray(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LIMALc::delete_StringArray($self);
        delete $OWNER{$self};
    }
}

*swap = *LIMALc::StringArray_swap;
*size = *LIMALc::StringArray_size;
*max_size = *LIMALc::StringArray_max_size;
*capacity = *LIMALc::StringArray_capacity;
*resize = *LIMALc::StringArray_resize;
*reserve = *LIMALc::StringArray_reserve;
*empty = *LIMALc::StringArray_empty;
*front = *LIMALc::StringArray_front;
*back = *LIMALc::StringArray_back;
*push_back = *LIMALc::StringArray_push_back;
*append = *LIMALc::StringArray_append;
*pop_back = *LIMALc::StringArray_pop_back;
*clear = *LIMALc::StringArray_clear;
*begin = *LIMALc::StringArray_begin;
*end = *LIMALc::StringArray_end;
*rbegin = *LIMALc::StringArray_rbegin;
*rend = *LIMALc::StringArray_rend;
*insert = *LIMALc::StringArray_insert;
*appendArray = *LIMALc::StringArray_appendArray;
*erase = *LIMALc::StringArray_erase;
*remove = *LIMALc::StringArray_remove;
*iterator_incr = *LIMALc::StringArray_iterator_incr;
*iterator_decr = *LIMALc::StringArray_iterator_decr;
*iterator_equal = *LIMALc::StringArray_iterator_equal;
*iterator_value = *LIMALc::StringArray_iterator_value;
*getitem = *LIMALc::StringArray_getitem;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LIMAL::StringList ##############

package LIMAL::StringList;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LIMAL );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LIMALc::new_StringList(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LIMALc::delete_StringList($self);
        delete $OWNER{$self};
    }
}

*swap = *LIMALc::StringList_swap;
*size = *LIMALc::StringList_size;
*max_size = *LIMALc::StringList_max_size;
*resize = *LIMALc::StringList_resize;
*empty = *LIMALc::StringList_empty;
*front = *LIMALc::StringList_front;
*back = *LIMALc::StringList_back;
*push_front = *LIMALc::StringList_push_front;
*push_back = *LIMALc::StringList_push_back;
*pop_front = *LIMALc::StringList_pop_front;
*pop_back = *LIMALc::StringList_pop_back;
*clear = *LIMALc::StringList_clear;
*remove = *LIMALc::StringList_remove;
*unique = *LIMALc::StringList_unique;
*merge = *LIMALc::StringList_merge;
*reverse = *LIMALc::StringList_reverse;
*sort = *LIMALc::StringList_sort;
*begin = *LIMALc::StringList_begin;
*end = *LIMALc::StringList_end;
*insert = *LIMALc::StringList_insert;
*erase = *LIMALc::StringList_erase;
*splice = *LIMALc::StringList_splice;
*iterator_incr = *LIMALc::StringList_iterator_incr;
*iterator_decr = *LIMALc::StringList_iterator_decr;
*iterator_equal = *LIMALc::StringList_iterator_equal;
*iterator_value = *LIMALc::StringList_iterator_value;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LIMAL::StringMap ##############

package LIMAL::StringMap;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LIMAL );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LIMALc::new_StringMap(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LIMALc::delete_StringMap($self);
        delete $OWNER{$self};
    }
}

*swap = *LIMALc::StringMap_swap;
*size = *LIMALc::StringMap_size;
*max_size = *LIMALc::StringMap_max_size;
*empty = *LIMALc::StringMap_empty;
*clear = *LIMALc::StringMap_clear;
*begin = *LIMALc::StringMap_begin;
*end = *LIMALc::StringMap_end;
*iterator_incr = *LIMALc::StringMap_iterator_incr;
*iterator_decr = *LIMALc::StringMap_iterator_decr;
*iterator_equal = *LIMALc::StringMap_iterator_equal;
*iterator_key = *LIMALc::StringMap_iterator_key;
*iterator_value = *LIMALc::StringMap_iterator_value;
*contains = *LIMALc::StringMap_contains;
*getitem = *LIMALc::StringMap_getitem;
*setitem = *LIMALc::StringMap_setitem;
*delitem = *LIMALc::StringMap_delitem;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LIMAL::Int32List ##############

package LIMAL::Int32List;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LIMAL );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LIMALc::new_Int32List(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LIMALc::delete_Int32List($self);
        delete $OWNER{$self};
    }
}

*swap = *LIMALc::Int32List_swap;
*size = *LIMALc::Int32List_size;
*max_size = *LIMALc::Int32List_max_size;
*resize = *LIMALc::Int32List_resize;
*empty = *LIMALc::Int32List_empty;
*front = *LIMALc::Int32List_front;
*back = *LIMALc::Int32List_back;
*push_front = *LIMALc::Int32List_push_front;
*push_back = *LIMALc::Int32List_push_back;
*pop_front = *LIMALc::Int32List_pop_front;
*pop_back = *LIMALc::Int32List_pop_back;
*clear = *LIMALc::Int32List_clear;
*remove = *LIMALc::Int32List_remove;
*unique = *LIMALc::Int32List_unique;
*merge = *LIMALc::Int32List_merge;
*reverse = *LIMALc::Int32List_reverse;
*sort = *LIMALc::Int32List_sort;
*begin = *LIMALc::Int32List_begin;
*end = *LIMALc::Int32List_end;
*insert = *LIMALc::Int32List_insert;
*erase = *LIMALc::Int32List_erase;
*splice = *LIMALc::Int32List_splice;
*iterator_incr = *LIMALc::Int32List_iterator_incr;
*iterator_decr = *LIMALc::Int32List_iterator_decr;
*iterator_equal = *LIMALc::Int32List_iterator_equal;
*iterator_value = *LIMALc::Int32List_iterator_value;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


# ------- VARIABLE STUBS --------

package LIMAL;

1;
