File size: 3,907 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): Anton Deguet
  Created on: 2010-09-16

  (C) Copyright 2010-2014 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 Define an internal command for cisstMultiTask
*/


#ifndef _mtsCommandQueuedWriteReturn_h
#define _mtsCommandQueuedWriteReturn_h

#include <cisstMultiTask/mtsCommandWriteReturn.h>
#include <cisstMultiTask/mtsCommandQualifiedRead.h>
#include <cisstMultiTask/mtsCallableQualifiedReadBase.h>
#include <cisstMultiTask/mtsQueue.h>

// Always include last
#include <cisstMultiTask/mtsExport.h>

class mtsCommandWriteBase;

/*!
  \ingroup cisstMultiTask

 */

template <class _Base>
class mtsCommandQueuedWriteReturnBase: public _Base
{
public:
    typedef _Base BaseType;

    /*! This type. */
    typedef mtsCommandQueuedWriteReturnBase<_Base> ThisType;

    typedef typename _Base::CallableType CallableType;

protected:
    /*! Mailbox used to queue the commands */
    mtsMailBox * MailBox;

    size_t ArgumentQueueSize; // size used for queues

    /*! Queue to store arguments */
    mtsQueueGeneric ArgumentsQueue;

    /*! Queue to store pointer to return value */
    mtsQueue<mtsGenericObject *> ReturnsQueue;

    /*! Queue for return events (to send result to caller) */
    mtsQueue<mtsCommandWriteBase *> FinishedEventQueue;

private:
    /*! Private default constructor to prevent use. */
    mtsCommandQueuedWriteReturnBase(void);

    /*! Private copy constructor to prevent copies */
    mtsCommandQueuedWriteReturnBase(const ThisType & CMN_UNUSED(other));

public:

    /*! Constructor */
    mtsCommandQueuedWriteReturnBase(CallableType * callable, const std::string & name,
                                    const mtsGenericObject * argumentPrototype,
                                    const mtsGenericObject * resultPrototype,
                                    mtsMailBox * mailBox, size_t size);

    /*! Destructor */
    virtual ~mtsCommandQueuedWriteReturnBase();

    virtual std::string GetClassName(void) const;

    virtual ThisType * Clone(mtsMailBox * mailBox, size_t size) const;

    // virtual method defined in base class
    mtsExecutionResult Execute(const mtsGenericObject & argument,
                               mtsGenericObject & result);

    // virtual method defined in base class
    mtsExecutionResult Execute(const mtsGenericObject & argument,
                               mtsGenericObject & result,
                               mtsCommandWriteBase * finishedEventHandler);

    std::string GetMailBoxName(void) const;

    inline virtual mtsGenericObject * ArgumentPeek(void) {
        return ArgumentsQueue.Peek();
    }

    inline virtual mtsGenericObject * ArgumentGet(void) {
        return ArgumentsQueue.Get();
    }

    inline virtual mtsGenericObject * ReturnGet(void) {
        return *(ReturnsQueue.Get());
    }

    inline virtual mtsCommandWriteBase * FinishedEventGet(void) {
        return *(FinishedEventQueue.Get());
    }

    void ToStream(std::ostream & outputStream) const;
};

typedef mtsCommandQueuedWriteReturnBase<mtsCommandWriteReturn> mtsCommandQueuedWriteReturn;
typedef mtsCommandQueuedWriteReturnBase<mtsCommandQualifiedRead> mtsCommandQueuedQualifiedRead;

#ifdef CISST_COMPILER_IS_MSVC
#pragma warning ( disable : 4661 )
template class CISST_EXPORT mtsCommandQueuedWriteReturnBase<mtsCommandWriteReturn>;
template class CISST_EXPORT mtsCommandQueuedWriteReturnBase<mtsCommandQualifiedRead>;
#endif

#endif // _mtsCommandQueuedWriteReturn_h