runtime1.cpp

Go to the documentation of this file.

#include "eleve/config.hpp"

#include "runtime1.hpp"

#include <fstream>

#include <boost/filesystem/operations.hpp>
#include <ql/utilities/tracing.hpp>

namespace eepgwde { namespace detail {
  
  static boost::regex_constants::syntax_option_type
  flags = boost::regex_constants::basic;

  namespace fs = boost::filesystem;
  
  class Facilities::Impl {
  public:
    Impl() throw() {}
    ~Impl() throw() {}
    Facilities *owner; 
  };

  Facilities::Facilities() throw(std::exception) :
    impl(new Facilities::Impl) {
    impl->owner = this;
  }

  Facilities::~Facilities() throw(std::exception) {}


  int Facilities::files(std::insert_iterator< std::set<fs::path> > set_,
            fs::path full_path, boost::regex re) const {
    unsigned long file_count = 0;
    unsigned long err_count = 0;
    unsigned long matches = 0;

    if (!fs::exists( full_path )) return -1;

    if (!fs::is_directory( full_path)) return -1;

    fs::directory_iterator end_iter;
    std::string t;
    boost::smatch what;

    for ( fs::directory_iterator dir_itr( full_path );
      dir_itr != end_iter;
      ++dir_itr ) {
      try {
    if ( fs::is_regular( dir_itr->status() ) ) {
      ++file_count;
    
      t = dir_itr->path().leaf();
      if (boost::regex_search(t, what, re)) {
        *set_++=dir_itr->path();
        ++matches;
      }
    }
      }
      catch ( const std::exception & ex ) {
    ++err_count;
      }
    }
    return matches;
  }


  int Facilities::files
  (std::insert_iterator< std::set<fs::path> > set_) const {
    return files(set_, fs::path("."), boost::regex(".+") );
  }

  std::vector<std::string> Facilities::readlines(const fs::path & s)
    const throw(std::exception) {
    std::ifstream ifs(s.string().c_str(), ios::in);
    std::istream & is = ifs;
    return readlines(is);
  }

  std::vector<std::string> Facilities::readlines(std::istream & is) const
    throw(std::exception) {
    if (is.bad()) {
      QL_TRACE("bad input stream");
      throw std::runtime_error("input stream is bad");
    }
    
    std::vector<std::string> results;

    char buffer[100];
    while (!is.getline(buffer, 100).eof()) {
      results.push_back(std::string(buffer));
    }

    return results;
  }

}}

---