// Copyright (c) 2005-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:

// Name        : condvar.cpp

// Part of     : pthread

// Interface   : POSIX, pthread

// POSIX implementation of pthread on Symbian

// Version     :

//

#include "condvartypes.h"

/*

This internal function initializes the passed queue to be an empty queue

*/

bool _QueueInit(_CondQueue* aQueue)

{

    if(!aQueue)

    {

        return false;

    }

    pthread_mutex_init(&aQueue->iMutex,NULL);

    aQueue->iHead = aQueue->iTail = NULL;

    return true;

}

/*

This internal function destroys the passed 

*/

int _QueueDestroy(_CondQueue* aQueue)

{

    if(!aQueue)

    {

        return EINVAL;

    }

    pthread_mutex_lock(&aQueue->iMutex);

    _CondNode* head = aQueue->iHead;

    pthread_mutex_unlock(&aQueue->iMutex);

    if (head) 

    {

        return EBUSY;   

    }

    else

    {

        return pthread_mutex_destroy(&aQueue->iMutex);

    }

}

/*

This internal function atomically adds a element

to the passed queue

*/

bool _QueueAdd(_CondQueue* aQueue, _CondNode* aNode)

{

    if( (!aQueue) || (!aNode) )

    {

        return false;

    }

    aNode->iNext = NULL;

    pthread_mutex_lock(&aQueue->iMutex);

    if(!(aQueue->iHead))

    {

        aQueue->iHead = aQueue->iTail = aNode;

    }

    else

    {

        aQueue->iTail->iNext = aNode;

        aQueue->iTail = aNode;

    }

    pthread_mutex_unlock(&aQueue->iMutex);

    return true;

}

/*

This internal function atomically removes the pased element

from the queue

*/

bool _QueueRemove(_CondQueue* aQueue, _CondNode* aNode)

{

    if( (!aQueue) || (!aNode) )

    {

        return false;

    }

    pthread_mutex_lock(&aQueue->iMutex);

    _CondNode* prev = NULL;

    _CondNode* node = aQueue->iHead;

    for(; node; node = node->iNext)

    {

        if(node == aNode)

        {

            break;

        }

        prev = node;

    }

    if(node)

    {

        if(node == aQueue->iHead)

        {

            aQueue->iHead = node->iNext;

        }

        if(node == aQueue->iTail)

        {

            aQueue->iTail = prev;

        }

        if(prev)

        {

            prev->iNext = node->iNext;

        }

    }// node found

    pthread_mutex_unlock(&aQueue->iMutex);

    return (node) ? true : false;

}

/*

This internal function atomically removes the head of the queue, and

returns a pointer to this node

*/

_CondNode* _QueueRemoveHead(_CondQueue* aQueue)

{

    _CondNode* retNode = NULL;

    pthread_mutex_lock(&aQueue->iMutex);

    retNode = aQueue->iHead;

    if(retNode)

    {

        aQueue->iHead = retNode->iNext;

        if(aQueue->iTail == retNode)

        {

            aQueue->iTail = aQueue->iHead = NULL;

        }

    }

    pthread_mutex_unlock(&aQueue->iMutex);

    return retNode;

}

/*

This internal function  removes the head of the queue, and

returns a pointer to this node WITHOUT locking the associated mutex

*/

_CondNode* _QueueRemoveHeadNoLock(_CondQueue* aQueue)

{

    _CondNode* retNode = NULL;

    retNode = aQueue->iHead;

    if(retNode)

    {

        aQueue->iHead = retNode->iNext;

        if(aQueue->iTail == retNode)

        {

            aQueue->iTail = aQueue->iHead = NULL;

        }

    }

    return retNode;

}

/*

This internal function  locks the queue mutex

*/

void  _QueueLock(_CondQueue* aQueue)

{

    pthread_mutex_lock(&aQueue->iMutex);

}

/*

This internal function  unlocks the queue mutex

*/

void  _QueueUnlock(_CondQueue* aQueue)

{

    pthread_mutex_unlock(&aQueue->iMutex);

}

/*

This internal function atomically resolves the race to dynamically initialize a static cond var

*/

bool _staticCondInit(pthread_cond_t* cond)

{

    if(!cond)

    {

        return false;

    }

    if(cond->iState == _EInitialized)

    {

        return true;

    }

    if(cond->iState != _ENeedsNormalInit)

    {

        return false;

    }

    int retval=0;

    #ifndef NOUSE_INTERNALS

    void* tlsPtr;

    // Get the TLS pointer

    tlsPtr = _pthread_getTls();  

    if(NULL == tlsPtr)

    {

        return false;

    }

    _pthread_atomicMutexLock(tlsPtr);

    #endif

    //another thread might win race

    if(cond->iState != _EInitialized)

    {

        retval = pthread_cond_init(cond,NULL);

    }

    #ifndef NOUSE_INTERNALS

    _pthread_atomicMutexUnlock(tlsPtr);

    #endif

    if(retval == 0)

    {

        return true;

    }

    else

    {

        return false;

    }

}

/*

This internal function provides the functionality to wait on a condition variable,

*/

int _internalCondWait(pthread_cond_t *cond, pthread_mutex_t *mutex,const struct timespec *abstime)

{

    if(!_staticCondInit(cond))

    {

        return EINVAL;

    }

    _CondNode* newNode = new _CondNode;  

    if(!newNode)

    {

        return ENOMEM;

    }

    sem_init(&newNode->iSemaphore,0,0);

    _QueueAdd(&cond->iQueue,newNode);

    int retval=0;

    //unlock passed mutex

    retval = pthread_mutex_unlock(mutex);

    if(retval != 0)

    {

        _QueueRemove(&cond->iQueue,newNode);

        sem_destroy(&newNode->iSemaphore);

        delete newNode; 

        errno = 0; // Condition variables should not set errno

        return retval;

    }    

    //node removed from queue by pthread_cond_signal or pthread_cond_broadcast

    //by timeout below

    if(abstime)

    {

        retval = sem_timedwait(&newNode->iSemaphore,abstime);   

        if(retval != 0)

        {

            _QueueRemove(&cond->iQueue,newNode);

        }//timed_wait timedout

    }

    else

    {

        retval = sem_wait(&newNode->iSemaphore);    

    }

    if(retval != 0)

    {

        retval = errno;

    }

    sem_destroy(&newNode->iSemaphore);

    delete newNode; 

    /* This is a cancellation point */

    //test for cancel

    pthread_testcancel();

    //lock the passed mutex

    pthread_mutex_lock(mutex);

    errno = 0; // Condition variables should not set errno

    return retval;

}

//End of File