list_example.cc

Go to the documentation of this file.

 /*************************************************************************/
 /*                                                                       */
 /*                Centre for Speech Technology Research                  */
 /*                     University of Edinburgh, UK                       */
 /*                       Copyright (c) 1996,1997                         */
 /*                        All Rights Reserved.                           */
 /*  Permission is hereby granted, free of charge, to use and distribute  */
 /*  this software and its documentation without restriction, including   */
 /*  without limitation the rights to use, copy, modify, merge, publish,  */
 /*  distribute, sublicense, and/or sell copies of this work, and to      */
 /*  permit persons to whom this work is furnished to do so, subject to   */
 /*  the following conditions:                                            */
 /*   1. The code must retain the above copyright notice, this list of    */
 /*      conditions and the following disclaimer.                         */
 /*   2. Any modifications must be clearly marked as such.                */
 /*   3. Original authors' names are not deleted.                         */
 /*   4. The authors' names are not used to endorse or promote products   */
 /*      derived from this software without specific prior written        */
 /*      permission.                                                      */
 /*  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        */
 /*  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      */
 /*  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   */
 /*  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     */
 /*  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    */
 /*  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   */
 /*  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          */
 /*  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       */
 /*  THIS SOFTWARE.                                                       */
 /*                                                                       */
 /*************************************************************************/
 /*                                                                       */
 /*                 Author: Richard Caley (rjc@cstr.ed.ac.uk)             */
 /*                   Date: Tue Jul 22 1997                               */
 /* --------------------------------------------------------------------- */
 /* Example of list class use.                                            */
 /*                                                                       */
 /*************************************************************************/

#include <cstdlib>
#include <iostream>
#include "EST_bool.h"
#include "EST_TList.h"
#include "EST_String.h"
#include "EST_util_class.h"
#include "EST_types.h"

using namespace std;

bool second_char_gt(const EST_UItem *uv1, const EST_UItem *uv2);


int main(void)
{

    EST_String strings[] = {"quail", "wood pigeon", "eagle", "emu", "rook" }; //decl

    // There are a number of predefined list types for EST_TList. 
    // EST_StrList is EST_TList<EST_String>.
    EST_StrList slist;  // decl
    EST_Litem *p; //decl
    
    //@ code
    // append adds items on to the end of a list
    for (unsigned int i1 = 0; i1 < sizeof(strings) /sizeof(strings[0]); i1++)
    slist.append(strings[i1]);

    // add item to start of list
    slist.prepend("dove");

    // find pointer to "eagle", add "hawk" before it, and then add sparrow
    // after "hawk"
    for (p = slist.head(); p != 0; p = p->next())
    if (slist(p) == "eagle")
    {
        p = slist.insert_before(p,"hawk");
        p = slist.insert_after(p,"sparrow");
    } //@ endcode



    //@ code
    cout << "[ List Accessed by LItem\n";
    // print out contents of array.
    for (p = slist.head(); p != 0; p = p->next())
      cout << "  " << slist(p) << "\n";
    cout << "]\n";

    // items can also be accessed by their position in the list by using the
    // nth() function. The length() function returns the number of items
    // in a list.
    cout << "\n[ List Accessed by integer index\n";
    for (int i2 = 0; i2 < slist.length(); ++i2)
    cout << "  " << slist.nth(i2) << "\n";
    cout << "]\n";
    //@ endcode



    //@ code
    // Capital;ise all 'e's in all strings
    for (p = slist.head(); p != 0; p = p->next())
    slist(p).gsub("e", "E");

    // print out last item in list
    p = slist.tail();
    cout << "Last item: " << slist(p) << endl;

    // but a more direct method is
    cout << "Last item: " << slist.last() << endl;

    // likewise with the head of the list:
    cout << "First item: " << slist.first() << endl;

    // print out the 4th item:
    cout << "4th item: " << slist.nth(4) << endl;

    // All these can be used for overwriting existing members in the list.
    // To add new members use append(), prepend(), insert_before() or 
    // insert_after() as shown in \ref Addition 
    
    slist.first() = "Swallow";
    slist.last() = "TurkEy";
    slist.nth(2) = "SEagull";

    //@ endcode  

    cout << "\n[ List After Substitutions and Replacements\n";
    for (p = slist.head(); p != 0; p = p->next())
      cout << "  " << slist(p) << "\n";
    cout << "]\n";


    //@ code

    // In the following example, the item "eagle" is removed and a 
    // pointer to the previous item is returned. The for loop then
    // points this to the next item in the loop, giving the appearance
    // of seamless iteration.

    for (p = slist.head(); p != 0; p = p->next())
      if (slist(p) == "EaglE")
            p = slist.remove(p);

    //@ endcode

    cout << "\n[ List After Removing Eagle\n";
    for (p = slist.head(); p != 0; p = p->next())
      cout << "  " << slist(p) << "\n";
    cout << "]\n";

    //@ code
    slist.reverse();
    //@ endcode
    

    cout << "\n[ List After Reverse\n";
    for (p = slist.head(); p != 0; p = p->next())
      cout << "  " << slist(p) << "\n";
    cout << "]\n";

    //@ code

    // Sort into alphabetical order
    sort(slist);
 
   cout << "\n[ Sorted\n";
   for(p=slist.head(); p ; p=p->next())
     cout << "  " << slist(p) << "\n";
   cout << "]\n";
 
    // Sort by second character.
   qsort(slist,&second_char_gt );
 
   cout << "\n[ Sorted by second character\n";
   for(p=slist.head(); p ; p=p->next())
     cout << "  " << slist(p) << "\n";
   cout << "]\n";
   //@ endcode
 
}

