Param.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS 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 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be usefulen,
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 BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <Base/Common/W32Compat.hh>

#include <stdlib.h>
//#include <unistd.h>

#ifdef   WIN32
#  include <Base/Common/getopt_W32.h>
#else  //not WIN32
#  include <getopt.h>
#endif //WIN32

#include <stdio.h>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <time.h>
#include <algorithm>

#include "Param.hh"
#include "ParamTypes.hh"

// for umask
#include <sys/types.h>
#include <sys/stat.h>
#include <locale.h>


using namespace BIAS;
using namespace std;

// we set a typedef here, as we need const iterators very often...
typedef map<const std::string,BIAS::ParamTypeBase*>::const_iterator CI;


// JW
ParamCallbackInterface::~ParamCallbackInterface()
{}

ParamCallbackInterface::ParamCallbackInterface()
{}


void ParamCallbackInterface::ParameterChanged(
    const std::string & /*paramname*/,
    const void * /*data*/)
{}


Param::Param(bool DisableDestructorWarning)
{
  DestructorWarning_ = !DisableDestructorWarning;
  // init some members
  ParamMap_.clear();
  AddParamString("writeconfig","Write file with current configuration");
  AddParamString("readconfig","Read configuration from file");
#ifdef BIAS_HAVE_XML2
  AddParamString("writeconfigXML","Write XML file with current configuration");
  AddParamString("readconfigXML","Read configuration from XML file");
#endif
  AddParamBool("expert","Expert Mode: also show and write parameters marked "
               "as enhanced");
  SetParameterWriteToFile("writeconfig",false);
  SetParameterWriteToFile("readconfig",false);
#ifdef BIAS_HAVE_XML2
  SetParameterWriteToFile("writeconfigXML",false);
  SetParameterWriteToFile("readconfigXML",false);
#endif
  SetParameterWriteToFile("expert", false);
  // needed to ensure consistent ,/. behavior in different envs
  setlocale(LC_ALL, "C");
  //setlocale(LC_NUMERIC, "C");
  //setlocale(LC_CTYPE ,  "C");

  // default Write-options
  WriteComments_ = true;
  WriteIndent_ = false;
  WriteEnhanced_ = false;
  WriteFlagSet_ = false;
}


Param::~Param()
{
  // destroy all listitems...
  for ( CI it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
    // cerr << " deleting "<<it->first<<endl;
    delete it->second;
  }
  //#ifdef BIAS_DEBUG
  //  if (DestructorWarning_)
  //     BIASERR("\n Warning: Parameter are held in class Param. Don't delete this class, if you're still using the parameter somewhere.\n\n");
  //#endif
}


void Param::ShowData(std::ostream &os, int grp, bool showenhanced)
{
  int namew=GetSizeOfLongestParamName()+2, typew=7;
  int valw=GetSizeOfLongestParamValueString()+2;

  namew=(namew<20)?(20):namew;
  valw=(valw<7)?(7):valw;

  int pos   = 0;

  CI it;

  os <<"idx"<<setw(namew)<<"name"<<setw(typew)
  <<"type"<<setw(valw)<<"value"<<" options"<<endl;

  if (grp==GRP_ALL){
    vector<int> grps=UniqueSortedGroups();
    vector<int>::iterator git;
    for (git=grps.begin(); git!=grps.end(); git++){
      os <<"\n############### Group ID "<<*git<<" : "<<GetGroupName(*git)
      <<" #######################\n";
      for(it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
        if ((*it).second->Group_==*git){
          if ((showenhanced || (!(*it).second->Enhanced_)) &&
              (!(*it).second->Hidden_)) {
                os << pos << ": " << setw(namew) << it->first;
                os << setw(typew) << it->second->GetTypeName()<<" "
                << setw(valw) << it->second->GetValueString() <<"   "
                << it->second->ShortCmd_ ;
                if ((*it).second->Enhanced_) os << "   (enhanced)";
                os << endl;
                pos++;
          }
        }
      }
    }
  } else {
    for(it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
      if ((*it).second->Group_==grp){
        if ((showenhanced || (!(*it).second->Enhanced_)) &&
            (!(*it).second->Hidden_)) {
              os << pos << ": " << setw(namew) << it->first;
              os << setw(typew) << it->second->GetTypeName()<<" "
              << setw(valw) << it->second->GetValueString() <<"   "
              << it->second->ShortCmd_;
              if ((*it).second->Enhanced_) os << "   (enhanced)";
              os << endl;
              pos++;
        }
      }
    }
  }
}


void Param::Usage(std::ostream &os)
{
  int namew = 0;
  int typew = 8;
  char tmpstr[256]; // max. length of name is assumed to be < 254
  bool expert = *GetParamBool("expert");

  if (WriteIndent_)
  {
    // search the length of the largest name to compute indentation
    for (CI it = ParamMap_.begin(); it != ParamMap_.end(); it++) {
      if ((!it->second->Enhanced_ || expert) && !it->second->Hidden_) {
        int len = it->first.length();
        if (len > namew) namew = len;
      }
    }
  }

  os << endl;
  os << "Available Parameters : ";
  os << endl;

  vector<int> grps = UniqueSortedGroups();
  for (vector<int>::iterator git = grps.begin(); git!=grps.end(); git++)
  {
    if (*git > -1)
      os << endl << " ---- " << GetGroupName(*git) << " ------------";
    os << endl;
    for (CI it = ParamMap_.begin(); it != ParamMap_.end(); it++)
    {
      if (it->second->Group_ == *git && !it->second->Hidden_ &&
          (expert || !it->second->Enhanced_))
      {
        sprintf(tmpstr, "--%s", it->first.c_str());
        if (WriteIndent_)
          os << setfill(' ') << setw(namew+2);
        os << left << tmpstr;
        if (it->second->ShortCmd_ == 0)
          os << "      ";
        else if (WriteIndent_)
          os << "  -" << it->second->ShortCmd_ << "  ";
        else
          os << ", -" << it->second->ShortCmd_ << "  ";
        if (WriteIndent_)
          os << setfill(' ') << setw(typew);
        if (dynamic_cast<ParamTypeInt*>(it->second))
        {
          // element is of type INTEGER
          os << left << "INT";
        }
        else if (dynamic_cast<ParamTypeBool*>(it->second))
        {
          // element is of type BOOLEAN
          os << left << "BOOL";
        }
        else if (dynamic_cast<ParamTypeDouble*>(it->second))
        {
          // element is of type DOUBLE
          os << left << "DOUBLE";
        }
        else if (dynamic_cast<ParamTypeString*>(it->second))
        {
          // element is of type STRING
          os << left << "STRING";
        }
        else if (dynamic_cast<ParamTypeVecDbl*>(it->second))
        {
          // element is of type VECTOR OF DOUBLE
          os << left << "VECDBL";
        }
        else if (dynamic_cast<ParamTypeVecInt*>(it->second))
        {
          // element is of type VECTOR OF INTEGER
          os << left << "VECINT";
        }
        else if (dynamic_cast<ParamTypeEnum*>(it->second))
        {
          // element is of type VECTOR OF INTEGER
          os << left << "ENUM";
          // now output all possible enum values
          os << "\n\t[ " << dynamic_cast<ParamTypeEnum*>(it->second)->GetHint() << " ]";
        }
        else
        {
          os << left << "unknown";
        }
        os <<" : \n\t";
        if (it->second->Help_ != "")
          os << it->second->Help_;
        else
          os << "No help available";
        os << endl;
      }
    }
    os << endl;
  }
}

