SGIO.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 1999-2009 Soeren Sonnenburg
 * Written (W) 1999-2008 Gunnar Raetsch
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef __SGIO_H__
#define __SGIO_H__

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <dirent.h>
#include <unistd.h>
#include <locale.h>

#include <sys/types.h>
#include <sys/stat.h>

#include <shogun/lib/common.h>
#include <shogun/base/init.h>

namespace shogun
{
    class SGIO;
    extern SGIO* sg_io;
}


namespace shogun
{
enum EMessageType
{
    MSG_GCDEBUG,
    MSG_DEBUG,
    MSG_INFO,
    MSG_NOTICE,
    MSG_WARN,
    MSG_ERROR,
    MSG_CRITICAL,
    MSG_ALERT,
    MSG_EMERGENCY,
    MSG_MESSAGEONLY
};


#define NUM_LOG_LEVELS 10
#define FBUFSIZE 4096

#ifdef DARWIN
#define CONST_DIRENT_T struct dirent
#else //DARWIN
#define CONST_DIRENT_T const struct dirent
#endif //DARWIN

#define SG_SET_LOCALE_C setlocale(LC_ALL, "C")
#define SG_RESET_LOCALE setlocale(LC_ALL, "")

// printf like funktions (with additional severity level)
// for object derived from CSGObject
#define SG_GCDEBUG(...) io->message(MSG_GCDEBUG, __FILE__, __LINE__, __VA_ARGS__)
#define SG_DEBUG(...) io->message(MSG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
#define SG_INFO(...) io->message(MSG_INFO, __FILE__, __LINE__, __VA_ARGS__)
#define SG_WARNING(...) io->message(MSG_WARN, __FILE__, __LINE__, __VA_ARGS__)
#define SG_ERROR(...) io->message(MSG_ERROR, __FILE__, __LINE__, __VA_ARGS__)
#define SG_UNSTABLE(func, ...) io->message(MSG_WARN, __FILE__, __LINE__, \
__FILE__ ":" func ": Unstable method!  Please report if it seems to " \
"work or not to the Shogun mailing list.  Thanking you in " \
"anticipation.  " __VA_ARGS__)

#define SG_PRINT(...) io->message(MSG_MESSAGEONLY, __FILE__, __LINE__, __VA_ARGS__)
#define SG_NOTIMPLEMENTED io->not_implemented(__FILE__, __LINE__)
#define SG_DEPRECATED io->deprecated(__FILE__, __LINE__)

#define SG_PROGRESS(...) io->progress(__VA_ARGS__)
#define SG_ABS_PROGRESS(...) io->absolute_progress(__VA_ARGS__)
#define SG_DONE() io->done()

// printf like function using the global sg_io object
#define SG_SGCDEBUG(...) sg_io->message(MSG_GCDEBUG,__FILE__, __LINE__, __VA_ARGS__)
#define SG_SDEBUG(...) sg_io->message(MSG_DEBUG,__FILE__, __LINE__, __VA_ARGS__)
#define SG_SINFO(...) sg_io->message(MSG_INFO,__FILE__, __LINE__, __VA_ARGS__)
#define SG_SWARNING(...) sg_io->message(MSG_WARN,__FILE__, __LINE__, __VA_ARGS__)
#define SG_SERROR(...) sg_io->message(MSG_ERROR,__FILE__, __LINE__, __VA_ARGS__)
#define SG_SPRINT(...) sg_io->message(MSG_MESSAGEONLY,__FILE__, __LINE__, __VA_ARGS__)
#define SG_SPROGRESS(...) sg_io->progress(__VA_ARGS__)
#define SG_SABS_PROGRESS(...) sg_io->absolute_progress(__VA_ARGS__)
#define SG_SDONE() sg_io->done()
#define SG_SNOTIMPLEMENTED sg_io->not_implemented(__FILE__, __LINE__)
#define SG_SDEPRECATED sg_io->deprecated(__FILE__, __LINE__)

#define ASSERT(x) { if (!(x)) SG_SERROR("assertion %s failed in file %s line %d\n",#x, __FILE__, __LINE__);}


class SGIO
{
    public:
        SGIO();
        SGIO(const SGIO& orig);

        void set_loglevel(EMessageType level);

        EMessageType get_loglevel() const;

        inline bool get_show_progress() const
        {
            return show_progress;
        }

        inline bool get_show_file_and_line() const
        {
            return show_file_and_line;
        }

        inline bool get_syntax_highlight() const
        {
            return syntax_highlight;
        }

        void message(EMessageType prio, const char* file,
                int32_t line, const char *fmt, ... ) const;

        void progress(
            float64_t current_val,
            float64_t min_val=0.0, float64_t max_val=1.0, int32_t decimals=1,
            const char* prefix="PROGRESS:\t");

        void absolute_progress(
            float64_t current_val, float64_t val,
            float64_t min_val=0.0, float64_t max_val=1.0, int32_t decimals=1,
            const char* prefix="PROGRESS:\t");

