taskinterface.hpp

Go to the documentation of this file.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use these files except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Copyright 2012 - Gonzalo Iglesias, Adrià de Gispert, William Byrne

#ifndef TASKINTERFACE_HPP
#define TASKINTERFACE_HPP

namespace ucam {
namespace util {

template <class Data>
class TaskInterface {
 private:
  TaskInterface *next_;

 public:
  TaskInterface() : next_ ( NULL ) { };

  virtual bool run ( Data& d ) = 0;
  virtual ~TaskInterface() {
    if ( next_ ) delete next_;
  };

  inline bool chainrun   ( Data& d ) {
    bool r = run ( d );
    if ( !r  && next_ ) {
      return next_->chainrun ( d );
    };
    return r;
  };
  inline bool operator() ( Data& d ) {
    bool r = run ( d );
    if ( !r  && next_ ) {
      return next_->chainrun ( d );
    };
    return r;
  };

  inline TaskInterface& appendTask ( TaskInterface *t ) {
    if ( t == NULL ) return *this;
    if ( !next_ ) {
      next_ = t;
      return *next_;
    } else return ( *next_ ) ( t );
  };
  inline TaskInterface& operator() ( TaskInterface *t ) {
    if ( t == NULL ) return *this;
    if ( !next_ ) {
      next_ = t;
      return *next_;
    } else return ( *next_ ) ( t );
  };

  inline TaskInterface *getTask() {
    return next_;
  };
  inline TaskInterface *next() {
    return next_;
  };

};

template<class Data>
class TaskFunctor {
 private:
  Data *d_;
  TaskInterface<Data> * task_;
 public:
  TaskFunctor()
    : d_ (NULL)
    , task_ (NULL) {
  };
  TaskFunctor ( TaskInterface<Data> *ti, Data *d )
    : d_ ( d )
    , task_ ( ti ) {
  };

  TaskFunctor (TaskFunctor<Data> const& tf)
    : d_ ( tf.d_)
    , task_ (tf.task_) {
  };

  void operator() () {
    if ( USER_CHECK ( task_ != NULL && d_ != NULL
                      , "TaskFunctor not properly initialized with a task and a data objects" ) ) {
      task_->chainrun ( *d_ );
      delete task_;
      delete d_;
      task_ = NULL;
      d_ = NULL;
    }
    return;
  };

};

}
} // end namespaces

#endif