JobDescriptionParserPlugin.h

Go to the documentation of this file.

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_JOBDESCRIPTIONPARSERPLUGIN_H__
#define __ARC_JOBDESCRIPTIONPARSERPLUGIN_H__

#include <map>
#include <string>
#include <utility>
#include <algorithm>

#include <arc/loader/Loader.h>
#include <arc/loader/Plugin.h>


namespace Arc {

  class JobDescription;
  class Logger;

  class JobDescriptionParsingError {
  public:
    JobDescriptionParsingError() {}
    JobDescriptionParsingError(const std::string& message, const std::pair<int, int>& line_pos = std::make_pair(0, 0), const std::string& failing_code = "")
      : message(message), failing_code(failing_code), line_pos(line_pos) {}
    ~JobDescriptionParsingError() {}
    std::string message;
    std::string failing_code;
    std::pair<int, int> line_pos;
  };

  class JobDescriptionParserPluginResult {
  public:
    typedef enum {
      Success,
      Failure, 
      WrongLanguage
    } Result;
    JobDescriptionParserPluginResult(void):v_(Success) { };
    JobDescriptionParserPluginResult(bool v):v_(v?Success:Failure) { };
    JobDescriptionParserPluginResult(Result v):v_(v) { };
    operator bool(void) { return (v_ == Success); };
    bool operator!(void) { return (v_ != Success); };
    bool operator==(bool v) { return ((v_ == Success) == v); };
    bool operator==(Result v) { return (v_ == v); };
    bool HasErrors() const { return !errors_.empty(); };
    const std::list<JobDescriptionParsingError>& GetErrors() const { return errors_; };
    void AddError(const JobDescriptionParsingError& error) { errors_.push_back(error); };
    void AddError(const IString& msg,
                  const std::pair<int, int>& location = std::make_pair(0, 0),
                  const std::string& failing_code = "") {
      errors_.push_back(JobDescriptionParsingError(msg.str(), location, failing_code));
    }
    void SetSuccess() { v_ = Success; };
    void SetFailure() { v_ = Failure; };
    void SetWrongLanguage() {v_ = WrongLanguage; };
  private:
    Result v_;
    std::list<JobDescriptionParsingError> errors_;
  };


  class JobDescriptionParserPlugin
    : public Plugin {
  public:
    virtual ~JobDescriptionParserPlugin();


    virtual JobDescriptionParserPluginResult Parse(const std::string& source, std::list<JobDescription>& jobdescs, const std::string& language = "", const std::string& dialect = "") const = 0;


    virtual JobDescriptionParserPluginResult Assemble(const JobDescription& job, std::string& output, const std::string& language, const std::string& dialect = "") const = 0;


    virtual JobDescriptionParserPluginResult UnParse(const JobDescription& job, std::string& output, const std::string& language, const std::string& dialect = "") const { return Assemble(job, output, language, dialect); };


    const std::list<std::string>& GetSupportedLanguages() const { return supportedLanguages; }


    bool IsLanguageSupported(const std::string& language) const { return std::find(supportedLanguages.begin(), supportedLanguages.end(), language) != supportedLanguages.end(); }


    const std::string& GetError(void) { return error; };

  protected:
    JobDescriptionParserPlugin(PluginArgument* parg);


    std::string& SourceLanguage(JobDescription& j) const;


    std::list<std::string> supportedLanguages;


    mutable std::string error;

    static Logger logger;
  };

  class JobDescriptionParserPluginLoader
    : public Loader {

  public:
    JobDescriptionParserPluginLoader();

    ~JobDescriptionParserPluginLoader();

    JobDescriptionParserPlugin* load(const std::string& name);

    const std::list<JobDescriptionParserPlugin*>& GetJobDescriptionParserPlugins() const { return jdps; }

    class iterator {
    private:
      iterator(JobDescriptionParserPluginLoader& jdpl);
      iterator& operator=(const iterator& it);
    public:
      ~iterator() {}
      //iterator& operator=(const iterator& it) { current = it.current; jdpl = it.jdpl; return *this; }
      JobDescriptionParserPlugin& operator*() { return **current; }
      const JobDescriptionParserPlugin& operator*() const { return **current; }
      JobDescriptionParserPlugin* operator->() { return *current; }
      const JobDescriptionParserPlugin* operator->() const { return *current; }
      iterator& operator++();
      operator bool() { return !jdpl->jdpDescs.empty() || current != jdpl->jdps.end(); }

      friend class JobDescriptionParserPluginLoader;
    private:
      void LoadNext();

      std::list<JobDescriptionParserPlugin*>::iterator current;
      JobDescriptionParserPluginLoader* jdpl;
    };

    iterator GetIterator() { return iterator(*this); }

  private:
    std::list<JobDescriptionParserPlugin*> jdps;
    std::list<ModuleDesc> jdpDescs;

    void scan();
    bool scaningDone;
  };
} // namespace Arc

#endif // __ARC_JOBDESCRIPTIONPARSERPLUGIN_H__