#include <iostream>
#include <boost/regex.hpp>
#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/shared_ptr.hpp>
#include <vector>

class threaded_class
{
        private:
        volatile bool m_stoprequested;
        std::vector<int> m_fibonacci_values;
        boost::mutex m_mutex;
        boost::thread m_thread;
        int nbFibSteps;
        int fib(int num)
        {
                switch(num)
                {
                        case 0: return 0; case 1: return 1;
                        default:
                        return fib(num-2) + fib(num-1);
                };
        }

        void do_work()
        {
                int iteration = 0;
                while (!m_stoprequested &&  iteration<nbFibSteps)
                {
                        int value = fib(++iteration);
                        boost::mutex::scoped_lock l(mutex);
                        m_fibonacci_values.push_back(value);
                }
        }

        public:
        threaded_class()
        : m_stoprequested(false),
nbFibSteps(10),
        m_thread(boost::bind(&threaded_class::do_work, this)) //Note 2
        {}
        ~threaded_class()
        {
        m_stoprequested = true;
        m_thread.join(); //Note 2
}

        int get_fibonacci_value(int _idx)
        {
        boost::mutex::scoped_lock lock(m_mutex);
        return m_fibonacci_values[_idx];
        }
};

int main(int argc, char *argv[])
{
        threaded_class fibcalc;
        fibcalc.get_fibonacci_value(4);
        return 0;
}

CC=g++
CFLAGS=-c -Wall
LDFLAGS=
SOURCES=hello.cpp
OBJECTS=$(SOURCES:.cpp=.o)
EXECUTABLE=hello
LDFLAGS = -L/usr/lib -l boost_regex -l boost_thread
INCLUDEPATH = -I/usr/include/boost

all: $(SOURCES) $(EXECUTABLE)
    
$(EXECUTABLE): $(OBJECTS) 
    $(CC) $(LDFLAGS) $(OBJECTS) -o $@

.cpp.o:
    $(CC) $(CFLAGS) $< -o $@