// ADDING routines ---------------------------------------------------

int * Param::AddParamInt( const std::string &name,
    const std::string &help, int deflt,
    int min, int max ,char cmdshort, int Group)
{
  if ( ParamMap_.find(name)!=ParamMap_.end() )
    {
      BIASERR("Cannot add parameter "<<name<<". Already in list!");
      return NULL;
    }

  ParamTypeInt * NewItem = new ParamTypeInt();
  BIASASSERT(NewItem!=NULL);

  NewItem->Name_        = name;
  NewItem->Help_        = help;
  NewItem->ShortCmd_    = cmdshort;
  NewItem->Group_       = Group;
  NewItem->WriteToFile_ = true;
  NewItem->value_       = deflt;
  NewItem->default_     = deflt;
  NewItem->min_         = min;
  NewItem->max_         = max;
  pair<string, ParamTypeBase*> NewPair(name, NewItem);
  ParamMap_.insert(ParamMap_.end(), NewPair );

  return &(NewItem->value_);;
}


bool * Param::AddParamBool( const std::string &name, const std::string &help,
    bool deflt, char cmdshort, int Group )
{
  if ( ParamMap_.find(name)!=ParamMap_.end() )
    {
      BIASERR("Cannot add parameter "<<name<<". Already in list!");
      return NULL;
    }
  ParamTypeBool * NewItem = new ParamTypeBool();
  NewItem->Name_        = name;
  NewItem->Help_        = help;
  NewItem->ShortCmd_    = cmdshort;
  NewItem->Group_       = Group;
  NewItem->WriteToFile_ = true;
  NewItem->value_       = deflt;
  NewItem->default_     = deflt;
  pair<string, ParamTypeBase*> NewPair(name,NewItem);
  ParamMap_.insert(ParamMap_.end(), NewPair );
  return &(NewItem->value_);
}


std::string * Param::AddParamString( const std::string &name,
    const std::string &help,
    std::string deflt, char cmdshort,
    int Group )
{
  if ( ParamMap_.find(name)!=ParamMap_.end() )
    {
      BIASERR("Cannot add parameter "<<name<<". Already in list!");
      return NULL;
    }
  ParamTypeString * NewItem = new ParamTypeString();
  NewItem->Name_        = name;
  NewItem->Help_        = help;
  NewItem->ShortCmd_    = cmdshort;
  NewItem->Group_       = Group;
  NewItem->WriteToFile_ = true;
  NewItem->value_       = deflt;
  NewItem->default_     = deflt;
  pair<string, ParamTypeBase*> NewPair(name,NewItem);
  ParamMap_.insert(ParamMap_.end(), NewPair );
  return &(NewItem->value_);;
}


double * Param::AddParamDouble( const std::string &name,
    const std::string &help,
    double deflt,
    double min, double max,
    char cmdshort, int Group)
{
  if ( ParamMap_.find(name)!=ParamMap_.end() )
    {
      BIASERR("Cannot add parameter "<<name<<". Already in list!");      
      return NULL;
    }
  ParamTypeDouble * NewItem = new ParamTypeDouble();
  NewItem->Name_        = name;
  NewItem->Help_        = help;
  NewItem->ShortCmd_    = cmdshort;
  NewItem->Group_       = Group;
  NewItem->WriteToFile_ = true;
  NewItem->value_       = deflt;
  NewItem->default_     = deflt;
  NewItem->min_         = min;
  NewItem->max_         = max;
  pair<string, ParamTypeBase*> NewPair(name,NewItem);
  ParamMap_.insert(ParamMap_.end(), NewPair );
  return &(NewItem->value_);;
}


BIAS::Vector<double> * Param::AddParamVecDbl( const std::string &name,
    const std::string &help,
    const Vector<double> &deflt,
    char cmdshort, int Group )
{
  if ( ParamMap_.find(name)!=ParamMap_.end() )
    {
      BIASERR("Cannot add parameter "<<name<<". Already in list!");
      return NULL;
    }
  ParamTypeVecDbl * NewItem = new ParamTypeVecDbl();
  NewItem->Name_        = name;
  NewItem->Help_        = help;
  NewItem->Group_       = Group;
  NewItem->ShortCmd_    = cmdshort;
  NewItem->WriteToFile_ = true;
  NewItem->value_       = deflt;
  NewItem->default_     = deflt;
  pair<string, ParamTypeBase*> NewPair(name,NewItem);
  ParamMap_.insert(ParamMap_.end(), NewPair );
  return &(NewItem->value_);
}

BIAS::Vector<double> * Param::AddParamVecDbl( const std::string &name,
    const std::string &help,
    const std::string &deflt,
    char cmdshort,
    int Group )
{
  std::vector<double> parsedValues;
  BIAS::Vector<double> values;

  std::stringstream defStream(deflt);
  double temp;
  while (defStream.good()) {
    defStream>>temp;
    parsedValues.push_back(temp);
  }
  values.newsize(parsedValues.size());
  for (unsigned int i=0;i<parsedValues.size();i++)
    values[i]=parsedValues[i];
  return AddParamVecDbl(name, help, values, cmdshort,Group);
}


BIAS::Vector<int> * Param::AddParamVecInt( const std::string &name,
    const std::string &help,
    const Vector<int> &deflt,
    char cmdshort, int Group )
{
  if ( ParamMap_.find(name)!=ParamMap_.end() )
    {
      BIASERR("Cannot add parameter "<<name<<". Already in list!");
      return NULL;
    }
  ParamTypeVecInt * NewItem = new ParamTypeVecInt();
  NewItem->Name_        = name;
  NewItem->Help_        = help;
  NewItem->Group_       = Group;
  NewItem->ShortCmd_    = cmdshort;
  NewItem->WriteToFile_ = true;
  NewItem->value_       = deflt;
  NewItem->default_     = deflt;
  pair<string, ParamTypeBase*> NewPair(name,NewItem);
  ParamMap_.insert(ParamMap_.end(), NewPair );
  return &(NewItem->value_);;
}

BIAS::Vector<int> * Param::AddParamVecInt( const std::string &name,
    const std::string &help,
    const std::string &deflt,
    char cmdshort,
    int Group )
{
  std::vector<int> parsedValues;
  BIAS::Vector<int> values;

  std::stringstream defStream(deflt);
  int temp;
  while (defStream.good()) {
    defStream>>temp;
    parsedValues.push_back(temp);
  }
  values.newsize(parsedValues.size());
  for (unsigned int i=0;i<parsedValues.size();i++)
    values[i]=parsedValues[i];
  return AddParamVecInt(name, help, values, cmdshort,Group);
}


