mootUtils.h

Go to the documentation of this file.

/* -*- Mode: C++ -*- */

/*
   libmoot : moocow's part-of-speech tagging library
   Copyright (C) 2003-2014 by Bryan Jurish <moocow@cpan.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

/*--------------------------------------------------------------------------
 * File: mootUtils.h
 * Author: Bryan Jurish <moocow@cpan.org>
 * Description:
 *   + moocow's PoS tagger : useful utilities
 *--------------------------------------------------------------------------*/

#ifndef _moot_UTILS_H
#define _moot_UTILS_H

#include <mootCIO.h>

#include <list>
#include <vector>

namespace moot {
  using namespace std;
  using namespace mootio;

  /*----------------------------------------------------------------------*/
  void moot_setlocale(void);

  const char *moot_lc_ctype(void);

  const char *moot_lc_numeric(void);


  /*----------------------------------------------------------------------*/
  
  bool moot_parse_doubles(const char *str, double *dbls, size_t ndbls);
  
  /*----------------------------------------------------------------------
   * normalize_ws_*()
   */
  void moot_normalize_ws(const char *buf,
                         size_t len,
                         std::string &out,
                         bool trim_left=true,
                         bool trim_right=true);

  void moot_normalize_ws(const std::string &in,
                         std::string &out,
                         bool trim_left=true,
                         bool trim_right=true);

  inline void moot_normalize_ws(const char *s,
                                std::string &out,
                                bool trim_left=true,
                                bool trim_right=true)
  {
    moot_normalize_ws(s, strlen(s), out, trim_left, trim_right);
  };

  inline std::string moot_normalize_ws(const char *buf,
                                       size_t len,
                                       bool trim_left=true,
                                       bool trim_right=true)
  {
    std::string out;
    out.reserve(len);
    moot_normalize_ws(buf,len, out, trim_left,trim_right);
    return out;
  };

  inline std::string moot_normalize_ws(const char *s,
                                       bool trim_left=true,
                                       bool trim_right=true)
  {
    return moot_normalize_ws(s,strlen(s), trim_left,trim_right);
  };

  inline std::string moot_normalize_ws(const std::string &s,
                                       bool trim_left=true,
                                       bool trim_right=true)
  {
    return moot_normalize_ws(s.data(),s.size(), trim_left,trim_right);
  };

  /*----------------------------------------------------------------------
   * remove_newlines()
   */
  void moot_remove_newlines(char *buf, size_t len);

  inline void moot_remove_newlines(char *s)
  { moot_remove_newlines(s, strlen(s)); };

  void moot_remove_newlines(std::string &s);

  void moot_strtok(const std::string &s, const std::string &delim, std::list<std::string> &out);

  std::list<std::string> moot_strtok(const std::string &s, const std::string &delim);

  void moot_strsplit(const std::string &s, const std::string &delim, std::vector<std::string> &out);

  std::vector<std::string> moot_strsplit(const std::string &s, const std::string &delim);


  int std_vsprintf(std::string &s, const char *fmt, va_list &ap);

  int std_sprintf(std::string &s, const char *fmt, ...);

  std::string std_vssprintf(const char *fmt, va_list &ap);

  std::string std_ssprintf(const char *fmt, ...);

  /*----------------------------------------------------------------------*/
  
  bool moot_file_exists(const char *filename);

  inline bool moot_file_exists(const std::string &filename)
  { return moot_file_exists(filename.c_str()); };
  
  std::string moot_unextend(const char *filename);

  const char *moot_extension(const char *filename, size_t pos);

  inline const char *moot_extension(const char *filename)
  {
    return moot_extension(filename, strlen(filename));
  };


  class cmdutil_file_churner {
  public:
    // -- command-line data
    const char   *progname;  
    char        **inputs;    
    int           ninputs;   
    // -- operation flags
    bool use_list;        
    bool paranoid;        
    // -- file data
    mifstream           in;    
    mifstream           list;  
    // -- buffer data
    std::string         line; 
  private:
    bool is_first_input;      
  public:
    cmdutil_file_churner(const char *my_progname=NULL,
                         char **my_inputs=NULL,
                         int  my_ninputs=0,
                         bool my_use_list=false,
                         bool my_paranoid=true)
      : progname(my_progname),
        inputs(my_inputs),
        ninputs(my_ninputs),
        use_list(my_use_list),
        paranoid(my_paranoid),
        is_first_input(true)
    {};

    ~cmdutil_file_churner() {};

    FILE *first_input_file();

    std::string &first_input_name();

    FILE *next_input_file();

    std::string &next_input_name();

  private:
    FILE *next_list_file();
  };

  /*----------------------------------------------------------------------*/

  typedef enum {
    vlSilent = 0,
    vlErrors = 1,
    vlWarnings = 2,
    vlInfo = 3,
    vlProgress = 4,
    vlDebug = 5,
    vlTrace = 6,
    vlEverything = 255
  } VerbosityLevel;

  std::string moot_banner(void);

  std::string moot_program_banner(const std::string &prog_name,
                                  const std::string &prog_version,
                                  const std::string &prog_author,
                                  bool is_free=true);

  void moot_vcarp(const char *fmt, va_list &ap);

  void moot_carp(const char *fmt, ...);

  void moot_vcroak(const char *fmt, ...);

  void moot_croak(const char *fmt, ...);

  void moot_vmsg(int curLevel, int minLevel, const char *fmt, va_list &ap);

  void moot_msg(int curLevel, int minLevel, const char *fmt, ...);

}; /* namespace moot */

#endif /* _moot_UTILS_H */