global_funcs.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 GLOBAL_FUNCTIONS_HPP
#define GLOBAL_FUNCTIONS_HPP

namespace ucam {
namespace util {
template <typename T>
inline std::string toString ( const T& x, uint pr = 2 ) {
  std::stringstream aux;
  aux << std::fixed << std::setprecision ( pr ) << x;
  std::string ss;
  aux >> ss;
  USER_CHECK ( !aux.fail(), "Converting Number to string failed" );
  return ss;
};

template <typename T>
inline void toString ( const T& x, std::string& ss, uint pr = 2 ) {
  std::stringstream aux;
  if ( pr != std::numeric_limits<T>::max() ) aux << std::fixed <<
        std::setprecision ( pr ) << x;
  else aux << x ;
  aux >> ss;
  USER_CHECK ( !aux.fail(), "Converting Number to string failed" );
};

template <typename T>
inline T toNumber ( const std::string& x ) {
  std::stringstream aux;
  aux << x;
  T ss;
  aux >> ss;
  USER_CHECK ( !aux.fail() && aux.eof(), "Converting string to number failed" );
  return ss;
};

inline bool exists ( const std::string& source, const std::string& needle ) {
  return ( source.find ( needle ) != std::string::npos );
};

inline void find_and_replace ( std::string& haystack, const std::string& needle,
                               const std::string& replace ) {
  std::size_t j = 0;
  for ( ; ( j = haystack.find ( needle ) ) != std::string::npos ; ) {
    haystack.replace ( j, needle.length(), replace );
  }
};

inline bool ends_with ( std::string const& haystack,
                        std::string const& needle ) {
  if ( haystack.length() >= needle.length() )
    return ( 0 == haystack.compare ( haystack.length() - needle.length(),
                                     needle.length(), needle ) );
  return false;
};

inline uint count_needles ( const std::string& haystack, const char needle,
                            std::size_t start, std::size_t end ) {
  uint count = 0;
  for ( const char *c = haystack.c_str() + start; c < haystack.c_str() + end;
        ++c )
    if ( *c == needle ) ++count;
  return count;
}

inline void trim_spaces ( const std::string& input, std::string *output ) {
  boost::regex pattern ( "\\s+",
                         boost::regex_constants::icase | boost::regex_constants::perl );
  std::string replace ( " " );
  *output = boost::regex_replace ( input, pattern, replace );
  boost::algorithm::trim ( *output );
};


inline void trim_trailing_zeros ( std::string& snumber ) {
  uint k;
  for (k = snumber.size() - 1; k > 0 && snumber[k] == '0'; --k);
  if (k == snumber.size() - 1 || !k) return;
  uint j = k;
  for (; j > 0 && snumber[j] != '.'; --j);
  if (j != k) snumber = snumber.substr (0, k + 1);
  else if (j > 0) snumber = snumber.substr (0, k);
}

inline bool validate_source_sentence ( const std::string& s ) {
  static const boost::regex e ( "^\\d+( \\d+)*$" );
  return boost::regex_match ( s, e );
}

inline std::string getTimestamp ( void ) {
  time_t ltime;
  time ( &ltime );
  char time_buffer[128];
  sprintf ( time_buffer, "%s", ctime ( &ltime ) );
  time_buffer[strlen ( time_buffer ) - 1] = 0;
  std::string times;
  times.append ( time_buffer );
  return times;
};

inline bool DirName ( std::string& dirname, const std::string& filename ) {
  std::string::size_type loc = filename.find_last_of ( "/", filename.size() );
  if ( loc == std::string::npos ) return false;
  dirname.append ( filename, 0, loc );
  return true;
};

inline bool fileExists ( const std::string& fileName ) {
  std::fstream fin;
  fin.open ( fileName.c_str(), std::ios::in );
  if ( fin.is_open() ) {
    fin.close();
    return true;
  }
  fin.close();
  return false;
};

inline float dotproduct ( std::vector<float>& v1, std::vector<float>& v2 ) {
  std::size_t lowertop = v1.size() > v2.size() ? v2.size() : v1.size();
  float result = 0.0f;
  for ( std::size_t k = 0; k < lowertop; ++k )
    result += v1[k] * v2[k];
  return result;
}

template<class VecT>
class HashEqVec {
 public:
  bool operator() ( VecT const& v1,
                    VecT const& v2 ) const {
    return v1 == v2;
  }
};

template<class VecT>
class HashFVec : public std::unary_function<VecT, std::size_t> {
public:
  std::size_t operator() ( VecT const& v ) const {
    std::size_t res = 0;
    for ( unsigned int i = 0; i < v.size();
          i++ )  res += ( std::size_t ) pow ( ( double ) v[i],
                                              double ( ( ( i ) % 6 ) + 1 ) );
    return res % HASH_MODULE;
  }
};


typedef HashEqVec<std::basic_string<unsigned> > hasheqvecuint;
typedef HashFVec<std::basic_string<unsigned> > hashfvecuint;

typedef HashEqVec<std::vector<long long> > hasheqvecint64;
typedef HashFVec<std::vector<long long> > hashfvecint64;

template
< typename T
  , template<typename ElemT, typename AllocT=std::allocator<ElemT> > class Container
  >
inline std::ostream& operator<< (std::ostream& o, Container<T> const& container) {
  typename Container<T>::const_iterator itx = container.begin();
  while(itx != container.end()) {
    o << *itx++ << " ";
  }  
  return o;
};

template
< typename T
  , template<typename ElemT, typename AllocT=std::allocator<ElemT> > class Container
  >
inline std::string printout(Container<T> const& container) {
  std::ostringstream ss;
  ss << container;
  return ss.str();
};

inline std::ostream& operator<< (std::ostream& o, std::basic_string<unsigned> const& container) {
  std::basic_string<unsigned>::const_iterator itx = container.begin();
  while(itx != container.end()) {
    o << *itx++ << " ";
  }  
  return o;
};

}} // end namespaces

#endif