int * Param::AddParamEnum( const std::string &name,
    const std::string &help,
    const std::vector<std::string> &enums,
    const int deflt,
    const std::vector<int> * IDs,
    const char cmdshort,
    const int Group )
{
  if ( ParamMap_.find(name)!=ParamMap_.end() )
    {
      BIASERR("Cannot add parameter "<<name<<". Already in list!");
      return NULL;
    }
  if ( enums.empty() )
    {
      BIASERR("At least one item is needed for enum type");
      return NULL;
    }
  if ( IDs != NULL && IDs->size() != enums.size() )
    {
      BIASERR("You gave "<<enums.size()<< "enums but "<<IDs->size()
          <<" ID values! Both numbers must be equal!");
      return NULL;
    }
  ParamTypeEnum * NewItem = new ParamTypeEnum();
  NewItem->Name_        = name;
  NewItem->Help_        = help;
  NewItem->Group_       = Group;
  NewItem->ShortCmd_    = cmdshort;
  NewItem->WriteToFile_ = true;
  NewItem->value_       = deflt;
  NewItem->default_     = deflt;
  pair<string,int> NewEnumPair;
  int newID;
  for(unsigned int i=0; i<enums.size(); i++)
    {
      newID = IDs?(*IDs)[i]:i;
      if ( NewItem->Map_.find(enums[i]) != NewItem->Map_.end() ) {
        BIASERR("Given enum IDs must be unique!");
        delete NewItem;
        return NULL;
      }
      NewEnumPair = make_pair(enums[i],newID );
      NewItem->Map_.insert(NewItem->Map_.end(), NewEnumPair);
    }
  //   if ( NewItem->Map_.find(deflt) == NewItem->Map_.end() )
  //     {
  //       BIASERR("The given default ID is not in the enum list!");
  //       delete NewItem;
  //       return NULL;
  //     }
  pair<string, ParamTypeBase*> NewPair(name,NewItem);
  ParamMap_.insert(ParamMap_.end(), NewPair );
  return &(NewItem->value_);
}


//////////////  CheckParam() ///////////////

bool Param::CheckParam(const std::string &name)
{
  if ( ParamMap_.find(name) == ParamMap_.end() ) return false;
  else return true;
}

// GETTING routines --------------------------------------------------
int * Param::GetParamIntByIndex( const int i )const
{

  CI it;
  int pos = -1;
  for(it=ParamMap_.begin(); (it!=ParamMap_.end() || (pos == i)); it++){
    pos++;

    if (pos == i) {
      if ( ParamTypeInt *item = dynamic_cast<ParamTypeInt*>(it->second) )
        return &(item->value_);
      else{
        BIASERR("Type of parameter is invalid!");
        return NULL;
      }
    }
  }
  BIASERR("Index is invalid!");
  return NULL;
}

double * Param::GetParamDoubleByIndex( const int i )const
{

  CI it;
  int pos = -1;
  for(it=ParamMap_.begin(); (it!=ParamMap_.end() || (pos == i)); it++){
    pos++;

    if (pos == i) {
      if ( ParamTypeDouble *item = dynamic_cast<ParamTypeDouble*>(it->second) )
        return &(item->value_);
      else{
        BIASERR("Parameter is invalid!");
        return NULL;
      }
    }
  }
  BIASERR("Index is invalid!");
  return NULL;
}

bool * Param::GetParamBoolByIndex( const int i )const
{

  CI it;
  int pos = -1;
  for(it=ParamMap_.begin(); (it!=ParamMap_.end() || (pos == i)); it++){
    pos++;

    if (pos == i) {
      if ( ParamTypeBool *item = dynamic_cast<ParamTypeBool*>(it->second) )
        return &(item->value_);
      else{
        BIASERR("Parameter is invalid!");
        return NULL;
      }
    }
  }
  BIASERR("Index is invalid!");
  return NULL;
}

std::string * Param::GetParamStringByIndex( const int i )const
{

  CI it;
  int pos = -1;
  for(it=ParamMap_.begin(); (it!=ParamMap_.end() || (pos == i)); it++){
    pos++;

    if (pos == i) {
      if ( ParamTypeString *item = dynamic_cast<ParamTypeString*>(it->second) )
        return &(item->value_);
      else{
        BIASERR("Parameter is invalid!");
        return NULL;
      }
    }
  }
  BIASERR("Index is invalid!");
  return NULL;
}

int * Param::GetParamInt( const std::string &name )const
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() ){
    BIASERR("int parameter "<<name<<" not found!");    
    return NULL;
  }
  else if ( ParamTypeInt *item = dynamic_cast<ParamTypeInt*>(it->second) )
    return &(item->value_);
  else{
    BIASERR("Parameter "<<name<<" is not of type INTEGER!");
    return NULL;
  }
}

bool * Param::GetParamBool( const std::string &name )const
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() ){
    BIASERR("bool parameter "<<name<<" not found!");
    return NULL;
  }
  else if ( ParamTypeBool *item = dynamic_cast<ParamTypeBool*>(it->second) )
    return &(item->value_);
  else{
    BIASERR("Parameter "<<name<<" is not of type BOOLEAN!");
    return NULL;
  }
}


std::string * Param::GetParamString( const std::string &name )const
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() ){
    BIASERR("string parameter "<<name<<" not found!");
    return NULL;
  }
  else if (ParamTypeString *item=dynamic_cast<ParamTypeString*>(it->second))
    return &(item->value_);
  else{
    BIASERR("Parameter "<<name<<" is not of type STRING!");
    return NULL;
  }
}


double * Param::GetParamDouble( const std::string &name )const
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() ){
    BIASERR("double parameter "<<name<<" not found!");
    return NULL;
  }
  else if (ParamTypeDouble *item=dynamic_cast<ParamTypeDouble*>(it->second))
    return &(item->value_);
  else{
    BIASERR("Parameter "<<name<<" is not of type DOUBLE!");
    return NULL;
  }
}

BIAS::Vector<double> * Param::GetParamVecDbl( const std::string &name )const
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() ){
    BIASERR("vecdbl parameter "<<name<<" not found!");
    return NULL;
  }
  else if (ParamTypeVecDbl *item=dynamic_cast<ParamTypeVecDbl*>(it->second))
    return &(item->value_);
  else{
    BIASERR("Parameter "<<name<<" is not of type VECTOR OF DOUBLE!");
    return NULL;
  }
}


BIAS::Vector<int> * Param::GetParamVecInt( const std::string &name )const
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() ){
    BIASERR("vecint parameter "<<name<<" not found!");
    return NULL;
  }
  else if (ParamTypeVecInt *item=dynamic_cast<ParamTypeVecInt*>(it->second))
    return &(item->value_);
  else{
    BIASERR("Parameter "<<name<<" is not of type VECTOR OF INTEGER!");
    return NULL;
  }
}


int * Param::GetParamEnum( const std::string &name )const
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() ){
    BIASERR("enum parameter \""<<name<<"\" not found!");
    return NULL;
  }
  else if ( ParamTypeEnum *item = dynamic_cast<ParamTypeEnum*>(it->second) )
    return &(item->value_);
  else{
    BIASERR("Parameter "<<name<<" is not of type ENUM!");
    return NULL;
  }
}

