UT/UT_Args.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      PROGRAMMER
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Command Library (C++)
 *
 * COMMENTS:
 *
 */

#ifndef __UT_Args_H__
#define __UT_Args_H__

#include "UT_API.h"
#include <stdlib.h>
#include <SYS/SYS_Types.h>
#include "UT_WorkArgs.h"
#include "UT_Assert.h"

#define UT_MAX_OPTIONS          4       // A maximum of three args following
                                        //  an option
class UT_WorkBuffer;
class UT_String;

class UT_API UT_Args {
public:
             UT_Args();
    virtual ~UT_Args();

    int          argc() const           { return my_argc; }
    char        *argv(unsigned i)       { return myArgv(i); }
    const char  *argv(unsigned i) const { return myArgv(i); }
    char        **argv()                { return myArgv.getArgv(); }
    const char  **argv() const          { return myArgv.getArgv(); }
    char        *operator[](unsigned i) { return (i < my_argc) ? argv(i) : 0; }
    char        *operator()(unsigned i)
                 {
                     UT_ASSERT_P(i < my_argc);
                     return argv(i);
                 }

    int          found(int opt) const
                 {
                     UT_ASSERT_P(opt >= 0 && opt < 128);
                     return my_found[opt];
                 }
    char        *argp(int opt, int which=0)
                 {
                     UT_ASSERT_P(opt >= 0 && opt < 128);
                     UT_ASSERT_P(which >= 0 && which < UT_MAX_OPTIONS);
                     return my_opt[opt][which];
                 }
    char        *argp2(int opt)
                 {
                     return my_opt[opt][1];
                 }
    char        *argp3(int opt)
                 {
                     UT_ASSERT_P(opt >= 0 && opt < 128);
                     return my_opt[opt][2];
                 }

    fpreal       fargp(int opt, int which=0) const
                 {
                     UT_ASSERT_P(opt >= 0 && opt < 128);
                     UT_ASSERT_P(which >= 0 && which < UT_MAX_OPTIONS);
                     return atof(my_opt[opt][which]);
                 }
    fpreal       fargp2(int opt) const
                 {
                     UT_ASSERT_P(opt >= 0 && opt < 128);
                     return fargp(opt, 1);
                 }
    fpreal       fargp3(int opt) const
                 {
                     UT_ASSERT_P(opt >= 0 && opt < 128);
                     return fargp(opt, 2);
                 }

    int          iargp(int opt, int which=0) const
                 {
                     UT_ASSERT_P(opt >= 0 && opt < 128);
                     UT_ASSERT_P(which >= 0 && which < UT_MAX_OPTIONS);
                     return atoi(my_opt[opt][which]);
                 }
    int          iargp2(int opt) const { return (int)fargp(opt, 1); }
    int          iargp3(int opt) const { return (int)fargp(opt, 2); }

    void         initialize(int argc, char *argv[]);
    void         appendArg(char *arg);
    void         stripOptions(const char *options);

    // This method will make a command string out of all the arguments (and
    // options).  Arguments will be quoted according to 'csh' syntax.
    // If there's not enough room in the buffer, then 0 is returned (else 1)
    int          fillCommandLine(UT_WorkBuffer &buf,
                                 int first_arg=0,
                                 int include_options=1) const;

    // This version takes a UT_String and will always have room for the
    // command line.  'first_arg' is the first argument to be output; so by
    // default, the command name is not output (set to 0 if this is desired).
    void         makeCommandLine(UT_String &str, int first_arg=1) const;

    // Be careful calling this function. Note that the text parameter is a
    // non-const char *. This does not mean you should expect the text to be
    // freed for you. The reason it is non-const is that the getArg functions
    // all return non-const char *s.
    void         setArgument(int idx, char *text);

    void         display();

private:
    int           my_argc;              // Arg count (after options)
    UT_WorkArgs   myArgv;
    char          my_found[128];        // Options found (one for each char)
    char         *my_opt  [128][UT_MAX_OPTIONS];
};
#endif

---