1

/*****************************************************************************

     2

 *

     3

 * $Id$

     4

 *

     5

 ****************************************************************************/

     6

     7

#include "Command.h"

     8

     9

/*****************************************************************************/

    10

    11

Command::Command(const string &name, const string &briefDesc):

    12

    name(name),

    13

    briefDesc(briefDesc),

    14

    verbosity(Normal)

    15

{

    16

}

    17

    18

/*****************************************************************************/

    19

    20

Command::~Command()

    21

{

    22

}

    23

    24

/*****************************************************************************/

    25

    26

void Command::setVerbosity(Verbosity v)

    27

{

    28

	verbosity = v;

    29

};

    30

    31

/*****************************************************************************/

    32

    33

void Command::setAlias(int a)

    34

{

    35

	alias = a;

    36

};

    37

    38

/*****************************************************************************/

    39

    40

void Command::setPosition(int p)

    41

{

    42

	position = p;

    43

};

    44

    45

/****************************************************************************/

    46

    47

bool Command::matchesSubstr(const string &cmd) const

    48

{

    49

    return name.substr(0, cmd.length()) == cmd;

    50

}

    51

    52

/****************************************************************************/

    53

    54

bool Command::matchesAbbrev(const string &abb) const

    55

{

    56

    unsigned int i;

    57

    size_t pos = 0;

    58

    59

    for (i = 0; i < abb.length(); i++) {

    60

        pos = name.find(abb[i], pos);

    61

        if (pos == string::npos)

    62

            return false;

    63

    }

    64

    65

    return true;

    66

}

    67

    68

/*****************************************************************************/

    69

    70

string Command::numericInfo()

    71

{

    72

    stringstream str;

    73

    74

    str << "Numerical values can be specified either with decimal (no" << endl

    75

        << "prefix), octal (prefix '0') or hexadecimal (prefix '0x') base."

    76

        << endl;

    77

    78

    return str.str();

    79

}

    80

    81

/*****************************************************************************/

    82

    83

void Command::throwInvalidUsageException(const stringstream &s) const

    84

{

    85

    throw InvalidUsageException(s);

    86

}

    87

    88

/*****************************************************************************/

    89

    90

void Command::throwCommandException(const stringstream &s) const

    91

{

    92

    throw CommandException(s);

    93

}

    94

    95

/*****************************************************************************/

    96

    97

void Command::throwSingleSlaveRequired(unsigned int size) const

    98

{

    99

    stringstream err;

   100

   101

    err << "The slave selection matches " << size << "slaves. '"

   102

        << name << "' requires a single slave.";

   103

   104

    throwInvalidUsageException(err);

   105

}

   106

   107

/*****************************************************************************/

   108

   109

Command::SlaveList Command::selectedSlaves(MasterDevice &m)

   110

{

   111

    ec_ioctl_master_t master;

   112

    unsigned int i, aliasIndex;

   113

    uint16_t lastAlias;

   114

    ec_ioctl_slave_t slave;

   115

    SlaveList list;

   116

   117

    m.getMaster(&master);

   118

   119

    if (alias == -1) { // no alias given

   120

        if (position == -1) { // no alias and position given

   121

            // all items

   122

            for (i = 0; i < master.slave_count; i++) {

   123

                m.getSlave(&slave, i);

   124

                list.push_back(slave);

   125

            }

   126

        } else { // no alias, but position given

   127

            // one item by position

   128

            m.getSlave(&slave, position);

   129

            list.push_back(slave);

   130

        }

   131

    } else { // alias given

   132

        if (position == -1) { // alias, but no position given

   133

            // take all items with a given alias

   134

            lastAlias = 0;

   135

            for (i = 0; i < master.slave_count; i++) {

   136

                m.getSlave(&slave, i);

   137

                if (slave.alias) {

   138

                    lastAlias = slave.alias;

   139

                }

   140

                if (lastAlias == (uint16_t) alias) {

   141

                    list.push_back(slave);

   142

                }

   143

            }

   144

        } else { // alias and position given

   145

            lastAlias = 0;

   146

            aliasIndex = 0;

   147

            for (i = 0; i < master.slave_count; i++) {

   148

                m.getSlave(&slave, i);

   149

                if (slave.alias && slave.alias == (uint16_t) alias) {

   150

                    lastAlias = slave.alias;

   151

                    aliasIndex = 0;

   152

                }

   153

                if (lastAlias && aliasIndex == (unsigned int) position) {

   154

                    list.push_back(slave);

   155

                }

   156

                aliasIndex++;

   157

            }

   158

        }

   159

    }

   160

   161

    return list;

   162

}

   163

   164

/*****************************************************************************/

   165

   166

bool operator<(

   167

        const ec_ioctl_config_t &a,

   168

        const ec_ioctl_config_t &b

   169

        )

   170

{

   171

    return a.alias < b.alias

   172

        || (a.alias == b.alias && a.position < b.position);

   173

}

   174

   175

/*****************************************************************************/

   176

   177

Command::ConfigList Command::selectedConfigs(MasterDevice &m)

   178

{

   179

    unsigned int i;

   180

    ec_ioctl_master_t master;

   181

    ec_ioctl_config_t config;

   182

    ConfigList list;

   183

    stringstream err;

   184

   185

    m.getMaster(&master);

   186

   187

    if (alias == -1) { // no alias given

   188

        if (position == -1) { // no alias and position given

   189

            // all items

   190

            for (i = 0; i < master.config_count; i++) {

   191

                m.getConfig(&config, i);

   192

                list.push_back(config);

   193

            }

   194

        } else { // no alias, but position given

   195

            for (i = 0; i < master.config_count; i++) {

   196

                m.getConfig(&config, i);

   197

                if (!config.alias && config.position == position) {

   198

                    list.push_back(config);

   199

                    break; // there can be at most one matching

   200

                }

   201

            }

   202

        }

   203

    } else { // alias given

   204

        if (position == -1) { // alias, but no position given

   205

            // take all items with a given alias

   206

            for (i = 0; i < master.config_count; i++) {

   207

                m.getConfig(&config, i);

   208

                if (config.alias == alias) {

   209

                    list.push_back(config);

   210

                }

   211

            }

   212

        } else { // alias and position given

   213

            for (i = 0; i < master.config_count; i++) {

   214

                m.getConfig(&config, i);

   215

                if (config.alias == alias && config.position == position) {

   216

                    list.push_back(config);

   217

                    break; // there can be at most one matching

   218

                }

   219

            }

   220

        }

   221

    }

   222

   223

    list.sort();

   224

    return list;

   225

}

   226

   227

/****************************************************************************/

   228

   229

string Command::alStateString(uint8_t state)

   230

{

   231

    switch (state) {

   232

        case 1: return "INIT";

   233

        case 2: return "PREOP";

   234

        case 4: return "SAFEOP";

   235

        case 8: return "OP";

   236

        default: return "???";

   237

    }

   238

}

   239

   240

/****************************************************************************/