// SETTING routines --------------------------------------------------

int * Param::SetParamInt( const std::string &name, const int &value )
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning NULL!");     
      return NULL;
    }
  if ( ParamTypeInt *item = dynamic_cast<ParamTypeInt*>(it->second) )
    {
      if ( value < item->min_ || value > item->max_ )
        {
          BIASERR("Valid values for \""<<name<<"\" are between "
              <<item->min_<<" and "<<item->max_<<"!");
          return NULL;
        }
      item->value_ = value;
      return &(item->value_);
    }
  else
    {
      BIASERR("Parameter "<<name<<" is not of type INTEGER!");
      return NULL;
    }
}


bool * Param::SetParamBool( const std::string &name, const bool &value )
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning NULL!");      
      return NULL;
    }
  if ( ParamTypeBool *item = dynamic_cast<ParamTypeBool*>(it->second) )
    {
      item->value_ = value;
      return &(item->value_);
    }
  else
    {
      BIASERR("Parameter "<<name<<" is not of type BOOLEAN!");
      return NULL;
    }
}


std::string * Param::SetParamString( const std::string &name,
    const std::string &value )
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning NULL!");      
      return NULL;
    }
  else if( ParamTypeString *item = dynamic_cast<ParamTypeString*>(it->second) )
    {
      item->value_ = value;
      return &(item->value_);
    }
  else
    {
      BIASERR("Parameter "<<name<<" is not of type STRING!");
      return NULL;
    }
}


double * Param::SetParamDouble( const std::string &name, const double &value )
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning NULL!");      
      return NULL;
    }
  if ( ParamTypeDouble *item = dynamic_cast<ParamTypeDouble*>(it->second) )
    {
      if ( value < item->min_ || value > item->max_ )
        {
          BIASERR("Valid values for "<<name<<" are between "
              <<item->min_<<" and "<<item->max_<<"!");
          return NULL;
        }
      item->value_ = value;
      return &(item->value_);
    }
  else
    {
      BIASERR("Parameter "<<name<<" is not of type DOUBLE!");
      return NULL;
    }
}


BIAS::Vector<double> * Param::SetParamVecDbl( const std::string &name,
    const Vector<double> &value )
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning NULL!");      
      return NULL;
    }
  if ( ParamTypeVecDbl *item = dynamic_cast<ParamTypeVecDbl*>(it->second) )
    {
      //       if ( value.size() != item->default_.size() )
      //         {
      //           BIASERR("New vector for "<<name<<" must be of size "
      //                   <<item->default_.size()<<" but this one's is "
      //                   <<value.size()<<"!");
      //           return NULL;
      //         }
      item->value_ = value;
      return &(item->value_);
    }
  else
    {
      BIASERR("Parameter "<<name<<" is not of type VECTOR OF DOUBLE!");
      return NULL;
    }
}


BIAS::Vector<int> * Param::SetParamVecInt( const std::string &name,
    const Vector<int> &value )
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning NULL!");      
      return NULL;
    }
  if ( ParamTypeVecInt *item = dynamic_cast<ParamTypeVecInt*>(it->second) )
    {
      //       if ( value.size() != item->default_.size() )
      //         {
      //           BIASERR("New vector for "<<name<<" must be of size "
      //                   <<item->default_.size()<<" but this one's is "
      //                   <<value.size()<<"!");
      //           return NULL;
      //         }
      item->value_ = value;
      return &(item->value_);
    }
  else
    {
      BIASERR("Parameter "<<name<<" is not of type VECTOR OF INTEGER!");
      return NULL;
    }
}


int * Param::SetParamEnum( const std::string &name,const std::string &value )
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning NULL!");      
      return NULL;
    }
  if ( ParamTypeEnum *item = dynamic_cast<ParamTypeEnum*>(it->second) )
    {
      map<string,int>::iterator it;
      if ( (it=item->Map_.find(value)) == item->Map_.end() ) {
        BIASERR(value << " is not a valid ID for this enum!");
        return NULL;
      }
      item->value_ = it->second;
      return &(item->value_);
    }
  else
    {
      BIASERR("Parameter "<<name<<" is not of type ENUM!");
      return NULL;
    }
}


int * Param::SetParamEnum( const std::string &name, const int &value )
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning NULL!");      
      return NULL;
    }
  if ( ParamTypeEnum *item = dynamic_cast<ParamTypeEnum*>(it->second) ) {
    // rush through map and if value is valid, set it
    map<string, int>::iterator it;
    for(it=item->Map_.begin(); it!=item->Map_.end(); it++)
      if ( it->second == value ){
        item->value_ = value;
        return &(item->value_);
      }
    BIASERR(value << " is not in this enum!");
    return NULL;
  }
  else {
    BIASERR("Parameter "<<name<<" is not of type ENUM!");
    return NULL;
  }
}


int Param::SetParameterWriteToFile(const std::string &name, bool writeToFile)
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set parameter,"
          <<" returning -1!");      
      return -1;
    }
  it->second->WriteToFile_ = writeToFile;
  return 0;
}

int Param::SetEnhancedFlag(const std::string &name, bool enhanced)
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set to enhanced, "
          <<" returning -1!");      
      return -1;
    }
  it->second->Enhanced_ = enhanced;
  return 0;
}

int Param::SetHiddenFlag(const std::string &name, bool hidden)
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() )
    {
      BIASERR("Parameter \""<<name<<"\" not found, cannot set to hidden, "
          <<" returning -1!");      
      return -1;
    }
  it->second->Hidden_ = hidden;
  return 0;
}

// command line and file processing methods --------------------------

int Param::UpdateParameter(int &argc, char *argv[],
    const std::string &default_filename)
{
  int res;
  // provide a default file name to readconfig
  *GetParamString("readconfig")=default_filename;
  res = ParseCommandLine(argc, argv);
  string *name=GetParamString("writeconfig");
  bool *expert=GetParamBool("expert");

  if (*name!="") {
    //cerr << "*name "<<*name<<endl;
    // comments on !
    SetWriteOptions(WriteIndent_,true,WriteEnhanced_ || *expert);
    WriteParameter(*name);
    BIASDOUT(D_PARAM_CONF_FILE, "wrote default param file "
        <<default_filename<<endl);
  } else {
    // write default parameter file if no parameter file given and default
    // file not found
    if (*GetParamString("readconfig")==default_filename) {
      BIASDOUT(D_PARAM_CONF_FILE, "using default param file "
          <<default_filename<<endl);
      ifstream is(default_filename.c_str());
      if (!is) {
        is.close();
        SetWriteOptions(WriteIndent_,false,WriteEnhanced_|| *expert); // comments off
        WriteParameter(default_filename);
        BIASDOUT(D_PARAM_CONF_FILE, "wrote default param file "
            <<default_filename<<endl);
      } else {
        is.close();
        BIASDOUT(D_PARAM_CONF_FILE, "found default param file "
            <<default_filename<<endl);
      }
    } else {
      BIASDOUT(D_PARAM_CONF_FILE, "using user given param file "
          <<*GetParamString("readconfig")<<endl);
    }
  }
  return res;
}

