return exps_t(std::next(_exps.begin()), _exps.end());
}
- inline bool isMemfillExp() const
+ inline bool isMemfillExp() const override
{
return true;
}
- virtual ExpType getType() const
+ virtual ExpType getType() const override
{
return MEMFILLEXP;
}
virtual void deleteImg() = 0;
public :
- bool isArrayOf()
+ bool isArrayOf() override
{
return true;
}
- bool isTrue();
+ bool isTrue() override;
// The function is not write here because we needs to create a Bool which inherits from ArrayOf<int>
// so it will create a cyclic dependency... so the body of the function is in bool.hxx after the Bool definition.
- virtual bool neg(InternalType *& out);
+ virtual bool neg(InternalType *& out) override;
virtual bool isVector() //only one dim must be != 1
{
return true;
}
- virtual bool isComplex()
+ virtual bool isComplex() override
{
return m_pImgData != NULL;
}
return getImg(getIndex(piIndexes));
}
- virtual ArrayOf<T>* insert(typed_list* _pArgs, InternalType* _pSource);
+ virtual ArrayOf<T>* insert(typed_list* _pArgs, InternalType* _pSource) override;
virtual ArrayOf<T>* append(int _iRows, int _iCols, InternalType* _poSource);
- virtual ArrayOf<T>* resize(int* _piDims, int _iDims);
+ virtual ArrayOf<T>* resize(int* _piDims, int _iDims) override;
// return a GenericType because of [] wich is a types::Double (can't be a ArrayOf<char>)
- virtual GenericType* remove(typed_list* _pArgs);
- virtual GenericType* extract(typed_list* _pArgs);
- virtual GenericType* insertNew(typed_list* _pArgs);
+ virtual GenericType* remove(typed_list* _pArgs) override;
+ virtual GenericType* extract(typed_list* _pArgs) override;
+ virtual GenericType* insertNew(typed_list* _pArgs) override;
virtual bool invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & e) override;
- virtual bool isInvokable() const;
- virtual bool hasInvokeOption() const;
- virtual int getInvokeNbIn();
- virtual int getInvokeNbOut();
+ virtual bool isInvokable() const override;
+ virtual bool hasInvokeOption() const override;
+ virtual int getInvokeNbIn() override;
+ virtual int getInvokeNbOut() override;
- virtual ArrayOf<T>* reshape(int _iNewRows, int _iNewCols)
+ virtual ArrayOf<T>* reshape(int _iNewRows, int _iNewCols) override
{
int piDims[2] = {_iNewRows, _iNewCols};
return reshape(piDims, 2);
}
- virtual ArrayOf<T>* reshape(int* _piDims, int _iDims);
+ virtual ArrayOf<T>* reshape(int* _piDims, int _iDims) override;
- virtual ArrayOf<T>* resize(int _iNewRows, int _iNewCols)
+ virtual ArrayOf<T>* resize(int _iNewRows, int _iNewCols) override
{
int piDims[2] = {_iNewRows, _iNewCols};
return resize(piDims, 2);
void getIndexes(int _iIndex, int* _piIndexes);
- virtual bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ virtual bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
void humanReadableByteCount(size_t n, char (&str)[9]);
- ArrayOf<T>* getColumnValues(int _iPos)
+ ArrayOf<T>* getColumnValues(int _iPos) override
{
ArrayOf<T>* pOut = NULL;
if (_iPos < m_iCols)
return pOut;
}
- virtual bool toString(std::wostringstream& ostr)
+ virtual bool toString(std::wostringstream& ostr) override
{
int* piDims = new int[m_iDims];
bool bFinish = parseSubMatrix(ostr, piDims, m_iDims, m_iDims - 1);
virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) = 0;
- virtual std::wstring toStringInLine()
+ virtual std::wstring toStringInLine() override
{
std::wostringstream ostr;
ostr << L"[";
Bool(int _iRows, int _iCols, int **_piData);
~Bool();
- Bool* clone();
+ Bool* clone() override;
/*zero or one set filler*/
Bool* setTrue();
/*Config management*/
- void whoAmI();
+ void whoAmI() override;
- bool isBool()
+ bool isBool() override
{
return true;
}
- bool operator==(const InternalType& it);
- bool operator!=(const InternalType& it);
+ bool operator==(const InternalType& it) override;
+ bool operator!=(const InternalType& it) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"boolean";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"b";
}
- virtual bool transpose(InternalType *& out);
+ virtual bool transpose(InternalType *& out) override;
virtual bool isNativeType() override
{
}
protected :
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabBool;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return isScalar() ? IdScalarBool : IdBool;
}
- virtual ast::Exp* getExp(const Location& loc);
+ virtual ast::Exp* getExp(const Location& loc) override;
private :
virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
- virtual int getNullValue();
- virtual Bool* createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
- virtual int copyValue(int _iData);
- virtual void deleteAll();
- virtual void deleteImg();
- virtual int* allocData(int _iSize);
+ virtual int getNullValue() override;
+ virtual Bool* createEmpty(int _iDims, int* _piDims, bool _bComplex = false) override;
+ virtual int copyValue(int _iData) override;
+ virtual void deleteAll() override;
+ virtual void deleteImg() override;
+ virtual int* allocData(int _iSize) override;
};
}
}
virtual ~Callable() {}
- bool isCallable()
+ bool isCallable() override
{
return true;
}
virtual bool invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_list & out, const ast::Exp & e) override;
- virtual bool isInvokable() const
+ virtual bool isInvokable() const override
{
return true;
}
- virtual bool hasInvokeOption() const
+ virtual bool hasInvokeOption() const override
{
return true;
}
- virtual int getInvokeNbIn()
+ virtual int getInvokeNbIn() override
{
return getNbInputArgument();
}
- virtual int getInvokeNbOut()
+ virtual int getInvokeNbOut() override
{
return getNbOutputArgument();
}
}
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"callable";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const = 0;
- virtual InternalType* clone(void) = 0;
+ virtual std::wstring getShortTypeStr() const override = 0;
+ virtual InternalType* clone(void) override = 0;
- virtual bool isAssignable(void)
+ virtual bool isAssignable(void) override
{
return true;
}
void createCell(int _iDims, const int* _piDims, InternalType** data);
public :
- void whoAmI(void)
+ void whoAmI(void) override
{
std::cout << "types::Cell";
};
- ScilabType getType(void)
+ ScilabType getType(void) override
{
return ScilabCell;
}
- ScilabId getId(void)
+ ScilabId getId(void) override
{
return IdCell;
}
- bool isCell()
+ bool isCell() override
{
return true;
}
** Clone
** Create a new List and Copy all values.
*/
- Cell* clone();
+ Cell* clone() override;
- Cell* set(int _iRows, int _iCols, InternalType* _pIT);
+ Cell* set(int _iRows, int _iCols, InternalType* _pIT) override;
Cell* set(int _iRows, int _iCols, const InternalType* _pIT);
- Cell* set(int _iIndex, InternalType* _pIT);
+ Cell* set(int _iIndex, InternalType* _pIT) override;
Cell* set(int _iIndex, const InternalType* _pIT);
- Cell* set(InternalType** _pIT);
+ Cell* set(InternalType** _pIT) override;
- bool operator==(const InternalType& it);
- bool operator!=(const InternalType& it);
+ bool operator==(const InternalType& it) override;
+ bool operator!=(const InternalType& it) override;
Cell* insertCell(typed_list* _pArgs, InternalType* _pSource);
static Cell* insertNewCell(typed_list* _pArgs, InternalType* _pSource);
List* extractCell(typed_list* _pArgs);
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"cell";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"ce";
};
- virtual bool isContainer(void)
+ virtual bool isContainer(void) override
{
return true;
}
bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
- bool isTrue()
+ bool isTrue() override
{
return false;
}
- virtual bool neg(InternalType *& /*out*/)
+ virtual bool neg(InternalType *& /*out*/) override
{
return false;
}
- virtual bool transpose(InternalType *& out);
+ virtual bool transpose(InternalType *& out) override;
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
private :
- virtual InternalType* getNullValue();
- virtual Cell* createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
- virtual Cell* createEmpty();
- virtual InternalType* copyValue(InternalType* _pData);
- virtual void deleteAll();
- virtual void deleteImg();
- virtual InternalType** allocData(int _iSize);
- virtual void deleteData(InternalType* _pData);
+ virtual InternalType* getNullValue() override;
+ virtual Cell* createEmpty(int _iDims, int* _piDims, bool _bComplex = false) override;
+ virtual Cell* createEmpty() override;
+ virtual InternalType* copyValue(InternalType* _pData) override;
+ virtual void deleteAll() override;
+ virtual void deleteImg() override;
+ virtual InternalType** allocData(int _iSize) override;
+ virtual void deleteData(InternalType* _pData) override;
};
}
bool setOnes();
/*Config management*/
- void whoAmI();
+ void whoAmI() override;
bool isEmpty();
- Double* clone();
+ Double* clone() override;
bool fillFromCol(int _iCols, Double *_poSource);
bool fillFromRow(int _iRows, Double *_poSource);
- Double* append(int _iRows, int _iCols, InternalType* _poSource);
+ Double* append(int _iRows, int _iCols, InternalType* _poSource) override;
//bool append(int _iRows, int _iCols, Double *_poSource);
- bool operator==(const InternalType& it);
- bool operator!=(const InternalType& it);
+ bool operator==(const InternalType& it) override;
+ bool operator!=(const InternalType& it) override;
- bool isDouble()
+ bool isDouble() override
{
return true;
}
- bool isComplex()
+ bool isComplex() override
{
return (m_pImgData != NULL) || isViewAsZComplex();
}
return true;
}
- bool isTrue();
+ bool isTrue() override;
- bool neg(InternalType *& out)
+ bool neg(InternalType *& out) override
{
if (isEmpty())
{
void convertFromZComplex();
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"constant";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"s";
}
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabDouble;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return isIdentity() ? isComplex() ? IdIdentityComplex : IdIdentity
: isEmpty() ? IdEmpty
}
- virtual bool adjoint(InternalType *& out)
+ virtual bool adjoint(InternalType *& out) override
{
if (isEmpty())
{
return false;
}
- virtual bool transpose(InternalType *& out)
+ virtual bool transpose(InternalType *& out) override
{
if (isEmpty())
{
return false;
}
- virtual ast::Exp* getExp(const Location& loc);
+ virtual ast::Exp* getExp(const Location& loc) override;
- virtual Double* set(int _iPos, const double _data)
+ virtual Double* set(int _iPos, const double _data) override
{
if (_iPos >= m_iSize)
{
return this;
}
- virtual Double* set(int _iRows, int _iCols, const double _data)
+ virtual Double* set(int _iRows, int _iCols, const double _data) override
{
return set(_iCols * getRows() + _iRows, _data);
}
- virtual Double* set(double* _pdata)
+ virtual Double* set(double* _pdata) override
{
if (m_pRealData == NULL)
{
return this;
}
- virtual Double* set(const double* _pdata)
+ virtual Double* set(const double* _pdata) override
{
if (m_pRealData == NULL)
{
private:
virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
- virtual double getNullValue();
- virtual Double* createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
- virtual double copyValue(double _dblData);
- virtual void deleteAll();
- virtual void deleteImg();
- virtual double* allocData(int _iSize);
- virtual void deleteData(double /*data*/) { }
+ virtual double getNullValue() override;
+ virtual Double* createEmpty(int _iDims, int* _piDims, bool _bComplex = false) override;
+ virtual double copyValue(double _dblData) override;
+ virtual void deleteAll() override;
+ virtual void deleteImg() override;
+ virtual double* allocData(int _iSize) override;
+ virtual void deleteData(double /*data*/) override { }
bool m_bViewAsInteger;
bool m_bViewAsZComplex;
~Function();
//FIXME : Should not return NULL
- virtual Function* clone();
- virtual bool operator==(const InternalType& it);
+ virtual Function* clone() override;
+ virtual bool operator==(const InternalType& it) override;
static Function* createFunction(const std::wstring& _wstName, GW_FUNC _pFunc, const std::wstring& _wstModule);
static Function* createFunction(const std::wstring& _wstName, GW_FUNC_OPT _pFunc, const std::wstring& _wstModule);
static Function* createFunction(const std::wstring& _wstFunctionName, const std::wstring& _wstEntryPointName, const std::wstring& _wstLibName, FunctionType _iType, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule, bool _bCloseLibAfterCall = false);
static Function* createFunction(const std::wstring& _wstFunctionName, const std::wstring& _wstEntryPointName, const std::wstring& _wstLibName, FunctionType _iType, const std::wstring& _wstLoadDepsName, const std::wstring& _wstModule, bool _bCloseLibAfterCall = false);
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabFunction;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return IdFunction;
}
- bool isFunction()
+ bool isFunction() override
{
return true;
}
- void whoAmI();
+ void whoAmI() override;
- bool toString(std::wostringstream& ostr);
+ bool toString(std::wostringstream& ostr) override;
virtual ReturnValue call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"fptr";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"fptr";
}
OptFunction(const std::wstring& _wstName, GW_FUNC_OPT _pFunc, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule);
Callable::ReturnValue call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
- OptFunction* clone();
+ OptFunction* clone() override;
GW_FUNC_OPT getFunc()
{
WrapFunction(const std::wstring& _wstName, OLDGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule);
Callable::ReturnValue call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
- WrapFunction* clone();
+ WrapFunction* clone() override;
OLDGW_FUNC getFunc()
{
WrapCFunction(const std::wstring& _wstName, GW_C_FUNC _pFunc, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule);
Callable::ReturnValue call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
- WrapCFunction* clone();
+ WrapCFunction* clone() override;
GW_C_FUNC getFunc()
{
WrapMexFunction(const std::wstring& _wstName, MEXGW_FUNC _pFunc, LOAD_DEPS _pLoadDeps, const std::wstring& _wstModule);
Callable::ReturnValue call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
- WrapMexFunction* clone();
+ WrapMexFunction* clone() override;
MEXGW_FUNC getFunc()
{
virtual ~GraphicHandle();
- GraphicHandle* clone();
+ GraphicHandle* clone() override;
- void whoAmI();
+ void whoAmI() override;
- bool isHandle()
+ bool isHandle() override
{
return true;
}
- bool isContainer()
+ bool isContainer() override
{
return true;
}
- bool operator==(const InternalType& it);
- bool operator!=(const InternalType& it);
+ bool operator==(const InternalType& it) override;
+ bool operator!=(const InternalType& it) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"handle";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"h";
}
- bool hasToString()
+ bool hasToString() override
{
return false;
}
- bool isTrue()
+ bool isTrue() override
{
return false;
}
- virtual bool neg(InternalType *& /*out*/)
+ virtual bool neg(InternalType *& /*out*/) override
{
return false;
}
- virtual bool transpose(InternalType *& out);
+ virtual bool transpose(InternalType *& out) override;
- virtual bool isFieldExtractionOverloadable() const
+ virtual bool isFieldExtractionOverloadable() const override
{
return true;
}
virtual bool invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_list & out, const ast::Exp & e) override ;
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
protected :
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabHandle;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return isScalar() ? IdScalarHandle : IdHandle;
}
private :
virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
- virtual long long getNullValue();
- virtual GraphicHandle* createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
- virtual long long copyValue(long long _handle);
- virtual void deleteAll();
- virtual void deleteImg();
- virtual long long* allocData(int _iSize);
+ virtual long long getNullValue() override;
+ virtual GraphicHandle* createEmpty(int _iDims, int* _piDims, bool _bComplex = false) override;
+ virtual long long copyValue(long long _handle) override;
+ virtual void deleteAll() override;
+ virtual void deleteImg() override;
+ virtual long long* allocData(int _iSize) override;
};
}
virtual ~ImplicitList();
ImplicitList(InternalType* _poStart, InternalType* _poStep, InternalType* _poEnd);
- ImplicitList* clone();
+ ImplicitList* clone() override;
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabImplicitList;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return IdImplicitList;
}
- bool isImplicitList()
+ bool isImplicitList() override
{
return true;
}
- virtual bool isAssignable(void)
+ virtual bool isAssignable(void) override
{
return true;
}
- inline virtual bool isInvokable() const
+ inline virtual bool isInvokable() const override
{
return true;
}
bool compute();
bool isComputable();
- bool toString(std::wostringstream& ostr);
+ bool toString(std::wostringstream& ostr) override;
InternalType::ScilabType getStartType();
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"implicitlist";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"ip";
}
void extractFullMatrix(T *_pT);
void extractFullMatrix(Double *_pdbl);
- virtual bool isTrue();
+ virtual bool isTrue() override;
- virtual bool transpose(InternalType *& out);
- virtual bool neg(InternalType *& out);
- virtual ast::Exp * getExp(const Location & loc);
+ virtual bool transpose(InternalType *& out) override;
+ virtual bool neg(InternalType *& out) override;
+ virtual ast::Exp * getExp(const Location & loc) override;
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
};
}
#endif
}
- Int<T>* clone()
+ Int<T>* clone() override
{
Int<T> *pbClone = new Int<T>(GenericType::getDims(), GenericType::getDimsArray());
pbClone->set(ArrayOf<T>::get());
}
/*Config management*/
- void whoAmI();
+ void whoAmI() override;
- bool isInt()
+ bool isInt() override
{
return true;
}
- bool neg(InternalType *& out)
+ bool neg(InternalType *& out) override
{
out = new Int<T>(this->getDims(), this->getDimsArray());
type_traits::bin_neg<T, T>(this->m_iSize, this->m_pRealData, static_cast<Int<T> *>(out)->get());
return true;
}
- virtual bool transpose(InternalType *& out)
+ virtual bool transpose(InternalType *& out) override
{
return type_traits::transpose(*this, out);
}
- bool operator==(const InternalType& it)
+ bool operator==(const InternalType& it) override
{
if (const_cast<InternalType &>(it).getType() != getType())
{
return true;
}
- bool operator!=(const InternalType& it)
+ bool operator!=(const InternalType& it) override
{
return !(*this == it);
}
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const;
+ virtual std::wstring getTypeStr() const override;
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"i";
}
}
protected :
- inline InternalType::ScilabType getType(void);
- inline InternalType::ScilabId getId(void);
+ inline InternalType::ScilabType getType(void) override;
+ inline InternalType::ScilabId getId(void) override;
private :
virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int /*_iDims*/) override
return true;
}
- virtual T getNullValue()
+ virtual T getNullValue() override
{
return T(0);
}
- virtual Int<T>* createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/)
+ virtual Int<T>* createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/) override
{
return new Int<T>(_iDims, _piDims);
}
- virtual T copyValue(T _data)
+ virtual T copyValue(T _data) override
{
return _data;
}
- virtual void deleteAll()
+ virtual void deleteAll() override
{
delete[] ArrayOf<T>::m_pRealData;
ArrayOf<T>::m_pRealData = NULL;
deleteImg();
}
- virtual void deleteImg() { }
+ virtual void deleteImg() override { }
- virtual T* allocData(int _iSize)
+ virtual T* allocData(int _iSize) override
{
return new T[_iSize];
}
};
public:
- bool isInt8()
+ bool isInt8() override
{
return is_same_int<T, char>::value;
}
- bool isInt16()
+ bool isInt16() override
{
return is_same_int<T, short>::value;
}
- bool isInt32()
+ bool isInt32() override
{
return is_same_int<T, int>::value;
}
- bool isInt64()
+ bool isInt64() override
{
return is_same_int<T, long long>::value;
}
- bool isUInt8()
+ bool isUInt8() override
{
return is_same_int<T, unsigned char>::value;
}
- bool isUInt16()
+ bool isUInt16() override
{
return is_same_int<T, unsigned short>::value;
}
- bool isUInt32()
+ bool isUInt32() override
{
return is_same_int<T, unsigned int>::value;
}
- bool isUInt64()
+ bool isUInt64() override
{
return is_same_int<T, unsigned long long>::value;
}
std::vector<InternalType *>* getData();
List(List *_oListCopyMe);
public :
- int getSize() const;
+ int getSize() const override;
- void whoAmI(void)
+ void whoAmI(void) override
{
std::cout << "types::List";
};
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabList;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return IdList;
}
-
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
-
+
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
+
/**
** append(InternalType *_typedValue)
** Append the given value to the end of the List
** Clone
** Create a new List and Copy all values.
*/
- virtual List* clone();
+ virtual List* clone() override;
- bool toString(std::wostringstream& ostr);
+ bool toString(std::wostringstream& ostr) override;
- bool isList()
+ bool isList() override
{
return true;
}
- List* insert(typed_list* _pArgs, InternalType* _pSource);
- InternalType* extract(typed_list* _pArgs);
+ List* insert(typed_list* _pArgs, InternalType* _pSource) override;
+ InternalType* extract(typed_list* _pArgs) override;
virtual bool invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & /*e*/) override
{
return true;
}
- virtual bool isInvokable() const
+ virtual bool isInvokable() const override
{
return true;
}
- virtual bool hasInvokeOption() const
+ virtual bool hasInvokeOption() const override
{
return false;
}
- virtual int getInvokeNbIn()
+ virtual int getInvokeNbIn() override
{
return -1;
}
- virtual int getInvokeNbOut()
+ virtual int getInvokeNbOut() override
{
return -1;
}
virtual List* set(const int _iIndex, InternalType* _pIT);
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"list";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"l";
}
- virtual bool operator==(const InternalType& it);
+ virtual bool operator==(const InternalType& it) override;
protected :
std::vector<InternalType *>* m_plData;
virtual ~Macro();
// FIXME : Should not return NULL;
- Macro* clone();
+ Macro* clone() override;
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabMacro;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return IdMacro;
}
- bool isMacro()
+ bool isMacro() override
{
return true;
}
- void whoAmI();
+ void whoAmI() override;
- bool toString(std::wostringstream& ostr);
+ bool toString(std::wostringstream& ostr) override;
Callable::ReturnValue call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
ast::SeqExp* getBody();
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"function";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"function";
}
std::list<symbol::Variable*>* getInputs();
std::list<symbol::Variable*>* getOutputs();
- virtual int getNbInputArgument(void);
- virtual int getNbOutputArgument(void);
+ virtual int getNbInputArgument(void) override;
+ virtual int getNbOutputArgument(void) override;
- bool operator==(const InternalType& it);
+ bool operator==(const InternalType& it) override;
void add_submacro(const symbol::Symbol& s, Macro* macro);
virtual ~MacroFile();
//FIXME : Should not return NULL
- MacroFile* clone();
+ MacroFile* clone() override;
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabMacroFile;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return IdMacroFile;
}
- bool isMacroFile()
+ bool isMacroFile() override
{
return true;
}
- void whoAmI();
+ void whoAmI() override;
- bool toString(std::wostringstream& ostr);
+ bool toString(std::wostringstream& ostr) override;
Callable::ReturnValue call(typed_list &in, optional_list &opt, int _iRetCount, typed_list &out) override;
bool parse(void);
Macro* getMacro(void);
- void setLines(int _iFirstLine, int _iLastLine);
+ void setLines(int _iFirstLine, int _iLastLine) override;
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"function";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"function";
}
return m_stPath;
}
- virtual int getNbInputArgument(void);
- virtual int getNbOutputArgument(void);
+ virtual int getNbInputArgument(void) override;
+ virtual int getNbOutputArgument(void) override;
- bool operator==(const InternalType& it);
+ bool operator==(const InternalType& it) override;
private :
std::wstring m_stPath;
MList() : TList() {}
//Destructor uses ~TList()
- virtual MList* clone()
+ virtual MList* clone() override
{
return new MList(this);
}
- void whoAmI(void)
+ void whoAmI(void) override
{
std::cout << "types::MList";
};
- ScilabType getType(void)
+ ScilabType getType(void) override
{
return ScilabMList;
}
- bool isMList()
+ bool isMList() override
{
return true;
}
- bool isTList()
+ bool isTList() override
{
return false;
}
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
virtual bool invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_list & out, const ast::Exp & e) override;
virtual ~Polynom();
// FIXME : Should not return NULL
- Polynom* clone();
+ Polynom* clone() override;
Polynom* setCoef(int _iRows, int _iCols, Double *_pdblCoef);
Polynom* setCoef(int _iIdx, Double *_pdblCoef);
- virtual Polynom* setComplex(bool _bComplex);
+ virtual Polynom* setComplex(bool _bComplex) override;
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabPolynom;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return isScalar() ? isComplex() ? IdScalarPolynomComplex
: IdScalarPolynom
: IdPolynom;
}
- bool isComplex(void);
+ bool isComplex(void) override;
- bool isDollar();
- inline bool isPoly()
+ bool isDollar() override;
+ inline bool isPoly() override
{
return true;
}
- void whoAmI(void);
+ void whoAmI(void) override;
std::wstring& getVariableName();
void setVariableName(const std::wstring&);
bool getSizes(int *_piSizes);
Double* extractCoef(int _iRank);
bool insertCoef(int _iRank, Double* _pCoef);
void setZeros();
- Polynom* insert(typed_list* _pArgs, InternalType* _pSource);
+ Polynom* insert(typed_list* _pArgs, InternalType* _pSource) override;
- Polynom* set(int _iPos, SinglePoly* _pS);
- Polynom* set(int _iRows, int _iCols, SinglePoly* _pS);
- Polynom* set(SinglePoly** _pS);
+ Polynom* set(int _iPos, SinglePoly* _pS) override;
+ Polynom* set(int _iRows, int _iCols, SinglePoly* _pS) override;
+ Polynom* set(SinglePoly** _pS) override;
std::wstring getRowString(int* _piDims, int _iDims, bool _bComplex);
std::wstring getColString(int* _piDims, int _iDims, bool _bComplex);
std::wstring getMatrixString(int* _piDims, int _iDims, bool _bComplex);
- bool operator==(const InternalType& it);
- bool operator!=(const InternalType& it);
+ bool operator==(const InternalType& it) override;
+ bool operator!=(const InternalType& it) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"polynomial";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"p";
}
- bool isTrue()
+ bool isTrue() override
{
return false;
}
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
- bool transpose(InternalType *& out);
- bool adjoint(InternalType *& out);
+ bool transpose(InternalType *& out) override;
+ bool adjoint(InternalType *& out) override;
static Polynom* Dollar();
private :
virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
- virtual SinglePoly* getNullValue();
- virtual Polynom* createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
- virtual SinglePoly* copyValue(SinglePoly* _pData);
- virtual void deleteAll();
- virtual void deleteImg();
- virtual SinglePoly** allocData(int _iSize);
- virtual void deleteData(SinglePoly* data);
+ virtual SinglePoly* getNullValue() override;
+ virtual Polynom* createEmpty(int _iDims, int* _piDims, bool _bComplex = false) override;
+ virtual SinglePoly* copyValue(SinglePoly* _pData) override;
+ virtual void deleteAll() override;
+ virtual void deleteImg() override;
+ virtual SinglePoly** allocData(int _iSize) override;
+ virtual void deleteData(SinglePoly* data) override;
};
}
SinglePoly(double** _pdblCoefR, double** _pdblcoefI, int _iRank);
virtual ~SinglePoly();
- virtual void deleteAll();
- virtual void deleteImg();
+ virtual void deleteAll() override;
+ virtual void deleteImg() override;
// FIXME : Should not return NULL;
- SinglePoly* clone();
+ SinglePoly* clone() override;
SinglePoly* conjugate();
- bool isSinglePoly()
+ bool isSinglePoly() override
{
return true;
}
/*Config management*/
- void whoAmI();
+ void whoAmI() override;
- virtual double getNullValue();
- virtual SinglePoly* createEmpty(int _iDims, int* _piDims, bool _bComplex);
- virtual double* allocData(int _iSize);
- virtual double copyValue(double _dblData);
+ virtual double getNullValue() override;
+ virtual SinglePoly* createEmpty(int _iDims, int* _piDims, bool _bComplex) override;
+ virtual double* allocData(int _iSize) override;
+ virtual double copyValue(double _dblData) override;
virtual bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
bool setZeros();
bool evaluate(double _dblInR, double _dblInI, double *_pdblOutR, double *_pdblOutI);
void updateRank(void);
- void toStringReal(const std::wstring& _szVar, std::list<std::wstring>* _pListExp , std::list<std::wstring>* _pListCoef);
- void toStringImg(const std::wstring& _szVar, std::list<std::wstring>* _pListExp , std::list<std::wstring>* _pListCoef);
+ void toStringReal(const std::wstring& _szVar, std::list<std::wstring>* _pListExp, std::list<std::wstring>* _pListCoef);
+ void toStringImg(const std::wstring& _szVar, std::list<std::wstring>* _pListExp, std::list<std::wstring>* _pListCoef);
- bool toString(std::wostringstream& ostr);
+ bool toString(std::wostringstream& ostr) override;
- bool operator==(const InternalType& it);
- bool operator!=(const InternalType& it);
+ bool operator==(const InternalType& it) override;
+ bool operator!=(const InternalType& it) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"poly";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"p";
}
protected :
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabSinglePolynom;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return IdSinglePolynom;
}
private :
- void toStringInternal(double *_pdblVal, const std::wstring& _szVar, std::list<std::wstring>* _pListExp , std::list<std::wstring>* _pListCoef);
+ void toStringInternal(double *_pdblVal, const std::wstring& _szVar, std::list<std::wstring>* _pListExp, std::list<std::wstring>* _pListCoef);
};
static wchar_t* nullValue();
- void whoAmI();
+ void whoAmI() override;
virtual String* set(int _iPos, const wchar_t* _pwstData);
virtual String* set(int _iRows, int _iCols, const wchar_t* _pwstData);
virtual String* set(int _iRows, int _iCols, const char* _pcData);
virtual String* set(const char* const* _pstrData);
- bool operator==(const InternalType& it);
- bool operator!=(const InternalType& it);
+ bool operator==(const InternalType& it) override;
+ bool operator!=(const InternalType& it) override;
bool subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"string";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"c";
}
- String* clone();
+ String* clone() override;
- inline ScilabType getType()
+ inline ScilabType getType() override
{
return ScilabString;
}
- inline ScilabId getId()
+ inline ScilabId getId() override
{
return isScalar() ? IdScalarString : IdString;
}
- bool isString()
+ bool isString() override
{
return true;
}
- bool isTrue()
+ bool isTrue() override
{
return false;
}
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
- virtual bool neg(InternalType *& /*out*/)
+ virtual bool neg(InternalType *& /*out*/) override
{
return false;
}
- virtual bool transpose(InternalType *& out);
+ virtual bool transpose(InternalType *& out) override;
- virtual ast::Exp* getExp(const Location& loc);
+ virtual ast::Exp* getExp(const Location& loc) override;
private :
void deleteString(int _iRows, int _iCols);
void deleteString(int _iPos);
void createString(int _iDims, int* _piDims);
- virtual wchar_t* copyValue(wchar_t* _pwstData);
+ virtual wchar_t* copyValue(wchar_t* _pwstData) override;
virtual wchar_t* copyValue(const wchar_t* _pwstData);
- virtual String* createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
- virtual wchar_t* getNullValue()
+ virtual String* createEmpty(int _iDims, int* _piDims, bool _bComplex = false) override;
+ virtual wchar_t* getNullValue() override
{
return nullValue();
};
- virtual void deleteAll();
- virtual void deleteImg();
- virtual wchar_t** allocData(int _iSize);
- void deleteData(wchar_t* data);
+ virtual void deleteAll() override;
+ virtual void deleteImg() override;
+ virtual wchar_t** allocData(int _iSize) override;
+ void deleteData(wchar_t* data) override;
};
}
public :
- void whoAmI(void)
+ void whoAmI(void) override
{
std::cout << "types::Struct";
};
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabStruct;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return IdStruct;
}
- bool isStruct()
+ bool isStruct() override
{
return true;
}
bool isEmpty();
- bool transpose(InternalType *& out);
+ bool transpose(InternalType *& out) override;
/**
** Clone
** Create a new List and Copy all values.
*/
- Struct* clone();
+ Struct* clone() override;
- Struct* set(int _iRows, int _iCols, SingleStruct* _pIT);
+ Struct* set(int _iRows, int _iCols, SingleStruct* _pIT) override;
Struct* set(int _iRows, int _iCols, const SingleStruct* _pIT);
- Struct* set(int _iIndex, SingleStruct* _pIT);
+ Struct* set(int _iIndex, SingleStruct* _pIT) override;
Struct* set(int _iIndex, const SingleStruct* _pIT);
- Struct* set(SingleStruct** _pIT);
+ Struct* set(SingleStruct** _pIT) override;
- bool operator==(const InternalType& it);
- bool operator!=(const InternalType& it);
+ bool operator==(const InternalType& it) override;
+ bool operator!=(const InternalType& it) override;
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const
+ virtual std::wstring getTypeStr() const override
{
return L"struct";
}
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const
+ virtual std::wstring getShortTypeStr() const override
{
return L"st";
}
- virtual bool isContainer(void)
+ virtual bool isContainer(void) override
{
return true;
}
- bool isTrue()
+ bool isTrue() override
{
return false;
}
- virtual bool neg(InternalType *& /*out*/)
+ virtual bool neg(InternalType *& /*out*/) override
{
return false;
}
Struct* addField(const std::wstring& _sKey);
Struct* addFieldFront(const std::wstring& _sKey);
Struct* removeField(const std::wstring& _sKey);
- bool toString(std::wostringstream& ostr);
+ bool toString(std::wostringstream& ostr) override;
List* extractFieldWithoutClone(const std::wstring& _wstField);
typed_list extractFields(std::vector<std::wstring> _wstFields);
typed_list extractFields(typed_list* _pArgs);
InternalType * extractField(const std::wstring& wstField);
- Struct* resize(int* _piDims, int _iDims);
- Struct* resize(int _iNewRows, int _iNewCols);
+ Struct* resize(int* _piDims, int _iDims) override;
+ Struct* resize(int _iNewRows, int _iNewCols) override;
/*specials functions to disable clone operation during copydata*/
InternalType* insertWithoutClone(typed_list* _pArgs, InternalType* _pSource);
void setCloneInCopyValue(bool _val);
using ArrayOf<SingleStruct *>::extract;
- bool extract(const std::wstring& name, InternalType *& out);
+ bool extract(const std::wstring& name, InternalType *& out) override;
virtual bool invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_list & out, const ast::Exp & e) override;
- virtual int getInvokeNbOut()
+ virtual int getInvokeNbOut() override
{
return -1;
}
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
private :
- virtual SingleStruct* getNullValue();
- virtual Struct* createEmpty(int _iDims, int* _piDims, bool _bComplex = false);
- virtual Struct* createEmpty();
- virtual SingleStruct* copyValue(SingleStruct* _pData);
- virtual void deleteAll();
- virtual void deleteImg();
- virtual SingleStruct** allocData(int _iSize);
- virtual void deleteData(SingleStruct* data);
+ virtual SingleStruct* getNullValue() override;
+ virtual Struct* createEmpty(int _iDims, int* _piDims, bool _bComplex = false) override;
+ virtual Struct* createEmpty() override;
+ virtual SingleStruct* copyValue(SingleStruct* _pData) override;
+ virtual void deleteAll() override;
+ virtual void deleteImg() override;
+ virtual SingleStruct** allocData(int _iSize) override;
+ virtual void deleteData(SingleStruct* data) override;
bool m_bDisableCloneInCopyValue;
TList(TList *_oTListCopyMe) : List(_oTListCopyMe) {}
public :
- void whoAmI(void)
+ void whoAmI(void) override
{
std::cout << "types::TList";
}
- ScilabType getType(void)
+ ScilabType getType(void) override
{
return ScilabTList;
}
- bool isTList()
+ bool isTList() override
{
return true;
}
- virtual TList* clone();
+ virtual TList* clone() override;
bool exists(const std::wstring& _sKey);
InternalType* getField(const std::wstring& _sKey);
int getIndexFromString(const std::wstring& _sKey);
TList* set(const std::wstring& _sKey, InternalType* _pIT);
- TList* set(const int _iIndex, InternalType* _pIT);
+ TList* set(const int _iIndex, InternalType* _pIT) override;
using List::extract; // to avoid this extract to hide extract in list
- bool extract(const std::wstring& name, InternalType *& out);
+ bool extract(const std::wstring& name, InternalType *& out) override;
virtual bool invoke(typed_list & in, optional_list & opt, int _iRetCount, typed_list & out, const ast::Exp & e) override;
- bool isFieldExtractionOverloadable() const
+ bool isFieldExtractionOverloadable() const override
{
return true;
}
InternalType* extractStrings(const std::list<std::wstring>& _stFields);
/* return type as string ( double, int, cell, list, ... )*/
- virtual std::wstring getTypeStr() const;
+ virtual std::wstring getTypeStr() const override;
/* return type as short string ( s, i, ce, l, ... )*/
- virtual std::wstring getShortTypeStr() const;
+ virtual std::wstring getShortTypeStr() const override;
String* getFieldNames() const;
- bool toString(std::wostringstream& ostr);
+ bool toString(std::wostringstream& ostr) override;
- bool getMemory(long long* _piSize, long long* _piSizePlusType);
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override;
private :
};
/*** non virtual function to prevent overriding in user derived class ***/
- inline ScilabType getType(void)
+ inline ScilabType getType(void) override
{
return ScilabUserType;
}
- inline ScilabId getId(void)
+ inline ScilabId getId(void) override
{
return IdUserType;
}
- bool isUserType(void)
+ bool isUserType(void) override
{
return true;
}
- inline bool isGenericType()
+ inline bool isGenericType() override
{
return false;
}
/*** User will be asked to implement the following methods ***/
/*** in order Scilab engine to manage correctly this user type ***/
- virtual std::wstring getTypeStr() const = 0;
- virtual std::wstring getShortTypeStr() const = 0;
- virtual UserType* clone() = 0;
+ virtual std::wstring getTypeStr() const override = 0;
+ virtual std::wstring getShortTypeStr() const override = 0;
+ virtual UserType* clone() override = 0;
public :
/*** User can overload these methods ***/
// and toString method is useless
// if user overload hasToString for return true, he must overload toString method
// bool toString(std::wostringstream& ostr)
- virtual bool hasToString()
+ virtual bool hasToString() override
{
return false;
}
// overload this method if hasToString method return true
- virtual bool toString(std::wostringstream& /*ostr*/)
+ virtual bool toString(std::wostringstream& /*ostr*/) override
{
return false;
}
// insertion by value
// _pArs is a list of scilab types:: of where we want to extract
// _pSource is what we wan to insert
- virtual UserType* insert(typed_list* /*_pArgs*/, InternalType* /*_pSource*/)
+ virtual UserType* insert(typed_list* /*_pArgs*/, InternalType* /*_pSource*/) override
{
return NULL;
}
// this method is called to perform an extraction by field. ie : a = myUserType.myfield
// name is the field name
// out contain extraction of field
- virtual bool extract(const std::wstring& /*name*/, InternalType *& /*out*/)
+ virtual bool extract(const std::wstring& /*name*/, InternalType *& /*out*/) override
{
return false;
}
// _pArs is a list of scilab types:: of where we want to extract
// return all element extracted, in case when multiple elements returned
// these elements must be stored in a types::List
- virtual InternalType* extract(typed_list* /*_pArgs*/)
+ virtual InternalType* extract(typed_list* /*_pArgs*/) override
{
return NULL;
}
// if return false , Scilab will never call "invoke" method
- virtual bool isInvokable() const
+ virtual bool isInvokable() const override
{
return true;
}
// ie : myUserType(a,b, opt=value, opt2=value2,...)
// in this case, "types::optional_list& opt" will contain opt and opt2.
// by default this method return false, the optional list is empty and the input list contains all arguments.
- virtual bool hasInvokeOption() const
+ virtual bool hasInvokeOption() const override
{
return false;
}
// used to compute the iterator in scilab loop "for"
// when type is a two dimensions array
// _iPos is the column position
- virtual GenericType* getColumnValues(int /*_iPos*/)
+ virtual GenericType* getColumnValues(int /*_iPos*/) override
{
return NULL;
}
//load must be done by overload %yourtype_load and must returns a pointer on your UserType
- bool getMemory(long long* _piSize, long long* _piSizePlusType)
+ bool getMemory(long long* _piSize, long long* _piSizePlusType) override
{
*_piSize = sizeof(UserType);
*_piSizePlusType = *_piSize;
void handleExpStart(const ast::Exp * e) override;
void handleExpEnd(const ast::Exp * e) override;
- inline std::size_t getIndentSize() const
+ inline std::size_t getIndentSize() const override
{
return indentLevel * 4;
}
- inline void incIndent()
+ inline void incIndent() override
{
++indentLevel;
}
- inline void decIndent()
+ inline void decIndent() override
{
--indentLevel;
}
- inline unsigned int getLineCharCount() const
+ inline unsigned int getLineCharCount() const override
{
return counter;
}
}
virtual ~EOType() {}
- inline std::wstring getTypeStr() const
+ inline std::wstring getTypeStr() const override
{
return L"eotype";
}
- inline std::wstring getShortTypeStr() const
+ inline std::wstring getShortTypeStr() const override
{
return L"eo";
}
- EOType* clone()
+ EOType* clone() override
{
return new EOType(id, isNew);
}
- inline bool hasToString()
+ inline bool hasToString() override
{
return true;
}
- inline bool toString(std::wostringstream& ostr)
+ inline bool toString(std::wostringstream& ostr) override
{
ostr << "eotype" << std::endl;
return true;
}
- inline bool isInvokable() const
+ inline bool isInvokable() const override
{
return true;
}
- inline bool isAssignable()
+ inline bool isAssignable() override
{
return false;
}
- inline bool isCallable()
+ inline bool isCallable() override
{
return true;
}
return new SciMpiComm(m_piWorldIndex, m_iGroupSize);
}
- std::wstring getTypeStr() const
+ std::wstring getTypeStr() const override
{
return L"SciMpiComm";
}
- std::wstring getShortTypeStr() const
+ std::wstring getShortTypeStr() const override
{
return L"smc";
}
* All following methods should be implemented by each template instance
*/
- virtual std::wstring getTypeStr() const = 0;
- virtual std::wstring getShortTypeStr() const = 0;
+ virtual std::wstring getTypeStr() const override = 0;
+ virtual std::wstring getShortTypeStr() const override = 0;
private:
virtual UserType* clone() override final
return L"Block";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
types::InternalType* getDocContent() const;
void setDocContent(types::InternalType* v);
return L"cpr";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
};
} /* namespace view_scilab */
return L"diagram";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
types::InternalType* getContribContent() const;
void setContribContent(types::InternalType* v);
return L"graphics";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
types::InternalType* getGrIContent() const;
void setGrIContent(types::InternalType* v);
return L"Link";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
// move (if possible) the partial informations to the model
static void relink(Controller& controller, model::Link* adaptee, const std::vector<ScicosID>& children);
return L"model";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
};
} /* namespace view_scilab */
return L"params";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
types::InternalType* getDocContent() const;
void setDocContent(types::InternalType* v);
return L"scs";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
};
} /* namespace view_scilab */
return L"xcs";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
};
} /* namespace view_scilab */
return L"Text";
}
- std::wstring getTypeStr() const;
- std::wstring getShortTypeStr() const;
+ std::wstring getTypeStr() const override;
+ std::wstring getShortTypeStr() const override;
};
} /* namespace view_scilab */
projects / scilab.git / commitdiff