scilab/modules/ast/includes/types/list.hxx

   1 /*
   2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  *  Copyright (C) 2010-2010 - DIGITEO - Bruno JOFRET
   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  *
  14  */
  15
  16 #ifndef __LIST_HH__
  17 #define __LIST_HH__
  18
  19 #include <list>
  20 #include "container.hxx"
  21
  22 namespace types
  23 {
  24 class EXTERN_AST List : public Container
  25 {
  26 public :
  27     List();
  28     virtual ~List();
  29
  30 protected :
  31     std::vector<InternalType *>*    getData();
  32     List(List *_oListCopyMe);
  33 public :
  34     int                             getSize() const override;
  35
  36     void                            whoAmI(void) override
  37     {
  38         std::cout << "types::List";
  39     };
  40
  41     inline ScilabType               getType(void) override
  42     {
  43         return ScilabList;
  44     }
  45     inline ScilabId                 getId(void) override
  46     {
  47         return IdList;
  48     }
  49
  50     bool                            getMemory(long long* _piSize, long long* _piSizePlusType) override;
  51
  52     /**
  53     ** append(InternalType *_typedValue)
  54     ** Append the given value to the end of the List
  55     */
  56     List*                           append(InternalType *_typedValue);
  57
  58     /**
  59     ** Clone
  60     ** Create a new List and Copy all values.
  61     */
  62     virtual List*                   clone() override;
  63
  64     bool                            toString(std::wostringstream& ostr) override;
  65
  66     bool                            isList() override
  67     {
  68         return true;
  69     }
  70
  71     List*                           insert(typed_list* _pArgs, InternalType* _pSource) override;
  72     InternalType*                   extract(typed_list* _pArgs) override;
  73
  74     virtual bool invoke(typed_list & in, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & out, const ast::Exp & /*e*/) override
  75     {
  76         if (in.size() == 0)
  77         {
  78             out.push_back(this);
  79         }
  80         else
  81         {
  82             InternalType * _out = extract(&in);
  83             if (_out == NULL)
  84             {
  85                 // invalid index
  86                 return false;
  87             }
  88
  89             List* pList = _out->getAs<types::List>();
  90             for (int i = 0; i < pList->getSize(); i++)
  91             {
  92                 out.push_back(pList->get(i));
  93             }
  94             pList->killMe();
  95         }
  96
  97         return true;
  98     }
  99
 100     virtual bool isInvokable() const override
 101     {
 102         return true;
 103     }
 104
 105     virtual bool hasInvokeOption() const override
 106     {
 107         return false;
 108     }
 109
 110     virtual int getInvokeNbIn() override
 111     {
 112         return -1;
 113     }
 114
 115     virtual int getInvokeNbOut() override
 116     {
 117         return -1;
 118     }
 119
 120     virtual InternalType*           get(const int _iIndex);
 121     virtual List*                   set(const int _iIndex, InternalType* _pIT);
 122
 123     /* return type as string ( double, int, cell, list, ... )*/
 124     virtual std::wstring            getTypeStr() const override
 125     {
 126         return L"list";
 127     }
 128     /* return type as short string ( s, i, ce, l, ... )*/
 129     virtual std::wstring            getShortTypeStr() const override
 130     {
 131         return L"l";
 132     }
 133
 134     virtual bool                    operator==(const InternalType& it) override;
 135
 136 protected :
 137     std::vector<InternalType *>*    m_plData;
 138 };
 139 }
 140
 141 #endif /* __LIST_HH__ */