BasicUtilities.hpp

/*
 * UAP Basic Utilities
 * Universal Accelerator Parser
 * Copyright (C) 2006 Andy Wolski, Daniel Bates, David Sagan
 * 
 * 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
 * 
 * Direct questions, comments, etc to:
 *   Andy Wolski (a.wolski@dl.ac.uk)
 *   Daniel Bates (dbates@lbl.gov)
 *   David Sagan (dcs16@cornell.edu)
 */

#ifndef UAPBasicUtilities_hpp
#define UAPBasicUtilities_hpp 1

#include <string>
#include <map>
#include <list>
#include <set>
#include <iostream>
#include <fstream>
#include <vector>
#include <valarray>

typedef std::string                                        Str;

typedef std::list<std::string>                             StrList;
typedef std::list<std::string>::iterator                   StrListIter;
typedef std::list<std::string>::const_iterator             StrListCIter;

typedef std::map<std::string, std::string>                 StrMap;
typedef std::map<std::string, std::string>::iterator       StrMapIter;
typedef std::map<std::string, std::string>::const_iterator StrMapCIter;

typedef std::map<std::string, int>                         IntMap;
typedef std::map<std::string, int>::iterator               IntMapIter;
typedef std::map<std::string, int>::const_iterator         IntMapCIter;

typedef std::vector<std::string>                           StrVec;
typedef std::vector<std::string>::iterator                 StrVecIter;
typedef std::vector<std::string>::const_iterator           StrVecCIter;

typedef std::map<std::string, StrVec>                      StrVecMap;
typedef std::map<std::string, StrVec>::iterator            StrVecMapIter;
typedef std::map<std::string, StrVec>::const_iterator      StrVecMapCIter;

typedef std::valarray<int>                                 IntArray;
typedef std::vector<int>                                   IntVec;
typedef std::list<int>                                     IntList;

typedef std::vector<double>                                DoubleVec;


StrList& operator<< (StrList& s_list, const std::string& str);
StrList& operator<< (StrList& list_out, StrList list_in);

StrVec& operator<< (StrVec& s_vector, const std::string& str);
StrVec& operator<< (StrVec& vector_out, StrVec list_in);

namespace BasicUtilities {

  const Str ERROR_STR = "!ERROR";

  Str trim(Str str);

  void split_file_name (Str file_name_in, Str& dir, Str& file_name, bool& is_relative);
  void split_file_name (Str file_name_in, Str& dir, Str& file_name);

  int string_to_int (const Str& str, bool& ok);
  int string_to_int (const Str& str);

  bool is_int (const Str& str);

  double string_to_double (const Str& str, bool& ok);
  double string_to_double (const Str& str);

  bool is_double (const Str& str);

  bool string_to_bool (const Str& str, bool& ok);
  bool string_to_bool (const Str& str);

  bool is_bool (const Str& str);

  Str bool_to_string (bool this_bool);

  Str int_to_string (const int i, bool& ok);
  Str int_to_string (const int i);

  Str double_to_string (const double r, bool& ok);
  Str double_to_string (const double r);

  Str str_to_upper (const Str& str_in);

  Str str_to_lower (const Str& str_in);

  Str add_parens (const Str& sub_expression, const Str& expression, int i0);

  Str add_parens (const Str& sub_expression, int op_level);

  Str to_xml_string (Str str_in);

  Str from_xml_string (Str str_in);

  Str str_pop (StrList& str_list);

  Str element_val(StrList& s_list, int index);

  bool found(StrList& s_list,     const Str& item);
  bool found(StrVec& s_vector, const Str& item);
  bool found(Str& str,    const Str& item);
  template <class T> inline bool found(std::map<Str, T>& this_map, const Str& item) 
  {
    return (this_map.find(item) != this_map.end());
  }

  StrListIter find(StrList& s_list, const Str& item);
  StrListIter rfind(StrList& s_list, const Str& item);

  StrList list_copy(StrListIter begin, StrListIter end);

  bool found_value(StrMap& string_map, const Str& item);

  bool get_taylor_exponents (const Str& exp_str, IntVec& exp_vec);

  bool splitXMLName (const Str& _name, Str& uri, Str& prefix, 
            Str& loc_name);
  bool splitXMLName (const Str& _name, Str& uri, Str& prefix, 
            Str& loc_name, bool& prefix_found);

}

// file_struct_struct is used for opening files and keeping track of directory paths.

struct FileStackElement {
  bool splitName (const Str& file_name_in);
  Str this_name;         // Name of file
  Str this_dir;          // Directory part of the file name
  Str this_file_no_dir;  // File name without directory
  Str full_dir;          // Full dirctory taking into accout previous stack elements.
  Str full_name;         // Full file ma,e taking into accout previous stack elements.
};

struct FileStackList {
  void addFile (const Str& file_name);
  std::list<FileStackElement> file_list;
};


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// stream_struct is used to break up lines that are too long when writing to a 
// lattice file (used for MAD and Bmad lattice files).

struct EndStruct {};

class StreamStruct {

public: 

  StreamStruct(Str file_name = "");

  Str continuation_char;
  int n_indent;
  int max_len;

  void close_file();
  void open_file(const Str& file_name);
  bool is_open();
  StreamStruct& operator<< (const Str& str);
  StreamStruct& operator<< (const int i);
  StreamStruct& operator<< (EndStruct& s);
  StreamStruct& operator= (StreamStruct& s);

private:

  int ix_line; 
  std::ofstream *out_file;

};


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// PrintInfoStruct is used for error reporting

class PrintInfoStruct {

public:

  void error (Str line1, Str line2 = "", Str line3 = "");
  void warning (Str line1, Str line2 = "", Str line3 = "");

  static Str parsing_status;
  static Str file_name; 
  static Str statement;
  static int ix_line;
  static bool everything_ok;

private:

  void print (Str& line2, Str& line3);

};


#endif

---