int Param::ParseCommandLine(int &argc, char *argv[])
{
  // if no arguments are given on Cmdl, return index to last non-opt: 1
  string *readPrj;
  if (argc==1) {
    // read configuration file if one is given (see UpdateParameter)
    if ( (readPrj = GetParamString("readconfig"))!=NULL ){
      if (*readPrj != ""){
        //cout <<"Reading configuration from file: "<<*readPrj<<endl;
        BIASDOUT(D_PARAM_CONF_FILE, "Reading configuration from file: "
            <<*readPrj<<endl);
        if (ReadParameter(*readPrj)<0) return -1;
      }
    }
    return 1;
  }
  BIASDOUT(D_PARAM_PARSECMDL,"Param::ParseCommandLine()");

  // fisrt get a copy of all that if we not already have one
  if (ArgV_.size() ==0)
    for ( int i=0;i<argc; i++)
      ArgV_.push_back(argv[i]);

  //BIASDOUT(D_PARAM_PARSECMDL,"NumParams_: "<<ParamMap_.size());
  int itemcount = 0;
  // there are NumParams_ shortopts maximum, each may have one arg,
  // plus trailing 0
  char *shortoptstring=new char[ParamMap_.size()*3+1];
  bool bReadConfig =true, bParse=true;
  while (bParse) {
    // set string empty
    shortoptstring[0] = 0;
    itemcount = 0;
    char tmpstr[2];
    tmpstr[1] = 0;

    // prepare array of longopts for getopt_long()
    // last element must be zeored
    longopts = new struct option[ParamMap_.size()+1];
    memset(&longopts[ParamMap_.size()], 0, sizeof(struct option));

    // traverse list of parameters and fill in longopts[]

    for (CI it=ParamMap_.begin(); it!=ParamMap_.end(); ++it)
      {
        longopts[itemcount].name = (it->first).c_str();
        // only type BOOL has an optional argument
        if ( dynamic_cast<ParamTypeBool*>(it->second) != NULL )
          longopts[itemcount].has_arg = optional_argument;
        else longopts[itemcount].has_arg = required_argument;

        // set .flag to NULL, then .val is returned from getopt_long()
        longopts[itemcount].flag = NULL;
        // set .val to itemcount+offset let us find the target in ParamList_
        // much faster. Offset is required to differ from shortopt char
        longopts[itemcount].val = itemcount+1000;

        // prepare shortoptstring
        if ( it->second->ShortCmd_!=0 ) {
          tmpstr[0] = it->second->ShortCmd_;
          strcat(shortoptstring, tmpstr);
          // append ':' to shortopstring for arguments to options
          strcat(shortoptstring, ":");
          // append a second ':' to bool, for optional argument
          if ( dynamic_cast<ParamTypeBool*>(it->second) != NULL)
            strcat(shortoptstring, ":");
        }
        itemcount++;
      }
    // reset optind to start scanning from 0
    optind = 0;

    bool done = false;
    int short_or_index=0;
    // now scan
    while (!done)
      {
        // getopt_long() returns a char if the short option was found
        // if the long option was found, the longopts.val is returned
        // in this case the index to longopts[] + 1000
        //getopt_long not present in WIN32
        short_or_index = ::getopt_long(argc, argv, shortoptstring,
            longopts, NULL);
        //        short_or_index = getopt(argc, argv, shortoptstring);

        // '?' means unknown option, ':' means missing argument
        if (short_or_index == '?' || short_or_index == ':') {
          delete [] longopts;
          Usage();
          return -1;
        }

        if (short_or_index == -1)
          done = true;
        else
          {
            // decide if short or long found
            CI it;
            if (short_or_index >=1000){
              // long opt found, take name from longopts and search in map
              int index = short_or_index -1000;
              it = ParamMap_.find(longopts[index].name);
              BIASDOUT(D_PARAM_PARSECMDL,"longopt at "<<index
                  <<" : "<<it->first);
            }
            else{
              for(it=ParamMap_.begin();it!=ParamMap_.end(); it++)
                if ( it->second->ShortCmd_==short_or_index ){
                  BIASDOUT(D_PARAM_PARSECMDL,"shortopt with "
                      <<(char)short_or_index<<" : "<<it->first);
                  break;
                }
            }
            // if optarg ==NUL, user specified a bool switch and no argument
            // or argument is not connected with '=', so fake argument
            const char* optparam;
            if (optarg != NULL) {
              //optarg="true";
              optparam = optarg;
            } else {
              optparam ="true";
            }

            // this calls the method from the correct class to insert into
            // (late binding magic)
            it->second->SetFromString(optparam);
          } // else if (short_or_index == -1)
      } //while ()
    /// this delete let the program bail out. but it realy should be deleted
    delete[] longopts;

    //// check for readconfigXML and readconfig
    if (bReadConfig){
#ifdef BIAS_HAVE_XML2
      if ( (*(readPrj = GetParamString("readconfigXML")))!="" ){
        //cout <<"Reading configuration from XML-file: "<<*readPrj<<endl;
        BIASDOUT(D_PARAM_CONF_FILE, "Reading configuration from XML-file: "
            <<*readPrj<<endl);
        if (ReadParameterXML(*readPrj)<0) return -1;
        // second parse to let cmdl override config file
        else bParse=true;
      } else
#endif
        if ( (*(readPrj = GetParamString("readconfig")))!="" ){
          //cout <<"Reading configuration from file: "<<*readPrj<<endl;
          BIASDOUT(D_PARAM_CONF_FILE, "Reading configuration from file: "
              <<*readPrj<<endl);
          if (ReadParameter(*readPrj)<0) return -1;
          // second parse to let cmdl override config file
          else bParse=true;
        } else {
          bParse=false;
          BIASDOUT(D_PARAM_CONF_FILE, "no configuration file given\n");
        }
      bReadConfig=false;
    } else {
      bParse=false;
    }
  } // end while bParse

  string *writePrj;

  // now eventually write config
  if (*(writePrj=GetParamString("writeconfig")) != "") {
    string s = *writePrj;
    SetParamString("writeconfig",(string)"");
    bool *expert=GetParamBool("expert");
    SetWriteOptions(WriteIndent_,WriteComments_,WriteEnhanced_ || *expert);
    WriteParameter(s);
    WriteFlagSet_ = true;
  }

#ifdef BIAS_HAVE_XML2
  // now eventually write config to XML-file
  if (*(writePrj=GetParamString("writeconfigXML")) != "") {
    string s = *writePrj;
    SetParamString("writeconfigXML",(string)"");
    bool *expert=GetParamBool("expert");
    SetWriteOptions(WriteIndent_,WriteComments_,WriteEnhanced_ || *expert);
    WriteParameterXML(s);
    WriteFlagSet_ = true;
  }
#endif


  delete[] shortoptstring;
  return optind;
}//////////////// End of ParseCommandLine()


