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)

    84

{

    85

    throw InvalidUsageException(s);

    86

}

    87

    88

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

    89

    90

void Command::throwCommandException(const stringstream &s)

    91

{

    92

    throw CommandException(s);

    93

}

    94

    95

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

    96

    97

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

    98

{

    99

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

   100

    uint16_t lastAlias;

   101

    ec_ioctl_slave_t slave;

   102

    SlaveList list;

   103

   104

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

   105

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

   106

            // all items

   107

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

   108

                m.getSlave(&slave, i);

   109

                list.push_back(slave);

   110

            }

   111

        } else { // no alias, but position given

   112

            // one item by position

   113

            m.getSlave(&slave, position);

   114

            list.push_back(slave);

   115

        }

   116

    } else { // alias given

   117

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

   118

            // take all items with a given alias

   119

            lastAlias = 0;

   120

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

   121

                m.getSlave(&slave, i);

   122

                if (slave.alias) {

   123

                    lastAlias = slave.alias;

   124

                }

   125

                if (lastAlias == (uint16_t) alias) {

   126

                    list.push_back(slave);

   127

                }

   128

            }

   129

        } else { // alias and position given

   130

            lastAlias = 0;

   131

            aliasIndex = 0;

   132

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

   133

                m.getSlave(&slave, i);

   134

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

   135

                    lastAlias = slave.alias;

   136

                    aliasIndex = 0;

   137

                }

   138

                if (lastAlias == (uint16_t) alias

   139

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

   140

                    list.push_back(slave);

   141

                }

   142

                aliasIndex++;

   143

            }

   144

        }

   145

    }

   146

   147

    return list;

   148

}

   149

   150

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

   151

   152

string Command::alStateString(uint8_t state)

   153

{

   154

    switch (state) {

   155

        case 1: return "INIT";

   156

        case 2: return "PREOP";

   157

        case 4: return "SAFEOP";

   158

        case 8: return "OP";

   159

        default: return "???";

   160

    }

   161

}

   162

   163

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