/home/rex/ebltrunk/tools/libeblearntools/include/thread.h

/***************************************************************************
 *   Copyright (C) 2010 by Pierre Sermanet *
 *   pierre.sermanet@gmail.com *
 *   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.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``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 AUTHORS 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.
 ***************************************************************************/

#ifndef THREAD_H_
#define THREAD_H_

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include "utils.h"

#ifdef __PTHREAD__
#include <pthread.h>
#endif

namespace ebl {

  // mutex
  
  class EXPORT mutex {
  public:
    mutex();
    ~mutex();

    bool trylock();

    void lock();

    void unlock();

  protected:
#ifdef __PTHREAD__




    pthread_mutex_t m;
#endif
  };
  
  // sbuf

  class mutex_ostream;

  // Specialize a stringbuf to handle flushing to unblock mutex.
  class EXPORT sbuf : public std::stringbuf {
  public:

    sbuf(std::ostream &o, mutex *m = NULL, const char *prefix = NULL);
    ~sbuf();
    
    // When we sync the stream with the output. 
    // 1) Output prefix then the buffer
    // 2) Reset the buffer
    // 3) flush the actual output stream we are using. 
    virtual int sync();
    virtual streamsize xsputn(const char *s, streamsize n);

    friend class mutex_ostream;
    
  private:
    std::ostream& out;
    bool new_line; 
    bool own_lock; 
    mutex *busy; 
    const char *prefix;
  };

  // mutex_ostream

  class EXPORT mutex_ostream : public std::ostream {
  public:
    mutex_ostream(std::ostream &o, mutex *m = NULL, const char *prefix = NULL);
    ~mutex_ostream();

  protected:
    sbuf buffer;
  };
  
  // thread 
  
  class EXPORT thread {
  public:
    thread(mutex *outmutex = NULL, const char *name = "Thread",
           bool sync = true);
    virtual ~thread();
    int start();

    void stop(long wait_seconds = 0);

    void ask_stop();

    bool finished();

    std::string& name();

    std::ostream& get_mout();

    std::ostream& get_merr();

  protected:
    void run();
    static void* entrypoint(void *pthis);
    virtual void execute() = 0;

  protected:    
    bool                _stop;
    std::string         _name;  
    mutex_ostream       mutout; // synchronized cout
    mutex_ostream       muterr; // synchronized cerr
    ostream             &mout; // may contained synced or standard output
    ostream             &merr; // may contained synced or standard err output
  private:
#ifdef __PTHREAD__
    pthread_t           threadptr;
#endif
    mutex               mutex1;
    bool                _finished;
  };

} // end namespace ebl

#endif /* THREAD_H_ */