File size: 3,684 Bytes
68ce2fc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Ankur Kapoor, Anton Deguet
  Created on: 2006-05-02

  (C) Copyright 2006-2009 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/


/*!
  \file
  \brief Defines a base class for a command
*/

#ifndef _mtsCommandBase_h
#define _mtsCommandBase_h

// These two includes are not required to compile this class but are
// pretty much always needed in conjunction with commands.  To ease
// the user's life, we include them now.
//include <cisstMultiTask/mtsGenericObjectProxy.h>
#include <cisstMultiTask/mtsExecutionResult.h>
#include <cisstMultiTask/mtsForwardDeclarations.h>

#include <iostream>
#include <sstream>

/*!
  \ingroup cisstMultiTask
*/
class mtsCommandBase {

private:
    /*! Private copy constructor to prevent copies */
    inline mtsCommandBase(const mtsCommandBase & CMN_UNUSED(other));

protected:
    /*! Name used for the command.  The name is provided to the
      constructor and can be accessed using the method GetName(). */
    std::string Name;

    /*! Flag used to determine is the command actually executes the
      provided method or function.  This "gated" command can be useful
      to turn on/off and event callback or to prevent calling a method
      owned by an object being deleted. */
    bool EnableFlag;

public:
    /*! The constructor. Does nothing */
    inline mtsCommandBase(void):
        Name("??"),
        EnableFlag(true)
    {}

    /*! Constructor with command name. */
    inline mtsCommandBase(const std::string & name):
        Name(name),
        EnableFlag(true)
    {}

    /*! The destructor. Does nothing */
    virtual ~mtsCommandBase() {}

    /*! For debugging. Generate a human readable output for the
      command object */
    //@{
    virtual std::string ToString(void) const  {
        std::stringstream outputStream;
        ToStream(outputStream);
        return outputStream.str();
    };
    virtual void ToStream(std::ostream & outputStream) const = 0;
    //@}

    /*! Returns number of arguments (parameters) expected by Execute
      method.  Must be overloaded in derived classes. */
    virtual size_t NumberOfArguments(void) const = 0;

    virtual bool Returns(void) const = 0;

    /*! Set and access the "enable" flag.  This flag is used to
      determine if the command actually uses the provided method or
      function when it is executed. */
    //@{
    inline void Enable(void) {
        this->EnableFlag = true;
    }

    inline void Disable(void) {
        this->EnableFlag = false;
    }

    inline bool IsEnabled(void) const {
        return this->EnableFlag;
    }

    inline bool IsDisabled(void) const {
        return !(this->EnableFlag);
    }
    //@}

    /*! Get the command name.  This method doesn't allow to change the
      command name. */
    inline const std::string & GetName(void) const {
        return this->Name;
    }
};


/*! Stream out operator for all classes derived from mtsCommandBase.
  This operator uses the ToStream method so that the output can be
  different for each derived class. */
inline std::ostream & operator << (std::ostream & outputStream,
                                   const mtsCommandBase & command) {
    command.ToStream(outputStream);
    return outputStream;
}


#endif // _mtsCommandBase_h