LoadVariablesThread.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//


#ifndef GNASH_LOADVARIABLESTHREAD_H
#define GNASH_LOADVARIABLESTHREAD_H

#include <string>
#include <map>
#include <boost/scoped_ptr.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp> 

#include "StreamProvider.h" // for inlines
#include "URL.h" // for inlines

namespace gnash {

// Exception thrown by LoadVariablesThread constructor if unable to connect
// to the stream input.
class NetworkException {};

//
class LoadVariablesThread
{
public:
        typedef std::map<std::string, std::string> ValuesMap;

        //
        LoadVariablesThread(const StreamProvider& sp, const URL& url);

        //
        LoadVariablesThread(const StreamProvider& sp, const URL& url,
            const std::string& postdata);

        ~LoadVariablesThread();

        ValuesMap& getValues()
        {
                return _vals;
        }

        void process()
        {
                assert(!_thread.get());
                assert(_stream.get());
                _thread.reset(new boost::thread(
                boost::bind(LoadVariablesThread::execLoadingThread, this)));
        }

        //
        void cancel();

        bool inProgress()
        {
                // TODO: should we mutex-protect this ?
                return ( _thread.get() != NULL );
        }

        //
        bool completed()
        {
                boost::mutex::scoped_lock lock(_mutex);
                if (  _completed && _thread.get() )
                {
                        _thread->join();
                        _thread.reset();
                }
                return _completed;
        }

        size_t getBytesLoaded() const
        {
                // TODO: should we mutex-protect this ?
                return _bytesLoaded;
        }

        size_t getBytesTotal() const
        {
                // TODO: should we mutex-protect this ?
                return _bytesTotal;
        }


private:

        LoadVariablesThread& operator==(const LoadVariablesThread&); 
        LoadVariablesThread(const LoadVariablesThread&); 

        static void execLoadingThread(LoadVariablesThread* ptr)
        {
                //log_debug("LoadVars loading thread started");
                ptr->completeLoad();
                //log_debug("LoadVars loading thread completed");
        }


        void setCompleted()
        {
                boost::mutex::scoped_lock lock(_mutex);
                _completed = true;
                //log_debug("Completed");
        }


        //
        void completeLoad();

        //
        size_t parse(const std::string& str)
        {
                URL::parse_querystring(str, _vals);
                return _vals.size();
        }

        //
        bool cancelRequested();

        size_t _bytesLoaded;

        size_t _bytesTotal;

    boost::scoped_ptr<IOChannel> _stream;

    boost::scoped_ptr<boost::thread> _thread;

        ValuesMap _vals;

        bool _completed;

        bool _canceled;

        boost::mutex _mutex;
};

} // namespace gnash

#endif // GNASH_LOADVARIABLESTHREAD_H