#define READPARAM_CHECKDUPES
int Param::ReadParameter(const string &filename)
{
  setlocale(LC_ALL, "C");

  ifstream ifs;
  string typestr;
  string namestr;
  string assignstr;
  string valstr;
  char commentstr[1000];
  CI it; // const iterator for our ParamMap_
  int line = 0;

#ifdef READPARAM_CHECKDUPES
  map<string,bool> *ExistingNames = new map<string,bool>;
  string current;
#endif


  ifs.open(filename.c_str());
  if (!ifs) {
    BIASERR("error reading parameter file: "<<filename);
    ifs.close();
    return -1;
  }
  while (ifs) {

    line++;

    // try read one word, may be type or comment sign
    ifs >>  namestr;
    if (namestr[0] == '#') {
      ifs.getline(commentstr,sizeof(commentstr),'\n');
      BIASDOUT(D_PARAM_IO,"Comment read: "<<namestr<<commentstr);

    }
    else {
      ifs >> assignstr >>valstr ;
      // detect strings with whitespace and read them
      if (valstr[0] == '"' && valstr[valstr.length()-1] != '"') {
        char c = 0;
        while ( c != '\"') {
          ifs.read(&c,1);
          valstr.append(1,c);
        }
      }

      ifs >> typestr;
      if (ifs) {
        //  cout <<"read: "<<typestr<<" "<<namestr<<" "<<assignstr<<" "<<valstr
        //       <<endl;
#ifdef READPARAM_CHECKDUPES
        current = (string)namestr;
        //cout << "checking line " << line << " name "<<current<<endl;
        if ( ExistingNames->find(current) != ExistingNames->end() ){
          BIASERR("Oops! Found duplicate parameter '" << current
              << "' in line " << line << " of file '" << filename
              << "' ");
          ifs.close();
          return -2;
        }
        else{
          pair<string, bool> NewPair(current,true);
          ExistingNames->insert(ExistingNames->end(), NewPair );
        };

#endif
        // remove double-quotes where necessary
        if (valstr[0] == '"' && valstr[valstr.length()-1] == '"') {
          valstr = valstr.substr(1,valstr.length()-2);
        }
        //  cout <<"read: "<<typestr<<" "<<namestr<<" "<<assignstr<<" "<<valstr
        //       <<endl;

        if ( (it=ParamMap_.find(namestr))==ParamMap_.end() ){
          BIASERR("Unknown parameter \""<<namestr
              <<"\" in file "<<filename<<" line: "<<line);
          //           ShowData();          
        } else {
          // this calls the method from the correct class to insert
          // to (late binding magic)
          it->second->SetFromString(valstr);
          BIASDOUT(D_PARAM_IO, filename<<" parameter: "<<namestr
              <<" type: "<<typestr << " valstr: "<<valstr);
          BIASDOUT(D_PARAM_IO, filename<<" parameter: "<<namestr
              <<" value after SetFromString(): "
              <<it->second->GetValueString());
        } // if (item == NULL) else {
      } // if(ifs)
    } // if (comment) else {
  } // While (ifs)
  ifs.close();

#ifdef READPARAM_CHECKDUPES
  delete ExistingNames;
#endif
  return 0;
}

#ifdef BIAS_HAVE_XML2

int Param::ReadParameterXML(const string &filename)
{
  // Tree for XML-file...
  XMLIO tree;
  // vector for SubGroup nodes
  vector<xmlNodePtr> subgroups;
  // namestring for params
  string paramname;
  string attribType;

  // read XML-file
  xmlNodePtr root = tree.read(filename);

  // if not successful
  if (root == NULL){
    // exit with error -1
    BIASERR("Error reading XML-file: " << filename << endl);
    return -1;
  }

  xmlNodePtr parent = root;
  xmlNodePtr child = tree.getFirstChild(parent);

  // for all child-nodes...
  bool done=false;
  while (!done)
    {
      // if child is a groupnode...
      if ((tree.getAttributeName(tree.getFirstAttribute(child)) == "SubGroup")||
          (tree.getAttributeName(tree.getFirstAttribute(child)) == "GroupID")) {
            // ...remind the node for descend...
            subgroups.push_back(child);
      } else {
        // ...else get type of param, ...
        xmlAttrPtr attrib = tree.getFirstAttribute(child);
        while (tree.getAttributeName(attrib) != "Type") {
          attrib = tree.getNextAttribute();
        }
        attribType = tree.getAttributeValueString(attrib);

        // ...get parametername...
        attrib = tree.getFirstAttribute(child);
        while (tree.getAttributeName(attrib) != "Name") {
          attrib = tree.getNextAttribute();
        }
        paramname = tree.getAttributeValueString(attrib);

        // ... save value...
        attrib = tree.getFirstAttribute(child);
        while (tree.getAttributeName(attrib) != "Value") {
          attrib = tree.getNextAttribute();
        }
        if (attribType == "STRING") {
          SetParamString(paramname, tree.getAttributeValueString(attrib));
        } else if (attribType == "INT") {
          SetParamInt(paramname, tree.getAttributeValueInt(attrib));
        } else if (attribType == "DOUBLE"){
          SetParamDouble(paramname, tree.getAttributeValueDouble(attrib));
        } else if (attribType == "BOOL"){
          SetParamBool(paramname, tree.getAttributeValueBool(attrib));
        } else if (attribType == "VECDBL"){
          SetParamVecDbl(paramname,
              (Vector<double>)(tree.getAttributeValueVecDbl(attrib)));
        } else if (attribType == "VECINT"){
          SetParamVecInt(paramname,
              (Vector<int>)(tree.getAttributeValueVecInt(attrib)));
        } else if (attribType == "ENUM"){
          SetParamEnum(paramname, tree.getAttributeValueString(attrib));
        } else {
          BIASERR("Unknown parametertype: " << attribType << endl);
          return -1;
        }

        //... and set enhanced flag for param
        attrib = tree.getFirstAttribute(child);
        while (tree.getAttributeName(attrib) != "Enhanced") {
          attrib = tree.getNextAttribute();
        }
        SetEnhancedFlag(paramname, tree.getAttributeValueBool(attrib));
      }

      child = tree.getNextChild();
      if ((child == NULL)&&(subgroups.size()>0)) {
        // if all childs done but at least one subgroup left --> descend
        parent = subgroups[subgroups.size()-1];
        subgroups.pop_back();
        child = tree.getFirstChild(parent);
      } else
        // if all childs done and no subgroups left --> end
        if ((child == NULL)&&(subgroups.size()==0)) {
          done=true;
          break;
        }

    }

  return 0;
}

#endif

int Param::GetFreeGroupID()
{
  vector<int> gv=UniqueSortedGroups();
  if (gv.size()==0){
    return 0;
  }
  return (*(gv.rbegin()))+1;
}

int Param::GetGroupID(const string &name)
{
  CI it = ParamMap_.find(name);
  if (it != ParamMap_.end()){
    return it->second->Group_;
  }
  BIASERR("no parameter with name "<<name);
  return GRP_ALL;
}

int Param::GetGroupIDForGroupName(const string &name)
{
  for (unsigned int i=0;i<GroupNames_.size();i++)
    if (GroupNames_[i] == name) return i;
  return GRP_ALL;
}


