hasInvokeOption added in UserType to allow the use of optional input arguments.
[scilab.git] / scilab / modules / ast / includes / types / user.hxx
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2010-2010 - DIGITEO - Bruno JOFRET
4 *  Copyright (C) 2014 - Scilab Enterprises - Cedric Delamarre
5 *
6 *  This file must be used under the terms of the CeCILL.
7 *  This source file is licensed as described in the file COPYING, which
8 *  you should have received as part of this distribution.  The terms
9 *  are also available at
10 *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11 *
12 */
13
14 #ifndef __USER_HXX__
15 #define __USER_HXX__
16
17 #include "types.hxx"
18
19 namespace types
20 {
21 class UserType : public GenericType
22 {
23 public :
24     UserType() {}
25     virtual ~UserType() {}
26
27     /*** non virtual function to prevent overriding in user derived class ***/
28
29     inline ScilabType       getType(void)
30     {
31         return ScilabUserType;
32     }
33
34     inline ScilabId         getId(void)
35     {
36         return IdUserType;
37     }
38
39     bool                    isUserType(void)
40     {
41         return true;
42     }
43
44 public :
45     /*** User will be asked to implement the following methods      ***/
46     /*** in order Scilab engine to manage correctly this user type  ***/
47
48     std::wstring    getTypeStr() = 0;
49     std::wstring    getShortTypeStr() = 0;
50     InternalType*   clone() = 0;
51
52 public :
53     /*** User can overload these methode ***/
54     /*** all methode not overloaded will call scilab overload       ***/
55
56     // hasToString return false so scilab will call overload %..._p
57     // and toString method is useless
58     // if user overload hasToString for return true, he must overload toString method
59     // bool toString(std::wostringstream& ostr)
60     virtual bool hasToString()
61     {
62         return false;
63     }
64
65     // overload this methode if hasToString methode return true
66     virtual bool toString(std::wostringstream& /*ostr*/)
67     {
68         return false;
69     }
70
71     // insertion by value
72     // _pArs is a list of scilab types:: of where we want to extract
73     // _pSource is what we wan to insert
74     virtual InternalType* insert(typed_list* /*_pArgs*/, InternalType* /*_pSource*/)
75     {
76         return NULL;
77     }
78
79     // this methode is called to perform an extraction by field. ie : a = myUserType.myfield
80     // name is the field name
81     // out contain extraction of field
82     virtual bool          extract(const std::wstring & /*name*/, InternalType *& /*out*/)
83     {
84         return false;
85     }
86
87     // extraction by value, this methode can be only called by "invoke" methode below.
88     // _pArs is a list of scilab types:: of where we want to extract
89     // return all element extracted, in case when multiple elements returned
90     // these elements must be stored in a types::List
91     virtual InternalType* extract(typed_list* /*_pArgs*/)
92     {
93         return NULL;
94     }
95
96     // if return false , Scilab will never call "invoke" method
97     virtual bool isInvokable() const
98     {
99         return true;
100     }
101
102     // hasInvokeOption must return true to call the user type with optional argument.
103     // ie : myUserType(a,b, opt=value, opt2=value2,...)
104     // in this case, "types::optional_list& opt" will contain opt and opt2.
105     // by default this method return false, the optional list is empty and the input list contains all arguments.
106     virtual bool hasInvokeOption() const
107     {
108         return false;
109     }
110
111     // invoke method is called when a UserType is called with "(...)" ie : a = myUserType(...)
112     // This implementation allow the use of extract method above, but it can be overloaded.
113     // Inputs :
114     //  in          : contain input arguments myUserType(arg1,arg2,...)
115     //  opt         : contain optional input arguments myUserType(arg1=..., arg2=..., ...)
116     //  _iRetCount  : is the number of output arguments (ie : [a,b] = myUserType(...), _iRetCount = 2)
117     //  out         : after "invoke" execution, will contain results
118     //  execFunc    : is used in case of macro call : Overload::call(L"A_Macro", in, _iRetCount, out, execFunc);
119     //  e           : Generally used to return the Location when thowing an error. ie : throw ast::ScilabError(L"error message", 999, e.getLocation());
120     // Outputs :
121     // if false, Scilab will call the macro %UserType_e,where UserType is the string return by the methode getShortTypeStr()
122     // if true, Scilab will set each elements of out in Scilab variables
123     virtual bool invoke(types::typed_list & in, types::optional_list & /*opt*/, int /*_iRetCount*/, types::typed_list & out, ast::ConstVisitor & /*execFunc*/, const ast::Exp & /*e*/)
124     {
125         InternalType* pIT = extract(&in);
126         if (pIT)
127         {
128             out.push_back(pIT);
129             return true;
130         }
131
132         return false;
133     }
134
135     // used to compute the iterator in scilab loop "for"
136     // when type is a two dimensions array
137     // _iPos is the column position
138     virtual GenericType*  getColumnValues(int /*_iPos*/)
139     {
140         return NULL;
141     }
142
143 };
144 }
145
146 #endif /* !__USER_HXX__ */