1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementations for the scan list iterators

    15 *

    16 */

    17 

    18 

    19 #include "core_scan_list_iterator.h"

    20 #include "core_scan_list.h"

    21 #include "core_tools.h"

    22 #include "core_am_tools.h"

    23 #include "am_debug.h"

    24 

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

    26 

    27 // ---------------------------------------------------------------------------

    28 // ---------------------------------------------------------------------------

    29 //

    30 core_scan_list_iterator_by_tag_c::core_scan_list_iterator_by_tag_c(

    31     core_scan_list_c& scan_list,

    32     u8_t tag ) :

    33     scan_list_m( scan_list ),

    34     tag_m( tag )

    35     {

    36     DEBUG( "core_scan_list_iterator_by_tag_c::core_scan_list_iterator_by_tag_c" );

    37     }

    38 

    39 // ---------------------------------------------------------------------------

    40 // ---------------------------------------------------------------------------

    41 //

    42 core_scan_list_iterator_by_tag_c::~core_scan_list_iterator_by_tag_c()

    43     {

    44     DEBUG( "core_scan_list_iterator_by_tag_c::~core_scan_list_iterator_by_tag_c" );

    45     }

    46 

    47 // ---------------------------------------------------------------------------

    48 // ---------------------------------------------------------------------------

    49 //

    50 core_ap_data_c* core_scan_list_iterator_by_tag_c::first()

    51     {

    52     for( core_scan_list_c::core_scan_list_entry_s* iter = scan_list_m.scan_list_m.first(); iter; iter = scan_list_m.scan_list_m.next() )

    53         {

    54         if ( !( iter->tags & tag_m ) )

    55             {

    56             return iter->ap_data;

    57             }

    58         }

    59 

    60     return NULL;

    61     }

    62 

    63 // ---------------------------------------------------------------------------

    64 // ---------------------------------------------------------------------------

    65 //

    66 core_ap_data_c* core_scan_list_iterator_by_tag_c::next()

    67     {

    68     for( core_scan_list_c::core_scan_list_entry_s* iter = scan_list_m.scan_list_m.next(); iter; iter = scan_list_m.scan_list_m.next() )

    69         {

    70         if ( !( iter->tags & tag_m ) )

    71             {

    72             return iter->ap_data;

    73             }

    74         }

    75 

    76     return NULL;

    77     }

    78 

    79 // ---------------------------------------------------------------------------

    80 // ---------------------------------------------------------------------------

    81 //

    82 core_ap_data_c* core_scan_list_iterator_by_tag_c::current()

    83     {

    84     if ( scan_list_m.scan_list_m.current() )

    85         {

    86         return scan_list_m.scan_list_m.current()->ap_data;

    87         }

    88 

    89     return NULL;

    90     }

    91 

    92 // ---------------------------------------------------------------------------

    93 // ---------------------------------------------------------------------------

    94 //

    95 core_scan_list_iterator_by_age_c::core_scan_list_iterator_by_age_c(

    96     core_scan_list_c& scan_list,

    97     u32_t maximum_age ) :

    98     scan_list_m( scan_list ),

    99     maximum_age_m( maximum_age )

   100     {

   101     DEBUG( "core_scan_list_iterator_by_age_c::core_scan_list_iterator_by_age_c" );

   102     }

   103 

   104 // ---------------------------------------------------------------------------

   105 // ---------------------------------------------------------------------------

   106 //

   107 core_scan_list_iterator_by_age_c::~core_scan_list_iterator_by_age_c()

   108     {

   109     DEBUG( "core_scan_list_iterator_by_age_c::~core_scan_list_iterator_by_age_c" );

   110     }

   111 

   112 // ---------------------------------------------------------------------------

   113 // ---------------------------------------------------------------------------

   114 //

   115 core_ap_data_c* core_scan_list_iterator_by_age_c::first()

   116     {

   117     for( core_scan_list_c::core_scan_list_entry_s* iter = scan_list_m.scan_list_m.first(); iter; iter = scan_list_m.scan_list_m.next() )

   118         {

   119         u64_t difference = ( core_am_tools_c::timestamp() - iter->timestamp ) / SECONDS_FROM_MICROSECONDS;

   120             

   121         if ( maximum_age_m == SCAN_LIST_AGE_ANY ||

   122              difference <= maximum_age_m )

   123             {

   124             return iter->ap_data;

   125             }

   126         }

   127 

   128     return NULL;

   129     }

   130 

   131 // ---------------------------------------------------------------------------

   132 // ---------------------------------------------------------------------------

   133 //

   134 core_ap_data_c* core_scan_list_iterator_by_age_c::next()

   135     {

   136     for( core_scan_list_c::core_scan_list_entry_s* iter = scan_list_m.scan_list_m.next(); iter; iter = scan_list_m.scan_list_m.next() )

   137         {

   138         u64_t difference = ( core_am_tools_c::timestamp() - iter->timestamp ) / SECONDS_FROM_MICROSECONDS;

   139             

   140         if ( maximum_age_m == SCAN_LIST_AGE_ANY ||

   141              difference <= maximum_age_m )

   142             {

   143             return iter->ap_data;

   144             }

   145         }

   146 

   147     return NULL;

   148     }

   149 

   150 // ---------------------------------------------------------------------------

   151 // ---------------------------------------------------------------------------

   152 //

   153 core_ap_data_c* core_scan_list_iterator_by_age_c::current()

   154     {

   155     if ( scan_list_m.scan_list_m.current() )

   156         {

   157         return scan_list_m.scan_list_m.current()->ap_data;

   158         }

   159 

   160     return NULL;

   161     }

   162 

   163 // ---------------------------------------------------------------------------

   164 // ---------------------------------------------------------------------------

   165 //

   166 core_scan_list_iterator_by_tag_and_ssid_c::core_scan_list_iterator_by_tag_and_ssid_c(

   167     core_scan_list_c& scan_list,

   168     u8_t tag,

   169     const core_ssid_s& ssid ) :

   170     core_scan_list_iterator_by_tag_c( scan_list, tag ),

   171     ssid_m( ssid )

   172     {

   173     DEBUG( "core_scan_list_iterator_by_tag_and_ssid_c::core_scan_list_iterator_by_tag_and_ssid_c" );

   174     }

   175 

   176 // ---------------------------------------------------------------------------

   177 // ---------------------------------------------------------------------------

   178 //

   179 core_scan_list_iterator_by_tag_and_ssid_c::~core_scan_list_iterator_by_tag_and_ssid_c()

   180     {

   181     DEBUG( "core_scan_list_iterator_by_tag_and_ssid_c::~core_scan_list_iterator_by_tag_and_ssid_c" );

   182     }

   183 

   184 // ---------------------------------------------------------------------------

   185 // ---------------------------------------------------------------------------

   186 //

   187 core_ap_data_c* core_scan_list_iterator_by_tag_and_ssid_c::first()

   188     {

   189     core_ap_data_c* iter = core_scan_list_iterator_by_tag_c::first();

   190     while ( iter )

   191         {

   192         if ( iter->ssid() == ssid_m )

   193             {

   194             return iter;

   195             }

   196             

   197         iter = core_scan_list_iterator_by_tag_c::next();

   198         }

   199 

   200     return NULL;

   201     }

   202 

   203 // ---------------------------------------------------------------------------

   204 // ---------------------------------------------------------------------------

   205 //

   206 core_ap_data_c* core_scan_list_iterator_by_tag_and_ssid_c::next()

   207     {

   208     core_ap_data_c* iter = core_scan_list_iterator_by_tag_c::next();

   209     while ( iter )

   210         {

   211         if ( iter->ssid() == ssid_m )

   212             {

   213             return iter;

   214             }

   215             

   216         iter = core_scan_list_iterator_by_tag_c::next();

   217         }

   218 

   219     return NULL;

   220     }

   221 

   222 // ---------------------------------------------------------------------------

   223 // ---------------------------------------------------------------------------

   224 //

   225 core_scan_list_iterator_by_tag_and_ssid_and_bssid_c::core_scan_list_iterator_by_tag_and_ssid_and_bssid_c(

   226     core_scan_list_c& scan_list,

   227     u8_t tag,

   228     const core_ssid_s& ssid,

   229     const core_mac_address_s& bssid ) :

   230     core_scan_list_iterator_by_tag_and_ssid_c( scan_list, tag, ssid ),

   231     bssid_m( bssid )

   232     {

   233     DEBUG( "core_scan_list_iterator_by_tag_and_ssid_and_bssid_c::core_scan_list_iterator_by_tag_and_ssid_and_bssid_c" );

   234     }

   235 

   236 // ---------------------------------------------------------------------------

   237 // ---------------------------------------------------------------------------

   238 //

   239 core_scan_list_iterator_by_tag_and_ssid_and_bssid_c::~core_scan_list_iterator_by_tag_and_ssid_and_bssid_c()

   240     {

   241     DEBUG( "core_scan_list_iterator_by_tag_and_ssid_and_bssid_c::~core_scan_list_iterator_by_tag_and_ssid_and_bssid_c" );

   242     }

   243 

   244 // ---------------------------------------------------------------------------

   245 // ---------------------------------------------------------------------------

   246 //

   247 core_ap_data_c* core_scan_list_iterator_by_tag_and_ssid_and_bssid_c::first()

   248     {

   249     core_ap_data_c* iter = core_scan_list_iterator_by_tag_and_ssid_c::first();

   250     while( iter )

   251         {

   252         if( bssid_m == BROADCAST_MAC_ADDR ||

   253             iter->bssid() == bssid_m )

   254             {

   255             return iter;

   256             }

   257 

   258         iter = core_scan_list_iterator_by_tag_and_ssid_c::next();

   259         }

   260 

   261     return NULL;

   262     }

   263 

   264 // ---------------------------------------------------------------------------

   265 // ---------------------------------------------------------------------------

   266 //

   267 core_ap_data_c* core_scan_list_iterator_by_tag_and_ssid_and_bssid_c::next()

   268     {

   269     core_ap_data_c* iter = core_scan_list_iterator_by_tag_and_ssid_c::next();

   270     while( iter )

   271         {

   272         if( bssid_m == BROADCAST_MAC_ADDR ||

   273             iter->bssid() == bssid_m )

   274             {

   275             return iter;

   276             }

   277             

   278         iter = core_scan_list_iterator_by_tag_and_ssid_c::next();

   279         }

   280 

   281     return NULL;

   282     }