/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/smanip

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_smanip
#define inlib_smanip

#include "sep"

#include <vector>
#include <cstring>

#include "sout"   //for back compatibility.
#include "words"  //for back compatibility.
#include "sto"    //for back compatibility.
#include "strip"  //for back compatibility.
#include "path"   //for back compatibility.
#include "sjust"  //for back compatibility.
#include "srep"  //for back compatibility.

namespace inlib {

inline bool belong(const std::vector<std::string>& a_vec,
                   const std::string& a_s) {
  std::vector<std::string>::const_iterator it;
  for(it=a_vec.begin();it!=a_vec.end();++it) {
    if(*it==a_s) return true;
  }
  return false;
}

inline bool match(const std::string& a_string,const std::string& a_pattern){
  std::string::size_type lpattern = a_pattern.length();
  std::string::size_type lstring  = a_string.length();
  if ((lpattern==0)&&(lstring==0)) return true;
  if ((lpattern==0)&&(lstring!=0)) return true;
  if ((lpattern!=0)&&(lstring==0)) return false;

  if(a_pattern=="*") return true; // pattern is * :

 {bool some_star = false;
  for(unsigned int count=0;count<lpattern;count++) {
    if(a_pattern[count]=='*') {some_star = true;break;}
  }
  if(!some_star) {  // no wildcard :
    return (a_pattern==a_string ? true : false );
  }}

  // complex pattern :
  std::vector<std::string> ws;
  words(a_pattern,"*",false,ws);  
  if(ws.empty()) return true; // only wildcards :

  // tricky case :
  unsigned int wnumber = ws.size();
  char* token = (char*)a_string.c_str();
 {for(unsigned int count=0;count<wnumber;count++) { 
    unsigned int lword = ws[count].size(); 
    if(!lword) continue;//should never happen !
    if(count==0) {
      if(a_pattern[0]!='*') {
        // Begin of pattern (ws[0]) and a_string must match :
        if(::strncmp(token,ws[count].c_str(),lword)) return false;
        token = token + lword;
        continue;
      }
    }
    char* pos = ::strstr(token,ws[count].c_str());
    if(!pos) return false;
    if((count==(wnumber-1)) && (a_pattern[lpattern-1]!='*') ) { // Last word.
      // Compare last word and end of a_string.
      if(::strcmp(a_string.c_str()+lstring-lword,ws[count].c_str())) 
        return false;
      break;
    } else {
      token = pos + lword;
    }
  }}
  return true;
}

inline unsigned int numchar(const std::string& a_string,char a_c){
  unsigned int num = 0;  
  std::string::const_iterator it;
  for(it=a_string.begin();it!=a_string.end();++it) {
    if((*it)==a_c) num++;
  }
  return num;
}

inline void replace(std::string& a_string,char a_old,char a_new){
  for(std::string::iterator it=a_string.begin();it!=a_string.end();++it) {
    if((*it)==a_old) *it = a_new;
  }
}

inline std::vector<std::string> path_words(const std::string& a_path,bool& a_absolute,bool& a_win_path,std::string& a_drive){

  //  a_path could be at the Windows syntax : <drive>:\dir1\dir2...
  // If so, only dir1, dirn are put in a_words.

  std::string path = a_path;
  std::string::size_type pos = path.find('\\');
  a_win_path = (pos==std::string::npos?false:true);
  if(a_win_path) {
    replace(path,"\\","/");
    pos = path.find(':');
    if(pos!=std::string::npos) { //drive 
      a_drive = path.substr(0,pos);
      path = path.substr(pos+1,path.size()-(pos+1));
    } else {
      a_drive = "";
    }
  } else {
    a_drive = "";
  }

  a_absolute = (path.size()&&(path[0]=='/')?true:false);

  return words(path,"/");
}

inline bool remove(std::vector<std::string>& a_strings,const std::string& a_string){
  bool found_some = false;
  //std::vector<std::string>::iterator it;
  //for(it=a_strings.begin();it!=a_strings.end();) {
  //  if(*it==a_string) {
  //    it = a_strings.erase(it);
  //    found_some = true;
  //  } else {
  //    ++it;
  //  }
  //}
  //brut force avoiding erase(). For Android + inlib/stl.
  std::vector<std::string> ss;
  std::vector<std::string>::iterator it;
  for(it=a_strings.begin();it!=a_strings.end();++it) {
    if(*it==a_string) {
      found_some = true;
    } else {
      ss.push_back(*it);
    }
  }
  a_strings = ss;
  return found_some;
}

inline void tolowercase(std::string& a_string){
  for(std::string::iterator it=a_string.begin();it!=a_string.end();++it) {
    char c = *it;
    *it = ((c) >= 'A' && (c) <= 'Z' ?  c - 'A' + 'a' : c);
  }
}

inline void touppercase(std::string& a_string){
  for(std::string::iterator it=a_string.begin();it!=a_string.end();++it) {
    char c = *it;
    *it = ((c) >= 'a' && (c) <= 'z' ?  c - 'a' + 'A' : c);
  }
}

inline bool is_ip(const std::string& a_string){
  if(a_string.empty()) return false;
  if(a_string[0]=='.') return false;
  if(a_string[a_string.size()-1]=='.') return false;
  unsigned int ndot = 0;  
  std::string::const_iterator it;
  for(it=a_string.begin();it!=a_string.end();++it) {
    if((*it)=='.') {
      ndot++;
    } else if( ((*it)=='0') || ((*it)=='1') ||
               ((*it)=='2') || ((*it)=='3') ||
               ((*it)=='4') || ((*it)=='5') ||
               ((*it)=='6') || ((*it)=='7') ||
               ((*it)=='8') || ((*it)=='9') ){
    } else {
      return false;
    }
  }
  if(ndot!=3) return false;
  return true;
}

//used in OpenPAW, BatchLab.
inline bool is_f77(const std::string& a_path){
  std::string sfx = suffix(a_path);
  tolowercase(sfx);
  if(sfx=="f") return true;       //the standard.
  if(sfx=="for") return true;     //for opaw. Known by g77.
  if(sfx=="ftn") return true;     //for opaw.
  if(sfx=="fortran") return true; //for opaw.
  if(sfx=="f77") return true;
  return false;
}

//used in OpenPAW, BatchLab.
inline bool is_cpp(const std::string& a_path){
  std::string sfx = suffix(a_path);
  tolowercase(sfx);
  if(sfx=="c") return true;
  if(sfx=="cxx") return true;
  if(sfx=="cpp") return true;
  if(sfx=="C") return true;
  return false;
}

inline std::string to_xml(const std::string& a_string){
  // > : &lt;
  // < : &gt;
  // & : &amp;
  // " : &quot;
  // ' : &apos;
  std::string s = a_string;
  replace(s,"<","&lt;");
  replace(s,">","&gt;");
  replace(s,"&","&amp;");
  replace(s,"\"","&quot;");
  replace(s,"'","&apos;");
  return s;
}

inline std::string to_string(const std::vector<std::string>& a_strings,const std::string& a_sep,bool a_sep_at_end = false){
  unsigned int number = a_strings.size();
  if(number<=0) return "";
  std::string result;
  number--;
  for(unsigned int index=0;index<number;index++) {
    result += a_strings[index];
    result += a_sep;
  }
  result += a_strings[number];
  if(a_sep_at_end) result += a_sep;
  return result;
}

inline std::string to_string(unsigned int a_linen,const char* a_lines[]) {
  std::string s;
  for(unsigned int index=0;index<a_linen;index++) {
    s += std::string(a_lines[index]);
    s += "\n";
  }
  return s;
}

inline std::vector<std::string> to(int a_argc,char** a_argv) {
  std::vector<std::string> v;
  for(int index=0;index<a_argc;index++) v.push_back(a_argv[index]);
  return v;
}

// same logic as words() function.
template <class T>
inline bool values(const std::string& a_string,const std::string& a_sep,bool a_take_empty,std::vector<T>& a_values){
  a_values.clear();
  if(a_string.empty()) return true;
  std::string::size_type lim = (a_take_empty?0:1);
  if(a_sep.empty()) {
    T value;
    if(!to<T>(a_string,value)) {
      a_values.clear();
      return false;
    }
    a_values.push_back(value);
  } else {
    std::string::size_type l = a_string.length();
    std::string::size_type llimiter = a_sep.length();
    std::string::size_type pos = 0;
    while(true) {
      std::string::size_type index = a_string.find(a_sep,pos);
      if(index==std::string::npos){ // Last word.
        if((l-pos)>=lim) {
          T value;
          if(!to<T>(a_string.substr(pos,l-pos),value)) {
            a_values.clear();
            return false;
          }
          a_values.push_back(value);
        }
        break;
      } else {
        //     abcxxxef
        //     0  3  67
        if((index-pos)>=lim) {
          T value;
          if(!to<T>(a_string.substr(pos,index-pos),value)) {
            a_values.clear();
            return false;
          }
          a_values.push_back(value);
        }
        pos = index + llimiter;
      }
    }
  }
  return true;
}

}

