examples/SFExamples/Example_RArray/InsertAndFindExamples.cpp

/*
Copyright (c) 2002-2011 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description:  
*/
#include "InsertandFindExamples.h"
#include "SharedCode.h"
#include <e32test.h>

extern CConsoleBase* console;

// ---------------------------------------------------------
// void InsertionUsingKeyOffsetsL()
// Sorts the array by inserting each element in its correct 
// position
// ---------------------------------------------------------
//
LOCAL_C void InsertionUsingKeyOffsetsL()
        {
        TExampleStruct* values = GenerateValuesLC();
        
        // Construct an RArray and let it take ownership of the
        // block of random data
        RArray<TExampleStruct> array(KDefaultGranularity, _FOFF(TExampleStruct, iB));
        CleanupClosePushL(array);
        
        // Now insert the values
        // into the array
        for (TInt i=0; i < KMaxElements; i++)
                {
                const TInt err = array.InsertInSignedKeyOrder(values[i]);
                if (err != KErrNone && err != KErrAlreadyExists)
                        User::Leave(err);
                }
                
        // Verify the elements can be found in the newly sorted array
        for (TInt i=0; i < KMaxElements; i++)
                {
                User::LeaveIfError(array.FindInSignedKeyOrder(values[i]));
                }
        
        // Verify the items are correctly sorted
        // Note there are never any duplicates
        for (TInt i=0; i < array.Count()-1; i++)
                {
                if (array[i].iB >= array[i+1].iB)
                        User::Leave(KErrGeneral);
                }
        
        CleanupStack::PopAndDestroy(2, values);
        }

// ---------------------------------------------------------
// void InsertionUsingFunctionL()
// Sorts the array using the TLinearOrder functionality 
// ---------------------------------------------------------
//
LOCAL_C void InsertionUsingFunctionL()
        {
        TExampleStruct* values = GenerateValuesLC();

        RExampleArray array(KDefaultGranularity);
        CleanupClosePushL(array);

        const TLinearOrder<TExampleStruct> order(TExampleStruct::RelativeAOrdering);
        
        // we construct an array by inserting the values into the array
        // in the case of duplicates we just ignore them which
        // means array.Count() may not be KMaxElements
        for (TInt i=0; i < KMaxElements; i++)
                {
                const TInt err = array.InsertInOrder(values[i], order);
                if (err != KErrNone && err != KErrAlreadyExists)
                        User::Leave(err);
                }
        
        // now verify each element of values can be found in the array
        for (TInt i = 0; i < KMaxElements; i++)
                {
                TInt err = array.FindInOrder(values[i], order);
                if (err == KErrNotFound)
                        User::Leave(KErrNotFound);
                }
        
        // now verify the array is sorted
        for (TInt i = 0; i < array.Count()-1; i++)
                {
                if (TExampleStruct::RelativeAOrdering(array[i], array[i+1]) > 0)
                        User::Leave(KErrGeneral);
                }

        CleanupStack::PopAndDestroy(2, values);
        }

// ---------------------------------------------------------
// void FindUsingLinearSearchL()
// Finds the items using a linear search (horribly inefficient) 
// ---------------------------------------------------------
//
LOCAL_C void FindUsingLinearSearchL()
        {
        TExampleStruct* values = GenerateValuesLC();

        // We need to make sure our randomly generated
        // data does not contain duplicate copies of the
        // key
        const TExampleStruct& s = values[KSearchIndex];
        for (TInt i= KSearchIndex-1; i>=0; i--)
                {
                if (values[i].iA == s.iA)
                        values[i].iA = 0;
                }       

        RExampleArray array;
        CleanupClosePushL(array);
        
        // Add the items to the array
        for (TInt i=0; i< KMaxElements; i++)
                User::LeaveIfError(array.Append(values[i]));
        
        // now find the items in linear order
        const TIdentityRelation<TExampleStruct> relation(TExampleStruct::IsEqual);
        User::LeaveIfError(array.Find(s, relation));
        
        CleanupStack::PopAndDestroy(2, values);
        }

// ---------------------------------------------------------
// FindUsingLinearOffsetL
// Finds the items using a linear search offset(horribly inefficient) 
// ---------------------------------------------------------
//
LOCAL_C void FindUsingLinearOffsetL()
        {
        TExampleStruct* values = GenerateValuesLC();

        // We need to make sure our randomly generated
        // data does not contain duplicate copies of the
        // key
        const TExampleStruct& s = values[KSearchIndex];
        for (TInt i= KSearchIndex-1; i>=0; i--)
                {
                if (values[i].iB == s.iB)
                        values[i].iB = 0;
                }       
        
        RExampleArray array(KDefaultGranularity, _FOFF(TExampleStruct, iB));
        CleanupClosePushL(array);
        
        for (TInt i=0; i < KMaxElements; i++)
                User::LeaveIfError(array.Append(values[i]));
        
        // now find the items in offset
        const TInt index = array.Find(s);
        if (index != KSearchIndex)
                User::Leave(KErrNotFound);
        
        CleanupStack::PopAndDestroy(2, values);
        }

// ---------------------------------------------------------
// void FindUsingAKeyL()
// Finds an element using the key style functions 
// ---------------------------------------------------------
//
LOCAL_C void FindUsingAKeyL()
        {
        TExampleStruct* values = GenerateValuesLC();

        RExampleArray array(KDefaultGranularity, _FOFF(TExampleStruct, iA));
        CleanupClosePushL(array);
        
        const TLinearOrder<TExampleStruct> order(TExampleStruct::RelativeAOrdering);
        for (TInt i=0; i < KMaxElements; i++)
                {
                const TInt err = array.InsertInOrder(values[i], order);
                if (err != KErrNone && err != KErrAlreadyExists)
                        User::Leave(err);
                }
        
        const TExampleStruct& s = array[KSearchIndex];
        
        // now find the item using the key function
        const TInt index = array.FindInOrder<TInt>(s.iA, TExampleStruct::KeyCompare);
        if (index != KSearchIndex)
                {
                User::Leave(KErrNotFound);
                }
        
        CleanupStack::PopAndDestroy(2, values);
        }

// ---------------------------------------------------------
// void InsertAndFindExamplesL()
// Inserting and finding examples
// ---------------------------------------------------------
//
void InsertAndFindExamplesL()
        {
        console->Printf(_L("Insert using offset value\n"));
        InsertionUsingKeyOffsetsL();
        User::After(0);

        console->Printf(_L("Insert using Linear order function\n"));
        InsertionUsingFunctionL();
        User::After(0);

        console->Printf(_L("Find using offset value\n"));
        FindUsingLinearOffsetL();
        User::After(0);
        
        
        console->Printf(_L("Find using Linear order function\n"));
        FindUsingLinearSearchL();
        User::After(0);

        console->Printf(_L("Find using the key search function\n"));
        FindUsingAKeyL();
        User::After(0);
        }

---