//@ code
bool second_char_gt(const EST_UItem *uv1, const EST_UItem *uv2)
{
  const EST_TItem<EST_String> *val1 = (const EST_TItem<EST_String> *)uv1;
  const EST_TItem<EST_String> *val2 = (const EST_TItem<EST_String> *)uv2;
   
  return (bool)(val1->val(1) > val2->val(1));
}
//@ endcode

//@}

// we would need to include the following template
// declarations if lists of strings weren't already declared.
// then this is only useful for and legal for 
// things which have < == and > defined

// template class EST_TList<EST_String>;
// template class EST_TItem<EST_String>;
// template class EST_TSortable<EST_String>;

// declare the template routines we use.

//template void sort(EST_TList<EST_String> &a,
//         bool (*gt)(const EST_UItem *, const EST_UItem *));
//template void qsort(EST_TList<EST_String> &a,
//         bool (*gt)(const EST_UItem *, const EST_UItem *));



/**@page EST_TList-example EST_TList example
   @brief Example of list class use. 
   @dontinclude list_example.cc 
   
   @section insert Inserting items into a list
   There is no easy way to initialise a list so we'll just set it
   from the strings array.

  @skipline //@ code
  @until //@ endcode
  
  @section iteration Iteration over a list

  A dummy pointer of type \ref EST_Litem  is used to iterate
  through a list. This acts somewhat like the index in an array in
  that it is used to access an item, in the list but does not
  contain a value itself.
  
  Iteration is usually done in a for loop. Initialisation involves
  setting the pointer to the head() function. Increments are done
  by the next() function. At the end of the list, the pointer will
  be set to null, and this can be used to check for the end.

  Items in the list are accessed by passing the pointer is as the
  argument to the function operator(), as in the following example.

  @skipline //@ code
  @until //@ endcode

  @section accessing Accessing elements of a list

  The normal way to access an item is to use the \ref EST_Litem 
  in conjunction with the () operator. Other functions also exist,
  eg. EST_TList::first(), EST_TList::last() and EST_TList::nth(). Const 
  and non-const version of each access function exist, allowing 
  both reading and writing.

  @skipline //@ code
  @until //@ endcode

  @section removing Removing items from a list.
  Removing items from lists is done by having the EST_Litem point
  to a particular item, and then passing this pointer to the
  remove function. This can be tricky as this leaves the EST_Litem
  pointer pointing to a non-existent item. To get round this, the
  EST_TList::remove() function returns a pointer to the previous 
  item in the list.
  
  @skipline //@ code
  @until //@ endcode

  @section reverse Reverse a list

  @skipline //@ code
  @until //@ endcode

  @section sort Sorting a list
  
  A number of sort routines for lists are defined. The most useful
  are probably sort (a simple bubble sort, quick for small lists)
  and qsort (quick-sort, faster for long lists).
  
  If the default collation order is not what you want you can pass
  a comparison operator to the sort routine.

  @skipline //@ code
  @until //@ endcode

  @subsection Comparison Operation Used in Sort
  
  Compares the second character of Strings.

  @skipline //@ code
  @until //@ endcode
  
  
  @see EST_TList
  @see EST_TKVL
  @see EST_Option
  */