args.h

Go to the documentation of this file.

/***************************************************************************
*
* Authors:     Carlos Oscar S. Sorzano (coss@cnb.csic.es)
*
* Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
* 02111-1307  USA
*
*  All comments concerning this program package may be sent to the
*  e-mail address 'xmipp@cnb.csic.es'
***************************************************************************/

#ifndef CORE_ARGS_H
#define CORE_ARGS_H

#include "xmipp_strings.h"
#include "xmipp_error.h"

template <typename T>
class Matrix1D;

template <typename T>
void readFloatList(const char* str,
                   int N, std::vector< T >& v)
{
    T valueF;
    char* token;

    token = firstToken(str);
    for (int i = 0; i < N; i++)
    {
        if (token == NULL)
            REPORT_ERROR(ERR_VALUE_INCORRECT, "Cannot convert string into a list of numbers");

        valueF = (T) textToFloat(token);
        v.push_back(valueF);

        if (i != N - 1)
            token = nextToken();
    }
}

template <typename T>
void readFloatList(const std::string& str,
                   size_t& i,
                   int N,
                   std::vector< T >& v)
{
    T valueF;
    std::string token;

    token = nextToken(str, i);
    for (int j = 0; j < N; j++)
    {
        if (token == "")
            REPORT_ERROR(ERR_VALUE_INCORRECT, "Cannot convert string into list of floats");
        valueF = (T) textToFloat(token.c_str());
        v.push_back(valueF);

        if (j != N - 1)
            token = nextToken(str, i);
    }
}

template <typename T>
void readFloatList(const char* str,
                   int N,
                   Matrix1D< T >& v,
                   ErrorType _errno = ERR_VALUE_INCORRECT,
                   std::string errmsg = "Error reading floating list",
                   int exit = 0)
{
    T valueF;
    char* token;

    token = firstToken(str);
    for (int i = 0; i < N; i++)
    {
        if (token == NULL)
        {
            // CO: Should not report other error than the required one
            // std::cout << "Read float list: Number of true parameters doesn't coincide\n";
            REPORT_ERROR(_errno, errmsg);
        }

        try
        {
            valueF = (T) textToFloat(token);
        }
        catch (XmippError)
        {
            REPORT_ERROR(_errno, errmsg);
        }

        v(i) = valueF;
        if (i != N - 1)
            token = nextToken();
    }
}

const char* getParameter(int argc,
                   const char** argv,
                   const char* param,
                   const char* option = NULL);

bool getTwoDoubleParams(int argc,
                        const char** argv,
                        const char* param,
                        double& v1,
                        double& v2,
                        double v1_def,
                        double v2_def);

bool getThreeDoubleParams(int argc,
                          const char** argv,
                          const char* param,
                          double& v1,
                          double& v2,
                          double& v3,
                          double v1_def,
                          double v2_def,
                          double v3_def);

bool checkParameter(int argc, const char** argv, const char* param);

int paremeterPosition(int argc, const char** argv, const char* param);

int numComponents(const std::string& str);

Matrix1D< double > getVectorParameter(int argc,
                                      const char** argv,
                                      const char* param,
                                      int dim = 2);

Matrix1D<double> getVectorParameter(FILE *fh, const char *param, int dim=2);

void generateCommandLine(const std::string& command_line,
                         int& argcp,
                         char**& argvp,
                         char*& copy);

bool generateCommandLine(FILE* fh,
                         const char* param,
                         int& argcp,
                         char**& argvp,
                         char*& copy);

std::string getParameter(FILE* fh,
                         const char* param,
                         int skip = 0,
                         const char* option = NULL);

bool checkParameter(FILE* fh, const char* param);

#endif