/home/rex/ebltrunk/tools/libeblearntools/include/metaparser.h

/***************************************************************************
 *   Copyright (C) 2009 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 METAPLOT_H_
#define METAPLOT_H_

#include <sstream>
#include <stdlib.h>

#ifndef __WINDOWS__
#include <sys/wait.h>
#include <unistd.h>
#endif

#include <stdio.h>
#include <map>
#include <list>

#include "configuration.h"
#include "sort.h"

#define VALUE_SEPARATOR '='

using namespace std;

namespace ebl {

  // iteration

  typedef map<uint,map<uint,uint> > natural_varmap;
  typedef list<map<uint,uint> > varmaplist;

  class EXPORT pairtree {
  public:
    pairtree(string &var, string &val);
    pairtree(uint var, uint val);
    pairtree();
    virtual ~pairtree();

    // data addition methods ///////////////////////////////////////////////////

    static uint get_var_id(const string &var);
    static uint get_var_id(const char *var);
    static uint get_val_id(const string &val);
    static list<uint> to_varid_list(list<string> &l);
    void add(const string &var, string &val);
    map<uint,uint> add(list<uint> &subvar, map<uint,uint> &ivars);

    // flattening methods //////////////////////////////////////////////////////

    natural_varmap flatten(const string &key, natural_varmap *flat = NULL,
                           map<uint,uint> *path = NULL);
    varmaplist flatten(varmaplist *flat = NULL,
                       map<uint,uint> *path = NULL);
    natural_varmap best(const string &key, uint n = 0, bool display = false);
    varmaplist best(list<string> &keys, uint n = 0, bool display = false,
                    int maxiter = -1);
    varmaplist best(list<string> &keys, const string &key,
                    bool display = false);
    varmaplist best(list<string> &keys, list<string> &keycomb,
                    bool display = false);

    uint& get_variable();

    uint& get_value();

    void pretty(string offset = "");

    static string flat_to_string(const string key, natural_varmap *flat = NULL);
    static string flat_to_string(varmaplist *flat = NULL,
                                 list<string> *keys = NULL);
    void pretty_flat(const string key, natural_varmap *flat = NULL);
    void pretty_flat(varmaplist *flat = NULL, list<string> *keys = NULL);
    uint get_max_uint(const string &var);

    bool exists(const string &var);
 
    bool delete_pair(const char *var, const char *value);

    map<uint,pairtree>& get_subtree();

    // members
  private:
    uint                        variable;       
    uint                        value;  
    uint                        subvariable;    


    map<uint,pairtree>                  subtree;
    map<uint,uint>              vars;
    static map<string,uint> vars_map; 
    static map<string,uint> vals_map; 
  public:
    static vector<string> vars_vector; 
    static vector<string> vals_vector; 
  };
  
  // metaparser
  
  typedef map<uint,pairtree> t_subtree;

  class EXPORT metaparser {
  public:
    metaparser();

    virtual ~metaparser();

    void parse_logs(const string &root, list<string> *sticky = NULL,
                    list<string> *watch = NULL);

    void organize_plot(list<string> &names, varmaplist &flat,
                       pairtree &p);

    void write_plots(configuration &conf, const char *dir = NULL,
                     pairtree *p = NULL, string *prefix = NULL);

    natural_varmap best(const string &key, uint n, bool display = false);
    varmaplist best(list<string> &keys, uint n, bool display = false);

    int get_max_iter();
    
    int get_max_common_iter();
    
    int get_max_common_iter(configuration &conf, const string &dir);

    void process(const string &dir);

    varmaplist analyze(configuration &conf, const string &dir, 
                       int &maxiter, varmaplist &besteach, 
                       bool displayall = false,
                       int *maxiter_common = NULL, 
                       varmaplist *best_common = NULL); 

    void send_report(configuration &conf, const string dir,
                     varmaplist &best, int max_iter, 
                     string conf_fullfname,
                     string jobs_info, uint nrunning = 0,
                     double maxminutes = 0.0, double minminutes = 0.0,
                     varmaplist *besteach = NULL,
                     varmaplist *best_common = NULL, 
                     int *maxiter_common = NULL);

    // internal methods
  private:
    bool parse_log(const string &fname, list<string> *sticky = NULL,
                   list<string> *watch = NULL);
    
    // members
  private:
    pairtree            tree;           
    char                separator;      
    map<string,string>  curpath;        
    list<uint>  hierarchy;      
  };

} // end namespace ebl

#endif /* METAPLOT_H_ */