properties.hh

/*
 * properties.hh
 *
 * License: Artistic License, see file LICENSE.TXT or
 *          https://opensource.org/licenses/artistic-license-1.0
 *
  * Description: Declaration of the Properties class.
 */
 
#ifndef _PROPERTIES_HH
#define _PROPERTIES_HH
 
// project includes
#include "types.hh"
 
// json support include
#include "json.hpp"
 
// standard C/C++ includes
#include <map>
 
#ifdef __APPLE__
#include <mach-o/dyld.h>   // for _NSGetExecutablePath
#endif
 
 
#define GENEMODEL_KEY "genemodel"
#define NONCODING_KEY "nc"
#define SINGLESTRAND_KEY "singlestrand"
#define SPECIES_KEY "species"
#define CFGPATH_KEY "AUGUSTUS_CONFIG_PATH"
#define INPUTFILE_KEY "queryfile"
#define SPECIESDIR_KEY "speciesdir"
#define UTR_KEY "UTR"
#define TRANSFILE_KEY "transfile"
#define EXTRINSIC_KEY "extrinsic"
#define EXTRFILE_KEY "extrinsicCfgFile"
#define EXTERNAL_KEY "optCfgFile"
#define HINTSFILE_KEY "hintsfile"
#define ALN_KEY "alnfile"
#define TREE_KEY "treefile"
#define DB_KEY "dbaccess"
#define SEQ_KEY "speciesfilenames"
#define CODONALN_KEY "codonAlignmentFile"
#define REF_EXON_KEY "referenceFile"
 
#define OVLPLENFILE "ovlp_len.pbl"
 
using json = nlohmann::json;
 
struct PropertiesError : public ProjectError {
    PropertiesError( string msg ) : ProjectError( msg ) { }
};
 
struct KeyNotFoundError : public PropertiesError {
    KeyNotFoundError( string key ) :
        PropertiesError("Properties::getProperty(): no such key \"" + key + "\".")
    {}
};
 
struct SpecifiedTypeError : public PropertiesError {
    SpecifiedTypeError(string name, string type) :
        PropertiesError("Properties::getProperty(): property \"" + name + "\" is not defined as \"" + type + "\" in configuration file.")
    {}
};
 
struct ValueError : public PropertiesError {
    ValueError(string name, string value) :
        PropertiesError("Properties::getProperty(): the given value \"" + value + "\" of property \"" + name + "\" is not one of the possible values according to the configuration file.")
    {}
};
 
struct ValueFormatError : public PropertiesError {
    ValueFormatError( string key, string value, string type ) :
        PropertiesError( "Properties::getProperty(): cannot convert value \""
                         + value + "\" of key \"" + key + "\" into " + type + "." )
    {}
};
 
struct HelpException {
    string message;
    HelpException(string s) : message(s) {}
}; // no error
 
class Properties
{
public:
    static void        readFile    ( string file );
    static void        init        ( int argc, char* argv[] );
    static Boolean hasProperty( string name);
 
    static void        addProperty         ( string name, string value );
    static Integer     getIntProperty      ( string name );
 
    static Double      getDoubleProperty   ( string name );
    static double      getdoubleProperty   ( string name );
    static Boolean     getBoolProperty     ( string name );
    static const char* getProperty   ( string name );
    static const char* getProperty(string name, int index);
    static string getConfigFilename(string name)
    {
        if (name != "") {
            return properties[CFGPATH_KEY] + getProperty(name);
        } else {
            return properties[CFGPATH_KEY];
        }
    }
 
    // assign value only if key is present
    static bool assignProperty(string name, Integer& target)
    {
        try {
            target = getIntProperty(name);
        } catch (KeyNotFoundError &e) {
            return false;
        }
        return true;
    }
    static bool assignProperty(string name, unsigned& target)
    {
        try {
            target = (unsigned) getIntProperty(name);
        } catch (KeyNotFoundError &e) {
            return false;
        }
        return true;
    }
    static bool assignProperty(string name, Double& target)
    {
        try {
            target = getDoubleProperty(name);
        } catch (KeyNotFoundError &e) {
            return false;
        }
        return true;
    }
    static bool assignProperty(string name, double& target)
    {
        try {
            target = getdoubleProperty(name);
        } catch (KeyNotFoundError &e) {
            return false;
        }
        return true;
    }
    static bool assignProperty(string name, Boolean& target)
    {
        try {
            target = getBoolProperty(name);
        } catch (KeyNotFoundError &e) {
            return false;
        }
        return true;
    }
    static bool assignProperty(string name, string& target)
    {
        try {
            target = getProperty(name);
        } catch (KeyNotFoundError &e) {
            return false;
        }
        return true;
    }
    static bool assignProperty(string name, const char*& target)
    {
        try {
            target = getProperty(name);
        } catch (KeyNotFoundError &e) {
            return false;
        }
        return true;
    }
 
 
private:
    Properties() {}  // do not construct objects!
    static void readLine(istream& strm );
    static bool hasValue(const json& list, const string value);
    static bool isDefinedType(const string typeName, const string paramName);
    static bool isPossibleValue(const string value, const string paramName);
    static void setDefaultValues();
 
private:
    static map<string, string> properties;
    static json allowedParameters;
};
 
/*
 * Find the path to the executable, e.g. /opt/augustus/bin/augustus, /home/mario/augustus/bin/augustus
 * code contributed by Bastien Chevreux
 */
string findLocationOfSelfBinary();
 
#endif  //  _PROPERTIES_HH