/*

* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of core_traffic_stream_list_c class.

*

*/

/*

* %version: 10 %

*/

#include "core_traffic_stream_list.h"

#include "core_tools.h"

#include "core_am_tools.h"

#include "am_debug.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_traffic_stream_list_c::core_traffic_stream_list_c() :

    ts_list_m( )

    {

    DEBUG( "core_traffic_stream_list_c::core_traffic_stream_list_c()" );

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_traffic_stream_list_c::~core_traffic_stream_list_c()

    {

    DEBUG( "core_traffic_stream_list_c::~core_traffic_stream_list_c()" );

    for( entry_s* iter = ts_list_m.first(); iter; iter = ts_list_m.next() )

        {

        delete iter->traffic_stream;

        }

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

u32_t core_traffic_stream_list_c::count() const

    {

    return ts_list_m.count();

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_traffic_stream_c* core_traffic_stream_list_c::first()

    {

    entry_s* iter = ts_list_m.first();

    if ( iter )

        {

        return iter->traffic_stream;

        }

    return NULL;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_traffic_stream_c* core_traffic_stream_list_c::next()

    {

    entry_s* iter = ts_list_m.next();

    if ( iter )

        {

        return iter->traffic_stream;

        }

    return NULL;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_traffic_stream_c* core_traffic_stream_list_c::current() const

    {

    entry_s* iter = ts_list_m.current();

    if ( iter )

        {

        return iter->traffic_stream;

        }

    return NULL;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_error_e core_traffic_stream_list_c::update_traffic_stream(

    const core_traffic_stream_c& traffic_stream )

    {

    DEBUG1( "core_traffic_stream_list_c::update_traffic_stream() - searching an entry with TID %u",

        traffic_stream.tid() );

    entry_s* iter = ts_list_m.first();

    while( iter )

        {

        if ( iter->traffic_stream->tid() == traffic_stream.tid() )

            {

            DEBUG( "core_traffic_stream_list_c::update_traffic_stream() - entry with matching TID found, replacing entry" );

            *iter->traffic_stream = traffic_stream;

            return core_error_ok;

            }

        iter = ts_list_m.next();

        }

    DEBUG( "core_traffic_stream_list_c::update_traffic_stream() - no entry matching the TID found, adding a new entry" );

    entry_s* entry = new entry_s;

    if ( entry )

        {

        entry->traffic_stream = new core_traffic_stream_c(

            traffic_stream.tid(),

            traffic_stream.user_priority() );

        if ( entry->traffic_stream )

            {

            *entry->traffic_stream = traffic_stream;

            ts_list_m.append( entry );

            }

        else

            {

            DEBUG( "core_traffic_stream_list_c::update_traffic_stream() - unable to create core_traffic_stream_c" );

            delete entry;

            return core_error_no_memory;

            }

        }

    else

        {

        DEBUG( "core_traffic_stream_list_c::update_traffic_stream() - unable to create entry_s" );

        return core_error_no_memory;

        }

    return core_error_ok;         

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void core_traffic_stream_list_c::remove_traffic_stream_by_tid(

    u8_t tid )

    {

    DEBUG1( "core_traffic_stream_list_c::remove_traffic_stream_by_tid() - removing an entry with TID %u", tid );

    entry_s* iter = ts_list_m.first();

    while( iter )

        {

        if ( iter->traffic_stream->tid() == tid )

            {

            DEBUG( "core_traffic_stream_list_c::remove_traffic_stream_by_tid() - matching entry found" );

            ts_list_m.remove( iter );

            iter = NULL;

            }

        else

            {

            iter = ts_list_m.next();

            }

        }

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void core_traffic_stream_list_c::print_contents()

    {

    for( entry_s* iter = ts_list_m.first(); iter; iter = ts_list_m.next() )

        {

        DEBUG1( "core_traffic_stream_list_c::print_contents() - TID: %u",

            iter->traffic_stream->tid() );

        DEBUG1( "core_traffic_stream_list_c::print_contents() - UP: %u",

            iter->traffic_stream->user_priority() );

        switch( iter->traffic_stream->direction() )

            {

            case core_traffic_stream_direction_uplink:

                DEBUG( "core_traffic_stream_list_c::print_contents() - direction: uplink" );

                break;

            case core_traffic_stream_direction_downlink:

                DEBUG( "core_traffic_stream_list_c::print_contents() - direction: downlink" );

                break;

            case core_traffic_stream_direction_bidirectional:

                DEBUG( "core_traffic_stream_list_c::print_contents() - direction: bi-directional" );

                break;

            }

        switch ( iter->traffic_stream->status() )

            {

            case core_traffic_stream_status_undefined:

                DEBUG( "core_traffic_stream_list_c::print_contents() - status: core_traffic_stream_status_undefined" );

                break;

            case core_traffic_stream_status_active:

                DEBUG( "core_traffic_stream_list_c::print_contents() - status: core_traffic_stream_status_active" );

                break;

            case core_traffic_stream_status_inactive_not_required:

                DEBUG( "core_traffic_stream_list_c::print_contents() - status: core_traffic_stream_status_inactive_not_required" );

                break;

            case core_traffic_stream_status_inactive_deleted_by_ap:

                DEBUG( "core_traffic_stream_list_c::print_contents() - status: core_traffic_stream_status_inactive_deleted_by_ap" );

                break;

            case core_traffic_stream_status_inactive_no_bandwidth:

                DEBUG( "core_traffic_stream_list_c::print_contents() - status: core_traffic_stream_status_inactive_no_bandwidth" );

                break;

            case core_traffic_stream_status_inactive_invalid_parameters:

                DEBUG( "core_traffic_stream_list_c::print_contents() - status: core_traffic_stream_status_inactive_invalid_parameters" );

                break;

            case core_traffic_stream_status_inactive_other:

                DEBUG( "core_traffic_stream_list_c::print_contents() - status: core_traffic_stream_status_inactive_other" );

                break;

            }

        DEBUG( "core_traffic_stream_list_c::print_contents()" );

        }

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

medium_time_s core_traffic_stream_list_c::admitted_medium_time()

    {

    medium_time_s medium_time( MEDIUM_TIME_NOT_DEFINED );

    for( entry_s* iter = ts_list_m.first(); iter; iter = ts_list_m.next() )

        {

        u16_t ts_medium_time(

            iter->traffic_stream->medium_time() );       

        if( iter->traffic_stream->direction() == core_traffic_stream_direction_bidirectional )

            {

            /**

             * The admitted medium time of a bi-directional stream has to be

             * multiplied by two because it contains both an uplink and

             * a downlink component.

             */

            ts_medium_time *= 2;

            }

        medium_time.up[iter->traffic_stream->user_priority()] += ts_medium_time;

        medium_time.ac[iter->traffic_stream->access_class()] += ts_medium_time;

        }

    return medium_time;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

bool_t core_traffic_stream_list_c::is_traffic_stream_for_access_class(

    core_access_class_e access_class )

    {

    for( entry_s* iter = ts_list_m.first(); iter; iter = ts_list_m.next() )

        {

        if ( core_tools_c::convert_user_priority_to_ac( iter->traffic_stream->user_priority() ) ==

             access_class )

            {

            return true_t;

            }

        }

    return false_t;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

bool_t core_traffic_stream_list_c::is_traffic_stream_for_tid(

    u8_t tid )

    {

    for( entry_s* iter = ts_list_m.first(); iter; iter = ts_list_m.next() )

        {

        if( iter->traffic_stream->tid() == tid )

            {

            return true_t;

            }

        }

    return false_t;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void core_traffic_stream_list_c::set_traffic_stream_status(

    core_traffic_stream_status_e status )

    {

    for( entry_s* iter = ts_list_m.first(); iter; iter = ts_list_m.next() )

        {

        iter->traffic_stream->set_status( status );

        }

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

u8_t core_traffic_stream_list_c::next_tid()

    {

    bool_t tid_array[MAX_TRAFFIC_STREAM_TID] =

        { false_t, false_t, false_t, false_t, false_t,false_t,false_t,false_t };

    for( entry_s* iter = ts_list_m.first(); iter; iter = ts_list_m.next() )

        {

        tid_array[iter->traffic_stream->tid()] = true_t;

        }

    u8_t tid( 0 );

    while( tid < MAX_TRAFFIC_STREAM_TID )

        {

        if( !tid_array[tid] )

            {

            return tid;

            }

        else

            {

            ++tid;

            }

        }

    return MAX_TRAFFIC_STREAM_TID;

    }