orthanc: UnitTestsSources/MultiThreading.cpp comparison

comparison UnitTestsSources/MultiThreading.cpp @ 779:76eb563f08f0 lua-scripting

improvements

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 30 Apr 2014 18:10:16 +0200
parents	9ae0bb3f188b
children	f0ac3a53ccf2

comparison

equal deleted inserted replaced

-:9ae0bb3f188b
+:76eb563f08f0
 #include <boost/lexical_cast.hpp>
 namespace Orthanc
 {
-typedef std::list<std::string>  ListOfStrings;
 class IServerFilter
 {
 public:
+typedef std::list<std::string>  ListOfStrings;
 virtual ~IServerFilter()
 {
 }
 virtual bool Apply(ListOfStrings& outputs,
 const ListOfStrings& inputs) = 0;
+virtual bool SendOutputsToSink() const = 0;
 };
 class Sink : public IServerFilter
 {
 ListOfStrings& target_;
 public:
 Sink(ListOfStrings& target) : target_(target)
 {
+}
+virtual bool SendOutputsToSink() const
+{
+return false;
 }
 virtual bool Apply(ListOfStrings& outputs,
 const ListOfStrings& inputs)
 {
 virtual void SignalFailure(const std::string& jobId) = 0;
 };
-class FilterWrapper : public IDynamicObject
+class ServerFilterInstance : public IDynamicObject
 {
 friend class ServerScheduler;
 private:
+typedef IServerFilter::ListOfStrings  ListOfStrings;
 IServerFilter *filter_;
 std::string jobId_;
 ListOfStrings inputs_;
-std::list<FilterWrapper*> next_;
+std::list<ServerFilterInstance*> next_;
 bool Execute(IServerFilterListener& listener)
 {
 ListOfStrings outputs;
 if (!filter_->Apply(outputs, inputs_))
 {
 listener.SignalFailure(jobId_);
 return true;
 }
-for (std::list<FilterWrapper*>::iterator
+for (std::list<ServerFilterInstance*>::iterator
 it = next_.begin(); it != next_.end(); it++)
 {
 for (ListOfStrings::const_iterator
 output = outputs.begin(); output != outputs.end(); output++)
 {
 return true;
 }
 public:
-FilterWrapper(IServerFilter *filter,
+ServerFilterInstance(IServerFilter *filter,
 const std::string& jobId) :
 filter_(filter),
 jobId_(jobId)
 {
 if (filter_ == NULL)
 {
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
 }
-virtual ~FilterWrapper()
+virtual ~ServerFilterInstance()
 {
 if (filter_ != NULL)
 {
 delete filter_;
 }
 void AddInput(const std::string& input)
 {
 inputs_.push_back(input);
 }
-void ConnectNext(FilterWrapper& filter)
+void ConnectNext(ServerFilterInstance& filter)
 {
 next_.push_back(&filter);
 }
-const std::list<FilterWrapper*>& GetNextFilters() const
+const std::list<ServerFilterInstance*>& GetNextFilters() const
 {
 return next_;
 }
+IServerFilter& GetFilter() const
+{
+return *filter_;
+}
 };
 class ServerJob
 {
 friend class ServerScheduler;
 private:
-std::list<FilterWrapper*> filters_;
+std::list<ServerFilterInstance*> filters_;
 std::string jobId_;
 bool submitted_;
 std::string description_;
 void CheckOrdering()
 {
-std::map<FilterWrapper*, unsigned int> index;
+std::map<ServerFilterInstance*, unsigned int> index;
 unsigned int count = 0;
-for (std::list<FilterWrapper*>::const_iterator
+for (std::list<ServerFilterInstance*>::const_iterator
 it = filters_.begin(); it != filters_.end(); it++)
 {
 index[*it] = count++;
 }
-for (std::list<FilterWrapper*>::const_iterator
+for (std::list<ServerFilterInstance*>::const_iterator
 it = filters_.begin(); it != filters_.end(); it++)
 {
-const std::list<FilterWrapper*>& nextFilters = (*it)->GetNextFilters();
+const std::list<ServerFilterInstance*>& nextFilters = (*it)->GetNextFilters();
-for (std::list<FilterWrapper*>::const_iterator
+for (std::list<ServerFilterInstance*>::const_iterator
 next = nextFilters.begin(); next != nextFilters.end(); next++)
 {
 if (index.find(*next) == index.end() ||
 index[*next] <= index[*it])
 {
 CheckOrdering();
 size_t size = filters_.size();
-for (std::list<FilterWrapper*>::iterator
+for (std::list<ServerFilterInstance*>::iterator
 it = filters_.begin(); it != filters_.end(); it++)
 {
 target.Enqueue(*it);
 }
 description_ = "no description";
 }
 ~ServerJob()
 {
-for (std::list<FilterWrapper*>::iterator
+for (std::list<ServerFilterInstance*>::iterator
 it = filters_.begin(); it != filters_.end(); it++)
 {
 delete *it;
 }
 }
 const std::string& GetDescription() const
 {
 return description_;
 }
-FilterWrapper& AddFilter(IServerFilter* filter)
+ServerFilterInstance& AddFilter(IServerFilter* filter)
 {
 if (submitted_)
 {
 throw OrthancException(ErrorCode_BadSequenceOfCalls);
 }
-filters_.push_back(new FilterWrapper(filter, jobId_));
+filters_.push_back(new ServerFilterInstance(filter, jobId_));
 return *filters_.back();
 }
 };
 JobStatus_Running = 1,
 JobStatus_Success = 2,
 JobStatus_Failure = 3
 };
+typedef IServerFilter::ListOfStrings  ListOfStrings;
 typedef std::map<std::string, JobInfo> Jobs;
 boost::mutex mutex_;
 boost::condition_variable jobFinished_;
 Jobs jobs_;
 while (!that->finish_)
 {
 std::auto_ptr<IDynamicObject> object(that->queue_.Dequeue(TIMEOUT));
 if (object.get() != NULL)
 {
-FilterWrapper& filter = dynamic_cast<FilterWrapper&>(*object);
+ServerFilterInstance& filter = dynamic_cast<ServerFilterInstance&>(*object);
 // Skip the execution of this filter if its parent job has
 // previously failed.
 bool jobHasFailed;
 {
 return true;
 }
 // Add a sink filter to collect all the results of the filters
 // that have no next filter.
-FilterWrapper& sink = job.AddFilter(new Sink(outputs));
+ServerFilterInstance& sink = job.AddFilter(new Sink(outputs));
-for (std::list<FilterWrapper*>::iterator
+for (std::list<ServerFilterInstance*>::iterator
 it = job.filters_.begin(); it != job.filters_.end(); it++)
 {
 if ((*it) != &sink &&
-(*it)->GetNextFilters().size() == 0)
+(*it)->GetNextFilters().size() == 0 &&
+(*it)->GetFilter().SendOutputsToSink())
 {
 (*it)->ConnectNext(sink);
 }
 }
 Toolbox::USleep(1000000);
 return true;
 }
+virtual bool SendOutputsToSink() const
+{
+return true;
+}
 };
 static void Tata(ServerScheduler* s, ServerJob* j, bool* done)
 {
+typedef IServerFilter::ListOfStrings  ListOfStrings;
 #if 1
 while (!(*done))
 {
 ListOfStrings l;
 s->GetListOfJobs(l);
 TEST(Toto, Toto)
 {
 ServerScheduler scheduler;
 ServerJob job;
-FilterWrapper& f2 = job.AddFilter(new Tutu(2));
+ServerFilterInstance& f2 = job.AddFilter(new Tutu(2));
-FilterWrapper& f3 = job.AddFilter(new Tutu(3));
+ServerFilterInstance& f3 = job.AddFilter(new Tutu(3));
-FilterWrapper& f4 = job.AddFilter(new Tutu(4));
+ServerFilterInstance& f4 = job.AddFilter(new Tutu(4));
-FilterWrapper& f5 = job.AddFilter(new Tutu(5));
+ServerFilterInstance& f5 = job.AddFilter(new Tutu(5));
 f2.AddInput(boost::lexical_cast<std::string>(42));
 //f3.AddInput(boost::lexical_cast<std::string>(42));
 //f4.AddInput(boost::lexical_cast<std::string>(42));
 f2.ConnectNext(f3);
 f3.ConnectNext(f4);
 boost::thread t(Tata, &scheduler, &job, &done);
 //scheduler.Submit(job);
-ListOfStrings l;
+IServerFilter::ListOfStrings l;
 scheduler.SubmitAndWait(l, job);
-for (ListOfStrings::iterator i = l.begin(); i != l.end(); i++)
+for (IServerFilter::ListOfStrings::iterator i = l.begin(); i != l.end(); i++)
 {
 printf("** %s\n", i->c_str());
 }
 //Toolbox::ServerBarrier();

Mercurial > hg > orthanc

comparison UnitTestsSources/MultiThreading.cpp @ 779:76eb563f08f0 lua-scripting