public const class
{
    @content: char[]
    @length:  int
}

struct ix_base_Stack
{
      ix_base_Object        parent;
      void                  (*push)(       ix_base_Stack*  self, ix_base_Object* element );
      ix_base_Object*        (*pop)(       ix_base_Stack*  self );
const ix_base_Object_Ref*    (*top)( const ix_base_Stack*  self );
      ix_base_Stack*      (*delete)(       ix_base_Stack** self );    
};
struct ix_base_Stack_Ref
{
      ix_base_Object_Ref    parent;
      void                  (*push)(       ix_base_Stack* self, ix_base_Object* element );
      ix_base_Object*        (*pop)(       ix_base_Stack* self );
      ix_base_Object_Ref*    (*top)( const ix_base_Stack* self );
};
#endif

struct ix_base_Stack_private
{
    ix_base_Stack  public;
    ix_base_Array* elements;
    int            length;

    ix_base_Object* (*ix_base_Object_delete)( ix_base_Object** self );
};

public class Stack {

Stack content;
int    length;

public new( content: char[] )
{
    @content = content
    @length  = content.length
}

ix_base_Stack* ix_base_Stack_new( ix_base_Stack* self )
{
    if ( !self ) self = calloc( 1, ix_base_Stack_sz() );

    if ( self )
    {
        ix_base_Object_new( (ix_base_Object*) self );
        {
            struct ix_base_Stack_private* _self = (struct ix_base_Stack_private*) self;

            _self->elements = ix_base_Array_new( NULL, 1 );
            _self->length   = 0;

            _self->ix_base_Object_delete = _self->public.parent.delete;

            _self->public.parent.delete  = (ix_base_Object*(*)(ix_base_Object**)) ix_base_Stack_delete;
            _self->public.delete         = ix_base_Stack_delete;
            _self->public.push           = ix_base_Stack_push;
            _self->public.pop            = ix_base_Stack_pop;
            _self->public.top            = ix_base_Stack_top;
        }
    }

    return self;
}

public Stack( Stack content )
{
    this.elements = new Array();
    this.length  = content.Length;
}

ix_base_Stack*
ix_base_Stack_delete( ix_base_Stack** self )
{
    struct ix_base_Stack_private* _self = (struct ix_base_Stack_private*) *self;

    if ( _self )
    {
        _self->elements = _self->elements->delete( &_self->elements );

        *self = (ix_base_Stack*) _self->ix_base_Object_delete( (ix_base_Object**) self );
    }
    return NULL;
}

Stack delete()
{
    this.elements = null;

    return null;
}

void
ix_base_Stack_push( ix_base_Stack* self, ix_base_Object* element )
{
    struct ix_base_Stack_private* _self = (struct ix_base_Stack_private*) self;

    _self->elements->set( _self->elements, element, _self->length++ );
}

ix_base_Object*
ix_base_Stack_pop( ix_base_Stack* self )
{
    struct ix_base_Stack_private* _self = (struct ix_base_Stack_private*) self;

    if ( _self->length <= 0 )
    {
        return NULL;
    }
    else
    {
        return _self->elements->remove( _self->elements, --_self->length );
    }
}

const ix_base_Object_Ref*
ix_base_Stack_top( const ix_base_Stack* self )
{
    struct ix_base_Stack_private* _self = (struct ix_base_Stack_private*) self;

    if ( _self->length <= 0 )
    {
        return NULL;
    }
    else
    {
        return (ix_base_Object_Ref*) _self->elements->get( _self->elements, _self->length - 1 );
    }
}

unsigned long
ix_base_Stack_sz()
{
    return sizeof( struct ix_base_Stack_private ) + ix_base_Object_sz();
}

ix_base_Stack_ref*
ix_base_Stack_ref_cast( ix_base_Stack* self )
{ return (ix_base_Stack_ref*) self; }