source: EEW/trunk/mcast2eew/eewPropertiesST.cc @ 3772

/*
  Author: Kalpesh Solanki
 */

#include "eewPropertiesST.h"
#include "Configuration.h"
#include <stdio.h>
#include <errno.h>
#include "GenLimits.h"

eewPropertiesST * eewPropertiesST::handle = NULL;




eewPropertiesST::eewPropertiesST(){};


eewPropertiesST* eewPropertiesST::getInstance(){
  if(handle==NULL){
    handle = new eewPropertiesST();
  }
  return handle;
}

void eewPropertiesST::init(string config_filename) throw(Error){
    //Check if file exists//
    fstream file;
    file.open(config_filename.c_str(),fstream::in);
    if(file.fail()){
        throw Error("eewPropertiesST::eewPropertiesST: Unable to open "+config_filename);
    } 
    file.close();
 
    //Populate KeyValue Map//
    char key[MAXSTR];
    char value[MAXSTR];
    int ret=TN_EOF; 
    Configuration cfg(config_filename.c_str());
   
    while((ret=cfg.next(key,value))==TN_SUCCESS){
        if(kvm[key] != ""){
            throw Error("eewPropertiesST::eewPropertiesST: Duplicate key found :"+string(key));
        }
        kvm[key] = value;
    }
    //Check for non-defaults//
    
        if(kvm["FilterOrder"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter FilterOrder not found.");
                                
        }
        else{
                try{
                        
                                        _filterorder = toInt(kvm["FilterOrder"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. FilterOrder is invalid");
                }
            }
        
        if(kvm["HPcutoff"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter HPcutoff not found.");
                                
        }
        else{
                try{
                        
                                        _hpcutoff = toFloat(kvm["HPcutoff"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. HPcutoff is invalid");
                }
            }
        
        if(kvm["WaitTimeAfterPick"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter WaitTimeAfterPick not found.");
                                
        }
        else{
                try{
                        
                                        _waittimeafterpick = toInt(kvm["WaitTimeAfterPick"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. WaitTimeAfterPick is invalid");
                }
            }
        
        if(kvm["LatencyTolerance"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter LatencyTolerance not found.");
                                
        }
        else{
                try{
                        
                                        _latencytolerance = toInt(kvm["LatencyTolerance"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. LatencyTolerance is invalid");
                }
            }
        
        if(kvm["VelocityThreshold"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter VelocityThreshold not found.");
                                
        }
        else{
                try{
                        
                                        _velocitythreshold = toFloat(kvm["VelocityThreshold"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. VelocityThreshold is invalid");
                }
            }
        
        if(kvm["ClipWaitSeconds"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter ClipWaitSeconds not found.");
                                
        }
        else{
                try{
                        
                                        _clipwaitseconds = toInt(kvm["ClipWaitSeconds"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. ClipWaitSeconds is invalid");
                }
            }
        
        if(kvm["SampleMultFactor"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter SampleMultFactor not found.");
                                
        }
        else{
                try{
                        
                                        _samplemultfactor = toInt(kvm["SampleMultFactor"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. SampleMultFactor is invalid");
                }
            }
        
        if(kvm["ServerName"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter ServerName not found.");
                                
        }
        else{
                try{
                        
                                        _servername = kvm["ServerName"];
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. ServerName is invalid");
                }
            }
        
        if(kvm["ServerPort"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter ServerPort not found.");
                                
        }
        else{
                try{
                        
                                        _serverport = toInt(kvm["ServerPort"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. ServerPort is invalid");
                }
            }
        
        if(kvm["NetAlgoServerName"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter NetAlgoServerName not found.");
                                
        }
        else{
                try{
                        
                                        _netalgoservername = kvm["NetAlgoServerName"];
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. NetAlgoServerName is invalid");
                }
            }
        
        if(kvm["NetAlgoServerPort"] == ""){
                
                        throw Error("eewPropertiesST::eewPropertiesST: Parameter NetAlgoServerPort not found.");
                                
        }
        else{
                try{
                        
                                        _netalgoserverport = toInt(kvm["NetAlgoServerPort"]);
                                        
                }
                catch(Error& e){
                        throw Error("Configuration file is not in a valid format. NetAlgoServerPort is invalid");
                }
            }
        
}

int eewPropertiesST::toInt(string int_val) throw(Error){
        char val[32];
        strcpy(val,int_val.c_str());

        int v = atoi(val);
//      if(errno == ERANGE || errno == EINVAL){
//              throw Error("Invalid Integer");
//      }
        
        return v;
}

float eewPropertiesST::toFloat(string float_val) throw(Error){
        char val[32];
        strcpy(val,float_val.c_str());

        float v = atof(val);
//      if(errno == ERANGE || errno == EINVAL){
//              throw Error("Invalid Float");
//      }
        return v;
}

double eewPropertiesST::toDouble(string double_val) throw(Error){
        char val[32];
        strcpy(val,double_val.c_str());

        double v = (double)atof(val);
//      if(errno == ERANGE || errno == EINVAL){
//              throw Error("Invalid Double");
//      }
        return v;
}


bool eewPropertiesST::toBool(string bool_val) throw(Error){
        if(bool_val == "true"){
                return true; 
        }
        else if(bool_val == "false"){
                return false;
        }
        else{
                throw Error("Invalid Bool");
        }
}



int eewPropertiesST::getFilterOrder() const{
        return _filterorder;
}

float eewPropertiesST::getHPcutoff() const{
        return _hpcutoff;
}

int eewPropertiesST::getWaitTimeAfterPick() const{
        return _waittimeafterpick;
}

int eewPropertiesST::getLatencyTolerance() const{
        return _latencytolerance;
}

float eewPropertiesST::getVelocityThreshold() const{
        return _velocitythreshold;
}

int eewPropertiesST::getClipWaitSeconds() const{
        return _clipwaitseconds;
}

int eewPropertiesST::getSampleMultFactor() const{
        return _samplemultfactor;
}

string eewPropertiesST::getServerName() const{
        return _servername;
}

int eewPropertiesST::getServerPort() const{
        return _serverport;
}

string eewPropertiesST::getNetAlgoServerName() const{
        return _netalgoservername;
}

int eewPropertiesST::getNetAlgoServerPort() const{
        return _netalgoserverport;
}