/home/rex/ebltrunk/core/libidx/include/utils.h

/***************************************************************************
 *   Copyright (C) 2010 by Pierre Sermanet   *
 *   pierre.sermanet@gmail.com   *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source 
 *       Initiative (http://www.opensource.org) must display the 
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef UTILS_H_
#define UTILS_H_

#ifdef __WINDOWS__
#include <time.h>
#else // linux & mac
#include <sys/time.h>
#include <unistd.h>
#endif

#include <stdio.h>
#include "defines.h"
#include "stl.h"

using namespace std;

namespace ebl {

  #define COLOR_LIST_SIZE 13

  extern IDXEXPORT ubyte color_list[COLOR_LIST_SIZE][3];

  // file IO utilities /////////////////////////////////////////////////////////

  EXPORT int fscan_int(FILE *fp);
  EXPORT float fscan_float(FILE *fp);
  EXPORT char *fscan_str(FILE *fp);

  // directory utilities ///////////////////////////////////////////////////////

  EXPORT bool mkdir_full(const char *dir);  
  EXPORT bool mkdir_full(string &dir);
  EXPORT bool dir_exists(const char *s);  
  EXPORT bool dir_exists(const std::string &s);  
  EXPORT bool file_exists(const char *s);
  EXPORT bool file_exists(const std::string &s);
  EXPORT uint file_size(const char *s);
  EXPORT uint file_size(const std::string &s);
  EXPORT time_t file_modified(const char *s);
  EXPORT time_t file_modified(const std::string &s);
  EXPORT int file_modified_elapsed(const char *s);
  EXPORT bool touch_file(const char *s);
  EXPORT bool touch_file(const std::string &s);
  EXPORT bool rm_file(const char *s);
  EXPORT bool mv_file(const char *src, const char *tgt);
  EXPORT const char *dirname(const char *fname);  
  EXPORT const char *basename(const char *fname, const char *suffix = NULL);    
  EXPORT std::string noext_name(const char *fname);
  EXPORT std::string ext_name(const char *fname);

  // timing utilities //////////////////////////////////////////////////////////

  EXPORT string tstamp();

  class EXPORT timer {
  public:
    timer();
    virtual ~timer();
    void start();
    void stop();
    void restart();
    void reset();
    double elapsed_minutes();
    long elapsed_seconds();
    long elapsed_milliseconds();
    long elapsed_microseconds();

    long accumulated_milliseconds();
    
    void pretty_elapsed();
    void pretty_secs(long seconds);
    string elapsed(long seconds);
    string elapsed();
    string elapsed_ms(long milliseconds);
    string elapsed_ms();
    string accumulated_ms();
    string eta(uint n, uint total);
    
  private:
#ifdef __WINDOWS__
#else // linux & mac
    struct timeval t0, t1;
#endif
    long total_micros; 
    long last_micros; 
    bool running; 
  };

  EXPORT void millisleep(long millis);  
  EXPORT void secsleep(long seconds);

  // process utilities /////////////////////////////////////////////////////////
  
  EXPORT int pid();
  
  // TIMING MACROS ////////////////////////////////////////////////

#ifdef __TIMING__
  
  extern EXPORT ebl::timer debug_timer1;
  extern EXPORT ebl::timer debug_timer2;
  extern EXPORT ebl::timer debug_timer_resizing; // timing of resizing
  extern EXPORT uint debug_resizing_cnt; // # of resizing

#define INIT_TIMING()                                   \
  ebl::timer debug_timer1;                              \
  ebl::timer debug_timer2;                              \
  ebl::timer debug_timer_resizing;                      \
  uint debug_resizing_cnt;

#define TIMING(s, t) {                                                  \
    std::cout << s << ": " << t.elapsed_ms() << std::endl;              \
    t.restart();                                                        \
  }
#define TIMINGACC(s, t) {                                               \
    std::cout << s << ": " << t.accumulated_ms() << std::endl;          \
    t.restart();                                                        \
  }
#define TIMING_ACCSTART(t) t.start();
#define TIMING_ACCSTOP(t) t.stop();                                     
#define TIMING_RESET(t) t.reset();
#define LOCAL_TIMING_START() ebl::timer local_debug_timer;
#define LOCAL_TIMING2_START() ebl::timer local_debug_timer2;
#define LOCAL_TIMING_REPORT(s) TIMING(s, local_debug_timer)
#define LOCAL_TIMING2_REPORT(s) TIMING(s, local_debug_timer2)

#define TIMING1(s) TIMING(s, debug_timer1)
#define TIMING2(s) TIMING(s, debug_timer2)
#define TIMING_RESIZING_ACCSTART()              \
  TIMING_ACCSTART(debug_timer_resizing);        \
  debug_resizing_cnt++;
#define TIMING_RESIZING_ACCSTOP() TIMING_ACCSTOP(debug_timer_resizing)
#define TIMING_RESIZING_RESET()                                 \
  TIMING_RESET(debug_timer_resizing);                           \
  debug_resizing_cnt = 0;
#define TIMING_RESIZING(s)                                              \
  TIMINGACC(s, debug_timer_resizing);                                   \
  std::cout << s << ": number of resizings: " << debug_resizing_cnt <<std::endl;

#else
#define INIT_TIMING()
#define TIMING(s, t)
#define TIMING_START_ACC(t)
#define TIMING_STOP_ACC(t)
#define TIMING_RESET(t)
#define TIMING_START()
#define TIMING_REPORT()
#define TIMING1(s)
#define TIMING2(s)
#define TIMING_RESIZING_ACCSTART()
#define TIMING_RESIZING_ACCSTOP()
#define TIMING_RESIZING_RESET()
#define TIMING_RESIZING(s)
#define LOCAL_TIMING_START()
#define LOCAL_TIMING2_START()
#define LOCAL_TIMING_REPORT(s)
#define LOCAL_TIMING2_REPORT(s)

#endif

} // end namespace ebl

#include "utils.hpp"

#endif /* UTILS_ */