examples/Base/IPC/condvar/condvarlocal/src/producer.cpp

Go to the documentation of this file.

// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "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:
// Contains the definition of member functions of the CProducer class.
//



#include "producer.h"

CProducer* CProducer::NewL(CConsoleBase* aConsole,CQueue* aTokens)
        {
        CProducer* self = new (ELeave)CProducer;
        CleanupStack::PushL(self);
        self->ConstructL(aConsole,aTokens);
        CleanupStack::Pop(self);
        return self;
        }

void CProducer::ConstructL(CConsoleBase* aConsole,CQueue* aTokens)
        {
        iConsole = aConsole;
        iQueue = aTokens;

        // Create an object of the CPeriodic class.
        iPeriodicProd = CPeriodic::NewL(CActive::EPriorityUserInput);

        // Create the producer thread.
        _LIT(KProducer,"ProducerThread");
        User::LeaveIfError(iProdThread.Create(KProducer,ProdThreadFunc,KDefaultStackSize,KMinHeapSize,256*KMinHeapSize,iQueue,EOwnerThread));
        iProdThread.SetPriority(EPriorityMore);

        // The producer thread invokes the InsertFunction() function every two seconds.
        // Associate InsertFunction() as the call back function for the iPeriodicCons object.
        iPeriodicProd->Start(0,3000000,TCallBack(InsertFunction,this));
        }

CProducer::CProducer()
        {
        }

void CProducer::Display()
        {
        RArray<TInt> array;
        // Initialize the array.
        // The array reflects the contents of the CQueue queue.
        iQueue->GetTokens(array);
        // Print the array.
        iConsole->Printf(KNewLine);
        _LIT(KTextQueue,"Queue Contents:\n[  ");
        iConsole->Printf(KTextQueue);

        _LIT(KTextIntFormat,"%d  ");

        for(TInt ix = 0 ; ix < array.Count() ; ix++)
                {
                iConsole->Printf(KTextIntFormat,array[ix]);
                }

        _LIT(KTextQueueEnd,"]");
        iConsole->Printf(KTextQueueEnd);
        iConsole->Printf(KNewLine);
        iConsole->Printf(KNewLine);
        array.Close();
        }

TInt CProducer::ProdThreadFunc(TAny* aPtr)
        {
        // The while loop mechanism ensures that the thread performs the CQueue::Insert() operation each time RThread::Resume() is invoked on the thread handle.
        while(true)
                {
                CQueue* ptr = (CQueue*)aPtr;
                __ASSERT_ALWAYS(ptr,User::Panic(KTxtPanic,-1));
                // Insert a token into the queue.
                ptr->Insert();
                // Suspend the thread.
                RThread().Suspend();
                }
        return KErrNone;
        }

void CProducer::ResumeProd()
        {
        // Call the RThread::Resume() function on the producer thread.
        // Control goes to the CProducer::ProdThreadFunc() function after this statement.
        iProdThread.Resume();
        }

void CProducer::Produce()
        {
        // Call the CQueue::Insert() function.
        iQueue->Insert();
        }

CProducer::~CProducer()
        {
        iProdThread.Kill(KErrCancel);
        delete iPeriodicProd;
        }


TInt CProducer::InsertFunction(TAny* aPtr)
        {
        CProducer* ptr = static_cast<CProducer*> (aPtr);
        __ASSERT_ALWAYS(ptr,User::Panic(KTxtPanic,-1));
        // Invoke the RThread::Resume() function on the producer thread repeatedly.
        ptr->ResumeProd();
        return KErrNone;
        }

---