        void done();

        inline void not_implemented(const char* file, int32_t line) const
        {
            message(MSG_ERROR, file, line, "Sorry, not yet implemented .\n");
        }

        inline void deprecated(const char* file, int32_t line) const
        {
            message(MSG_WARN, file, line,
                    "This function is deprecated and will be removed soon.\n");
        }

        void buffered_message(EMessageType prio, const char *fmt, ... ) const;

        static char* skip_spaces(char* str);

        static char* skip_blanks(char* str);

        inline FILE* get_target() const
        {
            return target;
        }

        void set_target(FILE* target);

        inline void set_target_to_stderr() { set_target(stderr); }

        inline void set_target_to_stdout() { set_target(stdout); }

        inline void enable_progress()
        {
            show_progress=true;

            // static functions like CSVM::classify_example_helper call SG_PROGRESS
            if (sg_io!=this)
                sg_io->enable_progress();
        }

        inline void disable_progress()
        {
            show_progress=false;

            // static functions like CSVM::classify_example_helper call SG_PROGRESS
            if (sg_io!=this)
                sg_io->disable_progress();
        }

        inline void enable_file_and_line()
        {
            show_file_and_line=true;

            if (sg_io!=this)
                sg_io->enable_file_and_line();
        }

        inline void disable_file_and_line()
        {
            show_file_and_line=false;

            if (sg_io!=this)
                sg_io->disable_file_and_line();
        }

        inline void enable_syntax_highlighting()
        {
            syntax_highlight=true;

            if (sg_io!=this)
                sg_io->enable_syntax_highlighting();
        }

        inline void disable_syntax_highlighting()
        {
            syntax_highlight=false;

            if (sg_io!=this)
                sg_io->disable_syntax_highlighting();
        }

        static inline void set_dirname(const char* dirname)
        {
            strncpy(directory_name, dirname, FBUFSIZE);
        }

        static inline char* concat_filename(const char* filename)
        {
            if (snprintf(file_buffer, FBUFSIZE, "%s/%s", directory_name, filename) > FBUFSIZE)
                SG_SERROR("filename too long");
            SG_SDEBUG("filename=\"%s\"\n", file_buffer);
            return file_buffer;
        }

        static inline int filter(CONST_DIRENT_T* d)
        {
            if (d)
            {
                char* fname=concat_filename(d->d_name);

                if (!access(fname, R_OK))
                {
                    struct stat s;
                    if (!stat(fname, &s) && S_ISREG(s.st_mode))
                        return 1;
                }
            }

            return 0;
        }

        inline int32_t ref()
        {
            ++refcount;
            return refcount;
        }

        inline int32_t ref_count() const
        {
            return refcount;
        }

        inline int32_t unref()
        {
            if (refcount==0 || --refcount==0)
            {
                delete this;
                return 0;
            }
            else
                return refcount;
        }

        inline const char* get_name() { return "SGIO"; }

    protected:
        const char* get_msg_intro(EMessageType prio) const;

    protected:
        FILE* target;
        float64_t last_progress_time;
        float64_t progress_start_time;
        float64_t last_progress;
        bool show_progress;
        bool show_file_and_line;
        bool syntax_highlight;

        EMessageType loglevel;
        static const EMessageType levels[NUM_LOG_LEVELS];
        static const char* message_strings_highlighted[NUM_LOG_LEVELS];
        static const char* message_strings[NUM_LOG_LEVELS];

        static char file_buffer[FBUFSIZE];
        static char directory_name[FBUFSIZE];

    private:
        int32_t refcount;
};

struct substring
{
    char *start;
    char *end;
};


inline char* c_string_of_substring(substring s)
{
    uint32_t len = s.end - s.start+1;
    char* ret = SG_CALLOC(char, len);
    memcpy(ret,s.start,len-1);
    return ret;
}

inline void print_substring(substring s)
{
    char* c_string = c_string_of_substring(s);
    SG_SPRINT("%s\n", c_string);
    SG_FREE(c_string);
}

inline float32_t float_of_substring(substring s)
{
    char* endptr = s.end;
    float32_t f = strtof(s.start,&endptr);
    if (endptr == s.start && s.start != s.end)
        SG_SERROR("error: %s is not a float!\n", c_string_of_substring(s));

    return f;
}

inline float64_t double_of_substring(substring s)
{
    char* endptr = s.end;
    float64_t f = strtod(s.start,&endptr);
    if (endptr == s.start && s.start != s.end)
        SG_SERROR("Error!:%s is not a double!\n", c_string_of_substring(s));

    return f;
}

inline int32_t int_of_substring(substring s)
{
    char* c_string = c_string_of_substring(s);
    int32_t int_val = atoi(c_string);
    SG_FREE(c_string);

    return int_val;
}

inline uint32_t ulong_of_substring(substring s)
{
    return strtoul(s.start,NULL,10);
}

inline uint32_t ss_length(substring s)
{
    return (s.end - s.start);
}

}
#endif // __SGIO_H__