/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

/*

 * This file is part of LibreOffice published API.

 */

#ifndef INCLUDED_OSL_CONDITN_HXX

#define INCLUDED_OSL_CONDITN_HXX

#include "sal/config.h"

#include <cstddef>

#include "osl/time.h"

#include "osl/conditn.h"

#if defined(MACOSX) && defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)

#   if __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES == 1

#       undef check

#   endif

#endif

namespace osl

{

    /** Condition variable

       A condition variable is essentially an object that is initially

       cleared which a thread waits on until it is "set". It allows a

       thread to synchronize execution by allowing other threads to wait

       for the condition to change before that thread then continues

       execution.

       @deprecated use C++11's std::condition_variable instead

            for a more robust and helpful condition.

       @attention Warning: the Condition abstraction is inadequate for

            any situation where there may be multiple threads setting,

            waiting, and resetting the same condition. It can only be

            used to synchronise interactions between two threads

            cf. lost wakeups in http://www.cs.wustl.edu/~schmidt/win32-cv-1.html

    */

    class Condition

    {

    public:

        enum Result

        {

            result_ok      = osl_cond_result_ok,        /*!< Successful completion.                         */

            result_error   = osl_cond_result_error,     /*!< Error occurred. @see osl_getLastSocketError() */

            result_timeout = osl_cond_result_timeout    /*!< Blocking operation timed out.                 */

        };

        /** Create a condition.

            @deprecated use C++11's std::condition_variable instead

                for a more robust and helpful condition.

        */

        Condition()

        {

            condition = osl_createCondition();

        }

        /** Release the OS-structures and free condition data-structure.

            @deprecated use C++11's std::condition_variable instead

                for a more robust and helpful condition.

        */

        ~Condition()

        {

            osl_destroyCondition(condition);

        }

        /** Release all waiting threads, check returns true.

            @deprecated use C++11's std::condition_variable instead

                for a more robust and helpful condition.

        */

        void set()

        {

            osl_setCondition(condition);

        }

        /** Reset condition to false: wait() will block, check() returns

            false.

            @deprecated use C++11's std::condition_variable instead

                        for a more robust and helpful condition.

        */

        void reset() {

            osl_resetCondition(condition);

        }

        /** Blocks the calling thread until condition is set.

            @param [in] pTimeout Timeout to wait before ending the condition.

                Defaults to NULL

            @retval result_ok       finished successfully

            @retval result_error    error occurred

            @retval result_timeout  timed out

            @deprecated use C++11's std::condition_variable instead

                for a more robust and helpful condition.

        */

        Result wait(const TimeValue *pTimeout = NULL)

        {

            return static_cast<Result>(osl_waitCondition(condition, pTimeout));

        }

#if defined LIBO_INTERNAL_ONLY

        Result wait(TimeValue const & timeout) { return wait(&timeout); }

#endif

        /** Checks if the condition is set without blocking.

            @retval true   condition is set

            @retval false  condition is not set

            @deprecated use C++11's std::condition_variable instead

                for a more robust and helpful condition.

        */

        bool check()

        {

            return osl_checkCondition(condition);

        }

    private:

        oslCondition condition;     /*< condition variable */

        /** Copy constructor

            The underlying oslCondition has no reference count.

            Since the underlying oslCondition is not a reference counted

            object, copy constructed Condition may work on an already

            destructed oslCondition object.

            @deprecated use C++11's std::condition_variable instead

                for a more robust and helpful condition.

        */

        Condition(const Condition& condition) SAL_DELETED_FUNCTION;

        /** This assignment operator is deleted for the same reason as

            the copy constructor.

            @deprecated use C++11's std::condition_variable instead

                for a more robust and helpful condition.

        */

        Condition& operator= (const Condition&) SAL_DELETED_FUNCTION;

    };

}

#endif // INCLUDED_OSL_CONDITN_HXX

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */