8cb4bd7fdc8ce06a838aad6fb44a65cfa3a110ca
[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  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14 *
15 */
16
17 #ifndef __USER_HXX__
18 #define __USER_HXX__
19
20 #include "types.hxx"
21 #include "bool.hxx"
22
23 namespace types
24 {
25 class EXTERN_AST UserType : public GenericType
26 {
27 public :
28     UserType() {}
29     virtual ~UserType() {}
30
31     /*** non virtual function to prevent overriding in user derived class ***/
32
33     inline ScilabType       getType(void)
34     {
35         return ScilabUserType;
36     }
37
38     inline ScilabId         getId(void)
39     {
40         return IdUserType;
41     }
42
43     bool                    isUserType(void)
44     {
45         return true;
46     }
47
48     inline bool             isGenericType()
49     {
50         return false;
51     }
52
53 public :
54     /*** User will be asked to implement the following methods      ***/
55     /*** in order Scilab engine to manage correctly this user type  ***/
56
57     virtual std::wstring    getTypeStr() const = 0;
58     virtual std::wstring    getShortTypeStr() const = 0;
59     virtual UserType*       clone() = 0;
60
61 public :
62     /*** User can overload these methods                            ***/
63     /*** all methods not overloaded will call scilab overload       ***/
64
65     virtual Bool* equal(UserType*& /*ut*/)
66     {
67         return NULL;
68     }
69
70     // hasToString return false so scilab will call overload %..._p
71     // and toString method is useless
72     // if user overload hasToString for return true, he must overload toString method
73     // bool toString(std::wostringstream& ostr)
74     virtual bool hasToString()
75     {
76         return false;
77     }
78
79     // overload this method if hasToString method return true
80     virtual bool toString(std::wostringstream& /*ostr*/)
81     {
82         return false;
83     }
84
85     // insertion by value
86     // _pArs is a list of scilab types:: of where we want to extract
87     // _pSource is what we wan to insert
88     virtual UserType* insert(typed_list* /*_pArgs*/, InternalType* /*_pSource*/)
89     {
90         return NULL;
91     }
92
93     // this method is called to perform an extraction by field. ie : a = myUserType.myfield
94     // name is the field name
95     // out contain extraction of field
96     virtual bool extract(const std::wstring& /*name*/, InternalType *& /*out*/)
97     {
98         return false;
99     }
100
101     // extraction by value, this method can be only called by "invoke" method below.
102     // _pArs is a list of scilab types:: of where we want to extract
103     // return all element extracted, in case when multiple elements returned
104     // these elements must be stored in a types::List
105     virtual InternalType* extract(typed_list* /*_pArgs*/)
106     {
107         return NULL;
108     }
109
110     // if return false , Scilab will never call "invoke" method
111     virtual bool isInvokable() const
112     {
113         return true;
114     }
115
116     // hasInvokeOption must return true to call the user type with optional argument.
117     // ie : myUserType(a,b, opt=value, opt2=value2,...)
118     // in this case, "types::optional_list& opt" will contain opt and opt2.
119     // by default this method return false, the optional list is empty and the input list contains all arguments.
120     virtual bool hasInvokeOption() const
121     {
122         return false;
123     }
124
125     // invoke method is called when a UserType is called with "(...)" ie : a = myUserType(...)
126     // This implementation allow the use of extract method above, but it can be overloaded.
127     // Inputs :
128     //  in          : contain input arguments myUserType(arg1,arg2,...)
129     //  opt         : contain optional input arguments myUserType(arg1=..., arg2=..., ...)
130     //  _iRetCount  : is the number of output arguments (ie : [a,b] = myUserType(...), _iRetCount = 2)
131     //  out         : after "invoke" execution, will contain results
132     //  execFunc    : is used in case of macro call : Overload::call(L"A_Macro", in, _iRetCount, out, execFunc);
133     //  e           : Generally used to return the Location when thowing an error. ie : throw ast::InternalError(L"error message", 999, e.getLocation());
134     // Outputs :
135     // if false, Scilab will call the macro %UserType_e,where UserType is the string return by the method getShortTypeStr()
136     // if true, Scilab will set each elements of out in Scilab variables
137     virtual bool invoke(types::typed_list & in, types::optional_list & /*opt*/, int /*_iRetCount*/, types::typed_list & out, const ast::Exp & /*e*/) override
138     {
139         InternalType* pIT = extract(&in);
140         if (pIT)
141         {
142             out.push_back(pIT);
143             return true;
144         }
145
146         return false;
147     }
148
149     // used to compute the iterator in scilab loop "for"
150     // when type is a two dimensions array
151     // _iPos is the column position
152     virtual GenericType*  getColumnValues(int /*_iPos*/)
153     {
154         return NULL;
155     }
156
157     //called by save to export your usertype as basic scilab type
158     //if you do not want to overload this function, save will call %yourtype_save overload function
159     virtual InternalType* save()
160     {
161         return nullptr;
162     }
163
164     //load must be done by overload %yourtype_load and must returns a pointer on your UserType
165 };
166 }
167
168 #endif /* !__USER_HXX__ */