int Param::SetGroupName(const int id, const string& name)
{
  int res=0;
  vector<int> ids=UniqueSortedGroups();
  if (find(ids.begin(), ids.end(), id)==ids.end()){
    //    BIASERR("unused group id "<<id);
    res=-1;
  } else {
    if (((*ids.rbegin())+1)>(int)GroupNames_.size()){
      GroupNames_.resize((*ids.rbegin())+1, "");
    }
    if(id<(int)GroupNames_.size())
        GroupNames_[id]=name;
  }
  return res;
}

std::string Param::GetGroupName(const int group_id)
{
  if (group_id==GRP_ALL){
    return "all";
  }
  if (group_id==GRP_NOSHOW){
    return "no show";
  }
  if (group_id>(int)(GroupNames_.size())-1 || group_id<0){
    BIASERR("invalid group id or no name given. "
        "group_id="<<group_id<<"GroupNames_.size()="<<GroupNames_.size())
        BIASBREAK;
    return "";
  }
  return GroupNames_[group_id];
}


vector<int> Param::UniqueSortedGroups()
{
  vector<int> res;
  CI it;
  for (it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
    if (it->second->WriteToFile_) res.push_back(it->second->Group_);
  }
  sort(res.begin(), res.end());
  vector<int>::iterator end = unique(res.begin(), res.end());
  res.erase(end, res.end());
  return res;
}

bool Param::IsUsedGroupID(const int group_id)
{
  vector<int> ids=UniqueSortedGroups();
  return (find(ids.begin(), ids.end(), group_id)!=ids.end());
}

int Param::GetSizeOfLongestParamName()
{
  unsigned length=0;
  // search for longest name
  unsigned i=0;
  for (CI it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
    if (it->second->Name_.size()>length &&
        !it->second->Enhanced_ && !it->second->Hidden_)
      length=it->second->Name_.size();
    i++;
  }
  return (int)length;
}

int Param::GetSizeOfLongestParamValueString()
{
  unsigned length=0;
  // search for longest name
  for (CI it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
    if (it->second->GetValueString().size()>length &&
        !it->second->Enhanced_ && !it->second->Hidden_)
      length=it->second->GetValueString().size();
  }
  return (int)length;
}




int Param::WriteParameter(const string &filename)
{
  ofstream ofs;
  // search for longest name to set namew
  int namew=GetSizeOfLongestParamName()+2, typew=12;
  int valuew=GetSizeOfLongestParamValueString()+2;
  if (WriteIndent_) {
    namew=(namew<20)?(20):namew;
    valuew=(valuew<7)?(7):valuew;
  }
  else {
    namew = 0;
    valuew = 0;
  }
  ofs.open(filename.c_str());
  if ( !ofs.is_open() )
    BIASERR( "File '" << filename << "' not opened!" << endl);

  ostringstream oss;
  vector<int> grps=UniqueSortedGroups();
  vector<int>::iterator git;
  for (git=grps.begin(); git!=grps.end(); git++){
    // dont write empty group headers into the parameter file:
    bool ThisGroupInUse = false;
    for ( CI it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
      if (it->second->WriteToFile_ && it->second->Group_ == *git
          && (WriteEnhanced_ || (!(*it).second->Enhanced_)) &&
          (!(*it).second->Hidden_)) {
            ThisGroupInUse = true;
            break;
      }
    }
    if (!ThisGroupInUse) continue;

    // this group will have at least one entry, write headline
    ofs <<"\n############### Group ID "<<*git<<" : "<<GetGroupName(*git)
    <<" #######################\n";

    // now write the group members
    for ( CI it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
      if (it->second->WriteToFile_ && it->second->Group_ == *git
          && (WriteEnhanced_ || (!(*it).second->Enhanced_)) &&
          (!(*it).second->Hidden_))
        {
          oss.str("");
          if (WriteComments_)
            // first, write name with comment
            ofs <<endl<<"# "<<it->second->Name_<<":  "<<it->second->GetHint()
            <<endl<<"# "<<it->second->Help_<<endl;
          // second write name = value
          oss <<setw(namew)<<it->first<<" = "
          <<setw(valuew)<<left<<it->second->GetValueString()<<right
          <<"  " ;
          while (oss.str().size() <40) oss<<" ";
          ofs <<oss.str();
          oss.str("");
          // third write type name
          oss << "PARAM_"<<it->second->GetTypeName();
          ofs << setw(typew) << oss.str()<< endl;
        }
    }
  }
  ofs.close();
  return 0;
}

#ifdef BIAS_HAVE_XML2

