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

    unsigned int numSlaves = m.slaveCount(), i, aliasIndex;

   112

    uint16_t lastAlias;

   113

    ec_ioctl_slave_t slave;

   114

    SlaveList list;

   115

   116

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

   117

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

   118

            // all items

   119

            for (i = 0; i < numSlaves; i++) {

   120

                m.getSlave(&slave, i);

   121

                list.push_back(slave);

   122

            }

   123

        } else { // no alias, but position given

   124

            // one item by position

   125

            m.getSlave(&slave, position);

   126

            list.push_back(slave);

   127

        }

   128

    } else { // alias given

   129

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

   130

            // take all items with a given alias

   131

            lastAlias = 0;

   132

            for (i = 0; i < numSlaves; i++) {

   133

                m.getSlave(&slave, i);

   134

                if (slave.alias) {

   135

                    lastAlias = slave.alias;

   136

                }

   137

                if (lastAlias == (uint16_t) alias) {

   138

                    list.push_back(slave);

   139

                }

   140

            }

   141

        } else { // alias and position given

   142

            lastAlias = 0;

   143

            aliasIndex = 0;

   144

            for (i = 0; i < numSlaves; i++) {

   145

                m.getSlave(&slave, i);

   146

                if (slave.alias) { // FIXME 'lock' first alias

   147

                    lastAlias = slave.alias;

   148

                    aliasIndex = 0;

   149

                }

   150

                if (lastAlias == (uint16_t) alias

   151

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

   152

                    list.push_back(slave);

   153

                }

   154

                aliasIndex++;

   155

            }

   156

        }

   157

    }

   158

   159

    return list;

   160

}

   161

   162

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

   163

   164

bool operator<(

   165

        const ec_ioctl_config_t &a,

   166

        const ec_ioctl_config_t &b

   167

        )

   168

{

   169

    return a.alias < b.alias

   170

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

   171

}

   172

   173

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

   174

   175

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

   176

{

   177

    unsigned int i;

   178

    ec_ioctl_master_t master;

   179

    ec_ioctl_config_t config;

   180

    ConfigList list;

   181

    stringstream err;

   182

   183

    m.getMaster(&master);

   184

   186

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

   187

            // all items

   188

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

   189

                m.getConfig(&config, i);

   190

                list.push_back(config);

   191

            }

   200

        }

   201

    } else { // alias given

   202

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

   203

            // take all items with a given alias

   204

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

   205

                m.getConfig(&config, i);

   207

                    list.push_back(config);

   208

                }

   209

            }

   210

        } else { // alias and position given

   211

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

   212

                m.getConfig(&config, i);

   214

                    list.push_back(config);

   215

                    break; // there can be at most one matching

   216

                }

   217

            }

   218

        }

   219

    }

   220

   221

    list.sort();

   222

    return list;

   223

}

   224

   225

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

   226

   227

string Command::alStateString(uint8_t state)

   228

{

   229

    switch (state) {

   230

        case 1: return "INIT";

   231

        case 2: return "PREOP";

   232

        case 4: return "SAFEOP";

   233

        case 8: return "OP";

   234

        default: return "???";

   235

    }

   236

}

   237

   238

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