Merge remote-tracking branch 'origin/master' into windows
[scilab.git] / scilab / modules / ast / includes / analysis / data / TITypeTuple.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2014 - Scilab Enterprises - Calixte DENIZET
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 __TITYPE_TUPLE_HXX__
17 #define __TITYPE_TUPLE_HXX__
18
19 #include <vector>
20
21 #include "tools.hxx"
22 #include "TIType.hxx"
23
24 namespace analysis
25 {
26 struct TITypeTuple
27 {
28     std::vector<TIType> types;
29
30     TITypeTuple() { }
31
32     TITypeTuple(const std::vector<TIType> & _types) : types(_types)
33     {
34         /*types.reserve(_types.size());
35           for (const auto & type : _types)
36           {
37           types.emplace_back(type.type, type.isscalar());
38           }*/
39     }
40
41     inline std::size_t size() const
42     {
43         return types.size();
44     }
45
46     inline std::size_t hash() const
47     {
48         if (types.empty())
49         {
50             return 0;
51         }
52         else
53         {
54             std::size_t seed = types.front().hashPureType();
55             for (std::vector<TIType>::const_iterator i = ++types.begin(), e = types.end(); i != e; ++i)
56             {
57                 seed = tools::hash_combine(seed, i->hashPureType());
58             }
59             return seed;
60         }
61     }
62
63     inline bool operator==(const TITypeTuple & R) const
64     {
65         if (types.size() == R.types.size())
66         {
67             for (std::vector<TIType>::const_iterator i = types.begin(), j = R.types.begin(), e = types.end(); i != e; ++i, ++j)
68             {
69                 if (i->type != j->type || i->isscalar() != j->isscalar())
70                 {
71                     return false;
72                 }
73             }
74             return true;
75         }
76
77         return false;
78     }
79
80     friend std::ostream & operator<<(std::ostream & out, const TITypeTuple & tuple)
81     {
82         if (tuple.types.empty())
83         {
84             out << "[]";
85         }
86         else
87         {
88             out << "[";
89             for (std::vector<TIType>::const_iterator i = tuple.types.begin(), e = std::prev(tuple.types.end()); i != e; ++i)
90             {
91                 out << *i << ", ";
92             }
93             out << tuple.types.back() << "]";
94         }
95         return out;
96     }
97
98     struct Hash
99     {
100         inline std::size_t operator()(const TITypeTuple & tuple) const
101         {
102             return tuple.hash();
103         }
104     };
105
106     struct Eq
107     {
108         inline bool operator()(const TITypeTuple & L, const TITypeTuple & R) const
109         {
110             return L == R;
111         }
112     };
113 };
114
115 } // namespace analysis
116
117 #endif // __TITYPE_TUPLE_HXX__