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

void Command::setDomain(int d)

    48

{

    49

	domain = d;

    50

};

    51

    52

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

    53

    54

void Command::setDataType(const string &t)

    55

{

    56

	dataType = t;

    57

};

    58

    59

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

    60

    61

void Command::setForce(bool f)

    62

{

    63

	force = f;

    64

};

    65

    66

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

    67

    68

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

    69

{

    70

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

    71

}

    72

    73

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

    74

    75

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

    76

{

    77

    unsigned int i;

    78

    size_t pos = 0;

    79

    80

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

    81

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

    82

        if (pos == string::npos)

    83

            return false;

    84

    }

    85

    86

    return true;

    87

}

    88

    89

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

    90

    91

string Command::numericInfo()

    92

{

    93

    stringstream str;

    94

    95

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

    96

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

    97

        << endl;

    98

    99

    return str.str();

   100

}

   101

   102

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

   103

   104

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

   105

{

   106

    throw InvalidUsageException(s);

   107

}

   108

   109

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

   110

   111

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

   112

{

   113

    throw CommandException(s);

   114

}

   115

   116

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

   117

   118

void Command::throwSingleSlaveRequired(unsigned int size) const

   119

{

   120

    stringstream err;

   121

   122

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

   123

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

   124

   125

    throwInvalidUsageException(err);

   126

}

   127

   128

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

   129

   130

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

   131

{

   132

    ec_ioctl_master_t master;

   133

    unsigned int i, aliasIndex;

   134

    uint16_t lastAlias;

   135

    ec_ioctl_slave_t slave;

   136

    SlaveList list;

   137

   138

    m.getMaster(&master);

   139

   140

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

   141

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

   142

            // all items

   143

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

   144

                m.getSlave(&slave, i);

   145

                list.push_back(slave);

   146

            }

   147

        } else { // no alias, but position given

   148

            // one item by position

   149

            m.getSlave(&slave, position);

   150

            list.push_back(slave);

   151

        }

   152

    } else { // alias given

   153

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

   154

            // take all items with a given alias

   155

            lastAlias = 0;

   156

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

   157

                m.getSlave(&slave, i);

   158

                if (slave.alias) {

   159

                    lastAlias = slave.alias;

   160

                }

   161

                if (lastAlias == (uint16_t) alias) {

   162

                    list.push_back(slave);

   163

                }

   164

            }

   165

        } else { // alias and position given

   166

            lastAlias = 0;

   167

            aliasIndex = 0;

   168

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

   169

                m.getSlave(&slave, i);

   170

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

   171

                    lastAlias = slave.alias;

   172

                    aliasIndex = 0;

   173

                }

   174

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

   175

                    list.push_back(slave);

   176

                }

   177

                aliasIndex++;

   178

            }

   179

        }

   180

    }

   181

   182

    return list;

   183

}

   184

   185

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

   186

   187

bool operator<(

   188

        const ec_ioctl_config_t &a,

   189

        const ec_ioctl_config_t &b

   190

        )

   191

{

   192

    return a.alias < b.alias

   193

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

   194

}

   195

   196

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

   197

   198

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

   199

{

   200

    unsigned int i;

   201

    ec_ioctl_master_t master;

   202

    ec_ioctl_config_t config;

   203

    ConfigList list;

   204

    stringstream err;

   205

   206

    m.getMaster(&master);

   207

   208

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

   209

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

   210

            // all items

   211

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

   212

                m.getConfig(&config, i);

   213

                list.push_back(config);

   214

            }

   215

        } else { // no alias, but position given

   216

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

   217

                m.getConfig(&config, i);

   218

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

   219

                    list.push_back(config);

   220

                    break; // there can be at most one matching

   221

                }

   222

            }

   223

        }

   224

    } else { // alias given

   225

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

   226

            // take all items with a given alias

   227

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

   228

                m.getConfig(&config, i);

   229

                if (config.alias == alias) {

   230

                    list.push_back(config);

   231

                }

   232

            }

   233

        } else { // alias and position given

   234

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

   235

                m.getConfig(&config, i);

   236

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

   237

                    list.push_back(config);

   238

                    break; // there can be at most one matching

   239

                }

   240

            }

   241

        }

   242

    }

   243

   244

    list.sort();

   245

    return list;

   246

}

   247

   248

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

   249

   250

Command::DomainList Command::selectedDomains(MasterDevice &m)

   251

{

   252

	ec_ioctl_domain_t d;

   253

	DomainList list;

   254

   255

    if (domain == -1) {

   256

		ec_ioctl_master_t master;

   257

        unsigned int i;

   258

   259

        m.getMaster(&master);

   260

   261

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

   262

			m.getDomain(&d, i);

   263

			list.push_back(d);

   264

        }

   265

    } else {

   266

		m.getDomain(&d, domain);

   267

		list.push_back(d);

   268

    }

   269

   270

	return list;

   271

}

   272

   273

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

   274

   275

string Command::alStateString(uint8_t state)

   276

{

   277

    switch (state) {

   278

        case 1: return "INIT";

   279

        case 2: return "PREOP";

   280

        case 4: return "SAFEOP";

   281

        case 8: return "OP";

   282

        default: return "???";

   283

    }

   284

}

   285

   286

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