Calibration/facilities/include/facilities/Util.h

Go to the documentation of this file.

// $ Header:$
#ifndef FACILITIES_UTIL_H
#define FACILITIES_UTIL_H
 
#include <map>
#include <string>
#include <vector>
 
/** @file Util.h
    @author J. Bogart
 
    This file declares the class Util for basic static utilities
    and an associated exception class.
 
*/
namespace facilities {
  /// This class provides a home for utility functions with no need for
  /// any context (hence static)
 
  /// Exception class used by expandEnvVar
  class Untranslatable {
  public:
    Untranslatable( const std::string& toTrans ) : m_badVar( toTrans ) {}
    std::string m_badVar;
  };
 
  /// Exception class used when converting from string to numeric type
 
  class WrongType {
  public:
    WrongType( const std::string& toConvert, const std::string& typeName )
        : m_toConvert( toConvert ), m_typeName( typeName ) {}
    std::string getMsg() {
      std::string msg =
          "facilities::WrongType.  Cannot convert '" + m_toConvert + "' to type " + m_typeName;
      return msg;
    }
 
  private:
    std::string m_toConvert;
    std::string m_typeName;
  };
 
  class Util {
  public:
    /** Given input string @a toExpand expand references to environment
        variables, by default of the form $(varname) and put the
        expanded version back into the original string.  Alternate
        delimiters for the @a varname may optionally be specified
        @param   toExpand string for which expansion is to be done
        @param   openDel opening delimiter (defaults to "$(")
        @param   closeDel closing delimiter (defaults to ")")
 
        @return  -1 if attempt at expansion failed at least once,
                 else number of successful expansions.
 
        TODO:  Perhaps add optional arguments to specify alternate
               delimiters.
    */
    static int expandEnvVar( std::string*       toExpand,
                             const std::string& openDel  = std::string( "$(" ),
                             const std::string& closeDel = std::string( ")" ) );
 
    /** Given an input integer @a val to convert and an output string @a outStr
      converts val into a std::string.
      This method duplicates the stdlib.h method itoa, except that it returns
      std::string rather than char*.
      @param   val
      @param   outStr will be modified by this method
 
      @return  const char* based on the contents of outStr.c_str()
    */
    static const char* itoa( int val, std::string& outStr );
 
    /// converts an std::string to an integer
    static int atoi( const std::string& InStr );
 
    /// converts a std::string to a double.  If string contents are not
    /// of proper form, throws facilities::WrongType
    static double stringToDouble( const std::string& InStr );
 
    /// converts a std::string to an int.  If string contents are not
    /// of proper form, throws facilities::WrongType
    static int stringToInt( const std::string& InStr );
 
    /** This routine breaks down a string into tokens, based on the
        characters appearing in the string @a delimiters.
        @param input       string to be tokenized
        @param delimiters  string containing one or more delimiter characters
        @param tokens      vector of strings to hold resulting tokens
        @param clear       if true (default) @a tokens will be cleared
                           at the start of processing
    */
    static void stringTokenize( std::string input, const std::string& delimiters,
                                std::vector<std::string>& tokens, bool clear = true );
 
    /** This routine breaks down a string into key/value token pairs and
        stores them in the user-supplied map. , based on the
        characters appearing in the string @a delimiters and the value
        of @a pairDelimiter.  In a typical example, @a input could be
        "key1=val1,key2=val2,key3=val3".  In this case invoke with
        delimiters=std::string(",") and pairDelimiter=std::string("=")
        (or omit pairDelimiter since it has the default value)
        @param input         string to be tokenized
        @param delimiters    string containing one or more delimiter
                             characters
        @param tokenMap      map of strings to hold resulting tokens
        @param pairDelimiter string separating key and value; defaults
                             to "="
        @param clear         if true (default) @a tokens will be cleared
                             at the start of processing
    */
    static void keyValueTokenize( std::string input, const std::string& delimiters,
                                  std::map<std::string, std::string>& tokenMap,
                                  const std::string& pairDelimiter = std::string( "=" ),
                                  bool               clear         = true );
 
    /** return the "non-directory" part of a (supposed) file identifier,
        @a path.  Environment variable translation should be done before
        calling @a basename.
        @sa { Util::expandEnvVar }
        @param path        string assumed to be a file identifier.
    */
    static std::string basename( const std::string& path );
 
    /**
       Trim trailing white space characters from the supplied string.
       White space characters for this purpose are blank, carriage return,
       line feed and form feed.  Return # of characters trimmed.
    */
    static unsigned trimTrailing( std::string* toTrim );
  };
} // namespace facilities
 
#endif