int Param::WriteParameterXML(const string &filename)
{
  // Tree for XML-file...
  XMLIO tree;
  // ...create base-node
  xmlNodePtr root = tree.create("XMLParamfile");
  tree.addAttribute(root, "Version", 0.1);

  stringstream tempString;

  vector<int> grps=UniqueSortedGroups();
  vector<int>::iterator git;
  for (git=grps.begin(); git!=grps.end(); git++){
    // dont write empty group headers into the parameter file:
    bool ThisGroupInUse = false;
    for ( CI it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
      if (it->second->WriteToFile_ && it->second->Group_ == *git
          && (WriteEnhanced_ || (!(*it).second->Enhanced_)) &&
          (!(*it).second->Hidden_)) {
            ThisGroupInUse = true;
            break;
      }
    }
    if (!ThisGroupInUse) continue;

    // this group will have at least one entry, create group-node...
    // ... but first erase blanks in group-name and add ID
    {
      const char *groupName = (GetGroupName(*git)).c_str();
      int i=0;
      tempString << "Group_" << *git << "_";
      while (groupName[i] != 0) {
        if (groupName[i] == ' ') {
          tempString << '_';
        } else {
          tempString << groupName[i];
        }
        i++;
      }
    }

    xmlNodePtr groupNode = tree.addChildNode(root, tempString.str());
    if (groupNode == NULL) {
      BIASERR("Error creating group: " + tempString.str() +
          " / " + GetGroupName(*git));
      return -1;
    }
    tempString.str("");
    tree.addAttribute(groupNode, "GroupID", *git);

    // now create the group's member-nodes
    for ( CI it=ParamMap_.begin(); it!=ParamMap_.end(); it++){
      if (it->second->WriteToFile_ && it->second->Group_ == *git
          && (WriteEnhanced_ || (!(*it).second->Enhanced_)) &&
          (!(*it).second->Hidden_))
        {

          xmlNodePtr lastNode = groupNode;
          std::string name = it->first;
          std::string::size_type lastFound = std::string::npos;
          std::string::size_type found = name.rfind('-');
          int depth = 1;
          while (found != string::npos){
            tempString << name.substr(found+1, lastFound-found);
            lastFound = found-1;

            xmlNodePtr temp = tree.getChild(lastNode, tempString.str());
            if (temp == NULL){
              lastNode = tree.addChildNode(lastNode, tempString.str());
              if (lastNode == NULL){
                BIASERR("Error creating SubGroup: " + tempString.str() +
                    " / " + name);
                return -1;
              }
              tree.addAttribute(lastNode, "SubGroup", depth);
            } else {
              lastNode = temp;
            }

            tempString.str("");
            found = name.rfind('-',lastFound);
            depth++;
          }
          if (lastFound == std::string::npos) {
            tempString << name;
          } else {
            tempString << name.substr(0,lastFound+1);
          }

          lastNode = tree.addChildNode(lastNode, tempString.str());
          if (lastNode == NULL){
            BIASERR("Error creating param: " + tempString.str() +
                " / " + name);
            return -1;
          }
          tempString.str("");

          //first: set comments if desired
          if (WriteComments_) {
            tree.addComment(lastNode, it->second->Help_);
          }

          //second: set name and value(s)
          if (it->second->GetTypeName() == "BOOL") {
            tree.addAttribute(lastNode, "Value",
                ((ParamTypeBool*) it->second)->value_);
            tree.addAttribute(lastNode, "Default",
                ((ParamTypeBool*) it->second)->default_);
            tree.addAttribute(lastNode, "Name", it->second->Name_);
          } else if (it->second->GetTypeName() == "INT") {
            tree.addAttribute(lastNode, "Value",
                ((ParamTypeInt*) it->second)->value_);
            tree.addAttribute(lastNode, "Range", it->second->GetHint());
            tree.addAttribute(lastNode, "Default",
                ((ParamTypeInt*) it->second)->default_);
            tree.addAttribute(lastNode, "Name", it->second->Name_);
          } else if (it->second->GetTypeName() == "DOUBLE") {
            tree.addAttribute(lastNode, "Value",
                ((ParamTypeDouble*) it->second)->value_);
            tree.addAttribute(lastNode, "Range", it->second->GetHint());
            tree.addAttribute(lastNode, "Default",
                ((ParamTypeDouble*) it->second)->default_);
            tree.addAttribute(lastNode, "Name", it->second->Name_);
          } else if (it->second->GetTypeName() == "STRING") {
            tree.addAttribute(lastNode, "Value",
                ((ParamTypeString*) it->second)->value_);
            tree.addAttribute(lastNode, "Default",
                ((ParamTypeString*) it->second)->default_);
            tree.addAttribute(lastNode, "Name", it->second->Name_);
          } else if (it->second->GetTypeName() == "VECDBL") {
            tree.addAttribute(lastNode, "Value",
                ((ParamTypeVecDbl*) it->second)->value_.GetSTLVec());
            tree.addAttribute(lastNode, "Default",
                ((ParamTypeVecDbl*) it->second)->default_.GetSTLVec());
            tree.addAttribute(lastNode, "Name", it->second->Name_);
          } else if (it->second->GetTypeName() == "VECINT") {
            tree.addAttribute(lastNode, "Value",
                ((ParamTypeVecInt*) it->second)->value_.GetSTLVec());
            tree.addAttribute(lastNode, "Default",
                ((ParamTypeVecInt*) it->second)->default_.GetSTLVec());
            tree.addAttribute(lastNode, "Name", it->second->Name_);
          } else if (it->second->GetTypeName() == "ENUM") {
            tree.addAttribute(lastNode, "Value",
                ((ParamTypeEnum*) it->second)->GetValueString());
            tree.addAttribute(lastNode, "Range", it->second->GetHint());
            tree.addAttribute(lastNode, "Name", it->second->Name_);
          } else {
            BIASERR("!!! No matching ParamType for attribute:"
                + it->second->GetTypeName() + " !!!");
            return -1;
          }

          //third: set type
          tree.addAttribute(lastNode, "Type", it->second->GetTypeName());
          //fourth: set enhanced or not enh.
          tree.addAttribute(lastNode, "Enhanced", it->second->Enhanced_);
        }
    }
  }

  // if XML-file has been written...
  if (tree.write(filename) == 0){
    // ...clear tree and exit ...
    tree.clear();
    return 0;
  }

  // else exit with error -1
  BIASERR("\nCould not write parameterfile:\n     " + filename + "\n");
  return -1;
}

#endif

int  Param::WriteRunMe(const std::string &filename)
{
  ofstream ofs;
  time_t now_s;
  struct tm* now;
  char datestr[20];
  string fname;

  time(&now_s);
  now = localtime(&now_s);//, &now);
  sprintf(datestr,"%4d-%02d-%02d-%02d:%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday,
      now->tm_hour,now->tm_min);

  fname = filename + datestr;
  ofs.open(fname.c_str());

  if (!ofs){
    perror(fname.c_str());
    return -1;
  }
  ofs <<"#!/bin/sh"<<endl<<endl;
  for (unsigned int i=0;i<ArgV_.size(); i++)
    ofs <<ArgV_[i]<<" ";
  ofs<<endl<<endl;
  ofs.close();
#ifndef  WIN32
  chmod(filename.c_str(),0755);
#endif //WIN32
  return 0;
}



void Param::SetDefaults()
{
  for (CI it=ParamMap_.begin(); it!=ParamMap_.end(); it++)
    it->second->SetDefault();
}


int Param::RegisterCallbackObject(const string &name,
    ParamCallbackInterface *obj)
{
  CI it;
  if ( (it=ParamMap_.find(name)) != ParamMap_.end()) {
    it->second->CallbackObject_ = obj;
    return 0;
  }
  BIASERR("Unknown parameter \""<<name<<"\"in RegisterCallbackObject()");
  return -1;
}

int  Param::SetRangeInt(const std::string &name,const int min, const int max)
{
  CI it;
  if ( (it=ParamMap_.find(name)) != ParamMap_.end()) {
    ParamTypeInt *pInt = dynamic_cast<ParamTypeInt *>(it->second);
    if (pInt != NULL) {
      pInt->min_ = min;
      pInt->max_  = max;
    }
    return 0;
  }
  BIASERR("Unknown parameter \""<<name<<"\"in RegisterCallbackObject()");
  return -1;
}


int Param::SetShortCommand(const string &name, const char cmd)
{
  CI it = ParamMap_.find(name);
  if ( it==ParamMap_.end() ){
    BIASERR("parameter "<<name<<" not found!");
    return -1;
  }
  else
    it->second->ShortCmd_ = cmd;
  return 0;
}

int Param::ParseListFile(const std::string& ListFileName,
    std::vector<std::string>& LinesInFile)
{
  ifstream ifs(ListFileName.c_str());
  if(!ifs) {
    BIASERR("stream to list file "<<ListFileName<<" could not be established");
    ifs.close();
    return -1;
  }

  stringstream sstr;
  sstr.str("");

  do {
    ifs.get(*(sstr.rdbuf()));//stream symbols til EOL or EOF(excludes EOL/EOF)
    if(sstr.str().size()>0) {
      LinesInFile.push_back(sstr.str());
    } else {
#ifdef BIAS_DEBUG
      //     cout<<"empty string\n";
#endif
    }
    sstr.clear();
    sstr.str("");
  } while(ifs.get()!=EOF);

  ifs.close();
  return 0;
}

// accessors because of protected-> private member to avoid DLL export JW
std::map<const std::string,BIAS::ParamTypeBase*> &
Param::GetParamMap()
{
  return ParamMap_;
}

const std::map<const std::string,BIAS::ParamTypeBase*> &
Param::GetParamMap() const
{
  return ParamMap_;
}

/**
 * \brief empties internal datastructures
 */
void Param::ClearAllParams(){
    ParamMap_.clear();
}