#include <cstdlib> //::strtol

namespace inlib {

inline bool version(const std::string& a_string,std::vector<unsigned int>& a_version) {
  // a_string is of the form [v,V][<number><char>]<number>
  // Examples : 0 1.2 v0 v1r2 V1r2p3 v0.1.3
  unsigned int number = a_string.size();
  if(!number) {
    a_version.clear();
    return false;
  }
  char* pos = (char*)a_string.c_str();
  if( ((*pos)=='v') || ((*pos)=='V') ) {
    if(number==1) {
      a_version.clear();
      return false; //a_string is only 'v' or 'V' !
    }
    pos++;
  }
  while(*pos!='\0') {
    char* s;
    long v = ::strtol(pos,&s,10);
    if(s==pos) {
      a_version.clear();
      return false;
    }
    if(v<0) {
      a_version.clear();
      return false;
    }
    a_version.push_back((unsigned int)v);
    pos = s; //Could be at end.
    if(*pos=='\0') break;
    // Next char is then not a digit. Skip it.
    pos++;
  }
  return true;
}


inline bool is_version(const std::string& a_string) {
  std::vector<unsigned int> vers;
  return version(a_string,vers);
}

inline std::string remove_version(const std::string& a_string) {
  // replace "@@top@@/pack/vers" -> "@@top@@/pack".
  std::string sold = a_string;
  replace(sold,"\"",sep()+"@quote@"); //To treat AIDA/v3r2p1"/src
  std::vector<std::string> words = inlib::words(sold,sep());
  unsigned int wordn = words.size();
  std::string snew;
  for(unsigned int index=0;index<wordn;index++) {
    std::vector<unsigned int> vers;
    std::string word = words[index];
    if(!version(word,vers)) {
      if(snew.size()) snew += sep();
      snew += words[index];
    }
  }
  replace(snew,sep()+"@quote@","\"");
  return snew;
}

inline bool polynomial_degree(const std::string& a_string,int& a_degree){
  // a_string = [p,P,Polynomial]<integer degree>
  // We extract <degree> from the upper.
  // The degree is the maximum "x" power.
  // For example P1 is ax+b which of degree 1.
  // For example P2 is ax*x+bx+c which of degree 2.
  std::string s = a_string;
  tolowercase(s);
  replace(s,"polynomial","p");
  a_degree = 0;
  if(s.size()<=0) return false;
  if(s[0]!='p') return false;
  int number = 0;
  if(!to<int>(s.substr(1,s.size()-1),number)) return false;
  a_degree = number;
  return true;
}

}

#endif