GPL + CeCILL Header change
[scilab.git] / scilab / modules / ast / includes / types / struct.hxx
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2011 - DIGITEO - Antoine ELIAS
4 *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  * === LICENSE_END ===
14 *
15 */
16
17 #ifndef __STRUCT_HXX__
18 #define __STRUCT_HXX__
19
20 #include "list.hxx"
21 #include "arrayof.hxx"
22 #include "singlestruct.hxx"
23
24 extern "C"
25 {
26 #include "localization.h"
27 }
28
29 namespace types
30 {
31 class EXTERN_AST Struct : public ArrayOf<SingleStruct*>
32 {
33 public :
34     ~Struct();
35     Struct();
36     Struct(int _iRows, int _iCols);
37     Struct(int _iDims, const int* _piDims);
38
39 private :
40     Struct(Struct* _oCellCopyMe);
41
42 public :
43
44     void                        whoAmI(void)
45     {
46         std::cout << "types::Struct";
47     };
48
49     inline ScilabType           getType(void)
50     {
51         return ScilabStruct;
52     }
53     inline ScilabId             getId(void)
54     {
55         return IdStruct;
56     }
57
58     bool                        isStruct()
59     {
60         return true;
61     }
62     bool                        isEmpty();
63
64     bool transpose(InternalType *& out);
65
66
67     /**
68     ** Clone
69     ** Create a new List and Copy all values.
70     */
71     Struct*                     clone();
72
73     Struct*                     set(int _iRows, int _iCols, SingleStruct* _pIT);
74     Struct*                     set(int _iRows, int _iCols, const SingleStruct* _pIT);
75     Struct*                     set(int _iIndex, SingleStruct* _pIT);
76     Struct*                     set(int _iIndex, const SingleStruct* _pIT);
77     Struct*                     set(SingleStruct** _pIT);
78
79     bool                        operator==(const InternalType& it);
80     bool                        operator!=(const InternalType& it);
81
82     /* return type as string ( double, int, cell, list, ... )*/
83     virtual std::wstring        getTypeStr()
84     {
85         return L"struct";
86     }
87     /* return type as short string ( s, i, ce, l, ... )*/
88     virtual std::wstring        getShortTypeStr()
89     {
90         return L"st";
91     }
92     virtual bool                isContainer(void)
93     {
94         return true;
95     }
96
97     bool isTrue()
98     {
99         return false;
100     }
101
102     virtual bool neg(InternalType *& /*out*/)
103     {
104         return false;
105     }
106
107     bool                        subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
108     String*                     getFieldNames();
109     bool                        exists(const std::wstring& _sKey);
110     Struct*                     addField(const std::wstring& _sKey);
111     Struct*                     addFieldFront(const std::wstring& _sKey);
112     Struct*                     removeField(const std::wstring& _sKey);
113     bool                        toString(std::wostringstream& ostr);
114     List*                       extractFieldWithoutClone(const std::wstring& _wstField);
115     std::vector<InternalType*>  extractFields(std::vector<std::wstring> _wstFields);
116     std::vector<InternalType*>  extractFields(typed_list* _pArgs);
117     inline InternalType *       extractField(const std::wstring& wstField);
118
119     Struct*                     resize(int* _piDims, int _iDims);
120     Struct*                     resize(int _iNewRows, int _iNewCols);
121
122     /*specials functions to disable clone operation during copydata*/
123     InternalType*               insertWithoutClone(typed_list* _pArgs, InternalType* _pSource);
124     InternalType*               extractWithoutClone(typed_list* _pArgs);
125     void                        setCloneInCopyValue(bool _val);
126
127     using ArrayOf<SingleStruct *>::extract;
128     bool extract(const std::wstring& name, InternalType *& out);
129
130     virtual bool invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_list & out, const ast::Exp & e) override;
131
132     virtual int getInvokeNbOut()
133     {
134         return -1;
135     }
136
137 private :
138     virtual SingleStruct*       getNullValue();
139     virtual Struct*             createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
140     virtual Struct*             createEmpty();
141     virtual SingleStruct*       copyValue(SingleStruct* _pData);
142     virtual void                deleteAll();
143     virtual void                deleteImg();
144     virtual SingleStruct**      allocData(int _iSize);
145     virtual void                deleteData(SingleStruct* data);
146
147     bool                        m_bDisableCloneInCopyValue;
148
149 };
150 }
151
152 #ifdef _MSC_VER
153 template class types::ArrayOf<types::SingleStruct*>; //Struct
154 #endif
155 #endif /* !__STRUCT_HXX__ */