MC_string_helper.cpp

Go to the documentation of this file.

#include <algorithm>
#include <fstream>
#include <cmath>

#include <MC_string_helper.hpp>

namespace mesh_conv
{
  

  // helper to tokenize
  std::vector<std::string> MC_string_tokenizer::tokenize(const std::string& str,const std::string& delimiters)
  {
    std::vector<std::string> tokens;
    std::string::size_type delimPos = 0, tokenPos = 0, pos = 0;
    
    if(str.length()<1)  return tokens;
    while(1){
      delimPos = str.find_first_of(delimiters, pos);
      tokenPos = str.find_first_not_of(delimiters, pos);
      
      if(std::string::npos != delimPos){
        if(std::string::npos != tokenPos){
          if(tokenPos<delimPos){
            tokens.push_back(str.substr(pos,delimPos-pos));
          }else{
            tokens.push_back("");
          }
        }else{
          tokens.push_back("");
        }
        pos = delimPos+1;
      } else {
        if(std::string::npos != tokenPos){
          tokens.push_back(str.substr(pos));
        } else {
          tokens.push_back("");
        }
        break;
      }
    }
    return tokens;
  }

  std::string MC_string_converter::zero_padding(const std::string& input,const int& zero_number)
  {
      std::string current_string=input;
      int current_length=input.size();
      for(int k=0;k<zero_number-current_length;k++)
          current_string=std::string("0")+current_string;
      return current_string;
  }
  std::string MC_string_converter::to_lower(const std::string& input)
  {
      std::string res("");
      for(unsigned int k=0;k<input.length();++k)
          res+=std::tolower(input[k],std::cout.getloc ());
      return res;
  }
  std::string MC_string_converter::to_upper(const std::string& input)
  {
      std::string res("");
      for(unsigned int k=0;k<input.length();++k)
          res+=std::toupper(input[k],std::cout.getloc ());
      return res;
  }

  std::vector <std::string> MC_string_converter::delete_empty(const std::vector <std::string>& in)
  {
      std::vector <std::string> res;

      int N=in.size();
      for(int k=0;k<N;++k)
          if(in[k]!=" " && in[k]!="")
              res.push_back(in[k]);
      return res;
  }

  MC_file_helper MC_file_helper::copy(const std::string& input_filename,const std::string& output_filename)
  {
      std::ifstream input(input_filename.c_str(),std::ifstream::in);
      std::ofstream output(output_filename.c_str(),std::ifstream::out);

      if(input.is_open()==false)
      {std::cout<<"Error in MC_file_helper::copy("<<input_filename<<","<<output_filename<<"), the file "<<input_filename<<" cannot be opened"<<std::endl;exit(-1);}
      if(output.is_open()==false)
      {std::cout<<"Error in MC_file_helper::copy("<<input_filename<<","<<output_filename<<"), the file "<<output_filename<<" cannot be opened"<<std::endl;exit(-1);}

      char buffer[static_cast<int>(pow(2,16))];
      while(input.good())
      {
          input.getline(buffer,static_cast<int>(pow(2,16)));
          if(input.good())
              output<<std::string(buffer)+"\n";
      }


      input.close();
      output.close();

      return MC_file_helper();
  }


  std::pair<std::pair<int,int>,std::pair<std::string,std::string> > MC_string_converter::extract_number_part(const std::string& filename)
  {
    int N=filename.length();

    bool is_number=false;
    int last_position_number=-1;
    int first_position_number=-1;
    for(int k=N-1;k>=0;--k)
    {
        if(filename[k]>='0' && filename[k]<='9')
            is_number=true;
        else
            is_number=false;
        if(last_position_number==-1 && is_number==true)
            last_position_number=k;
        if(first_position_number==-1 && is_number==false && last_position_number!=-1)
            first_position_number=k;
    }


    std::string part_1=filename.substr(0,first_position_number+1);
    std::string part_2=filename.substr(last_position_number+1,filename.length());


    std::string number=filename.substr(first_position_number+1,last_position_number-first_position_number);

    int N_zero=-1;
    for(unsigned int k=0;k<number.length();++k)
    {
        if(number[k]!='0' && N_zero==-1)
            N_zero=k;
    }
    if(N_zero==-1)
        N_zero=number.length()-1;

    bool is_ok=true;
    int current_number=value_of<int>(number,&is_ok);

    if(is_ok==false)
        return std::make_pair(std::make_pair(-1,-1),std::make_pair(filename,std::string()));

    return std::make_pair(std::make_pair(current_number,N_zero),std::make_pair(part_1,part_2));

  }

  std::vector<std::string> MC_string_converter::load_filename_sequence(const std::string filename,const unsigned int& iteration)
  {
      //extract informations from the filename
      std::pair<std::pair<int,int>,std::pair<std::string,std::string> > info=MC_string_converter::extract_number_part(filename);


      std::vector<std::string> v_file;

      //std::cout<<info.first.first<<","<<info.first.second<<std::endl;
      if(info.first.second==-1)
      {
          v_file.push_back(filename);
          return v_file;
      }

      int zero_pad=info.first.second+(MC_string_converter::to_string(info.first.first).length());

      bool is_continue=true;
      std::ifstream file;
      int k=info.first.first;
      do
      {
          std::string number=MC_string_converter::zero_padding(MC_string_converter::to_string(k),zero_pad);
          std::string current_file=info.second.first+number+info.second.second;



          file.open(current_file.c_str());
          if(file.good()==false)
              is_continue=false;
          else
              v_file.push_back(current_file);

          //std::cout<<current_file<<" "<<is_continue<<std::endl;
          file.close();
          k+=iteration;
      }while(is_continue==true);

      return v_file;

  }


}