[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[lmi-commits] [lmi] master fec4cd8 1/3: Restore but rename PETE's operat
|
From: |
Greg Chicares |
|
Subject: |
[lmi-commits] [lmi] master fec4cd8 1/3: Restore but rename PETE's operator==() and !=() for std::vector |
|
Date: |
Wed, 24 Mar 2021 10:37:25 -0400 (EDT) |
branch: master
commit fec4cd8097979b4d7e99721e4f2bfdea52ac81d8
Author: Gregory W. Chicares <gchicares@sbcglobal.net>
Commit: Gregory W. Chicares <gchicares@sbcglobal.net>
Restore but rename PETE's operator==() and !=() for std::vector
Reworked commit 2844ba037f4114 of 20210216T1619Z. Instead of removing
all of PETE's equality and inequality operators:
operator==(vector, vector) (1)
operator==(vector, T) (2a)
operator==(T, vector) (2b)
operator==(vector, expression) (3a)
operator==(expression, vector) (3b)
simply renamed them. Element-wise [in]equality comparisons are useful,
though probably not so often that they must be operators as such.
Chose names "EqualTo" and "UnequalTo" for unambiguity, not terseness.
They're still referred to as "operators" in the PETE code, e.g.:
m["binaryBoolOps"].push_back(
OperatorDescriptor("OpEQ",
but those are just arbitrary text strings.
It might have been nicer to keep them as operators, suppressing them
only to the extent they ambiguate the important standard operators like
template<typename T, typename Alloc>
constexpr bool operator==
(std::vector<T,Alloc> const& lhs
,std::vector<T,Alloc> const& rhs
);
but that turned out not to be worth the trouble:
(A) Mangling (1) above only, thus:
sed -i $@ -e's/operator==\(.*std::vector.*std::vector\)/XyZzY_EQ\1/'
sed -i $@ -e's/operator!=\(.*std::vector.*std::vector\)/XyZzY_NE\1/'
was insufficient because (2a) and (2b) still ambiguated the standard
operator. The 'sed' technique was tried because changing PETE to prevent
the operators from being generated is too daunting: PETE has several
layers of abstraction, and by the time the to-be-suppressed code is
generated, the identity of individual operators has been erased, so a
deep restructuring would be required.
(B) SFINAE might be used, e.g.:
template<typename>
struct is_std_vector : std::false_type {};
template<typename T, typename A>
struct is_std_vector<std::vector<T,A>> : std::true_type {};
template<typename T0, typename T1, typename=is_std_vector<T1>::value>
bool operator==(std::vector<T0> t0, T1 t1) {return t0 == t1;}
but intruding an extra template parameter into PETE seemed similarly
daunting for similar reasons.
(C) Later, of course, outside of PETE's code generation, SFINAE-based
operators could be implemented in terms of "EqualTo" and "UnequalTo",
if desired.
* tools/pete-2.1.1/PETE/Tools/PeteOps.in: Edited.
* tools/pete-2.1.1/PETE/OperatorTags.h: Regenerated.
* tools/pete-2.1.1/PETE/Tools/PeteOps.cpp: Regenerated.
* tools/pete-2.1.1/et_vector_operators.hpp: Regenerated.
---
tools/pete-2.1.1/PETE/OperatorTags.h | 32 +++++
tools/pete-2.1.1/PETE/Tools/PeteOps.cpp | 10 ++
tools/pete-2.1.1/PETE/Tools/PeteOps.in | 8 ++
tools/pete-2.1.1/et_vector_operators.hpp | 224 +++++++++++++++++++++++++++++++
4 files changed, 274 insertions(+)
diff --git a/tools/pete-2.1.1/PETE/OperatorTags.h
b/tools/pete-2.1.1/PETE/OperatorTags.h
index a913b9d..5e6a1cb 100644
--- a/tools/pete-2.1.1/PETE/OperatorTags.h
+++ b/tools/pete-2.1.1/PETE/OperatorTags.h
@@ -521,6 +521,38 @@ struct BinaryReturn<T1, T2, OpGE > {
typedef bool Type_t;
};
+struct OpEQ
+{
+ PETE_EMPTY_CONSTRUCTORS(OpEQ)
+ template<class T1, class T2>
+ inline typename BinaryReturn<T1, T2, OpEQ >::Type_t
+ operator()(const T1 &a, const T2 &b) const
+ {
+ return (a == b);
+ }
+};
+
+template<class T1, class T2 >
+struct BinaryReturn<T1, T2, OpEQ > {
+ typedef bool Type_t;
+};
+
+struct OpNE
+{
+ PETE_EMPTY_CONSTRUCTORS(OpNE)
+ template<class T1, class T2>
+ inline typename BinaryReturn<T1, T2, OpNE >::Type_t
+ operator()(const T1 &a, const T2 &b) const
+ {
+ return (a != b);
+ }
+};
+
+template<class T1, class T2 >
+struct BinaryReturn<T1, T2, OpNE > {
+ typedef bool Type_t;
+};
+
struct OpAnd
{
PETE_EMPTY_CONSTRUCTORS(OpAnd)
diff --git a/tools/pete-2.1.1/PETE/Tools/PeteOps.cpp
b/tools/pete-2.1.1/PETE/Tools/PeteOps.cpp
index 7864101..cec4551 100644
--- a/tools/pete-2.1.1/PETE/Tools/PeteOps.cpp
+++ b/tools/pete-2.1.1/PETE/Tools/PeteOps.cpp
@@ -109,6 +109,16 @@ void peteOps(map<string,vector<OperatorDescriptor> > &m)
"return (a >= b);",
""));
m["binaryBoolOps"].push_back(
+ OperatorDescriptor("OpEQ",
+ "EqualTo",
+ "return (a == b);",
+ ""));
+ m["binaryBoolOps"].push_back(
+ OperatorDescriptor("OpNE",
+ "UnequalTo",
+ "return (a != b);",
+ ""));
+ m["binaryBoolOps"].push_back(
OperatorDescriptor("OpAnd",
"operator&&",
"return (a && b);",
diff --git a/tools/pete-2.1.1/PETE/Tools/PeteOps.in
b/tools/pete-2.1.1/PETE/Tools/PeteOps.in
index 3846d01..6784885 100644
--- a/tools/pete-2.1.1/PETE/Tools/PeteOps.in
+++ b/tools/pete-2.1.1/PETE/Tools/PeteOps.in
@@ -174,6 +174,14 @@ binaryBoolOps
FUNCTION = "operator>="
EXPR = "return (a >= b);"
-----
+ TAG = "OpEQ"
+ FUNCTION = "EqualTo"
+ EXPR = "return (a == b);"
+-----
+ TAG = "OpNE"
+ FUNCTION = "UnequalTo"
+ EXPR = "return (a != b);"
+-----
TAG = "OpAnd"
FUNCTION = "operator&&"
EXPR = "return (a && b);"
diff --git a/tools/pete-2.1.1/et_vector_operators.hpp
b/tools/pete-2.1.1/et_vector_operators.hpp
index d7aa9bc..1dc668f 100644
--- a/tools/pete-2.1.1/et_vector_operators.hpp
+++ b/tools/pete-2.1.1/et_vector_operators.hpp
@@ -520,6 +520,34 @@ operator>=(const std::vector<T1> & l,const std::vector<T2>
& r)
}
template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpEQ,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
+EqualTo(const std::vector<T1> & l,const std::vector<T2> & r)
+{
+ typedef BinaryNode<OpEQ,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<std::vector<T1> >::make(l),
+ CreateLeaf<std::vector<T2> >::make(r)));
+}
+
+template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpNE,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
+UnequalTo(const std::vector<T1> & l,const std::vector<T2> & r)
+{
+ typedef BinaryNode<OpNE,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<std::vector<T1> >::make(l),
+ CreateLeaf<std::vector<T2> >::make(r)));
+}
+
+template<class T1,class T2>
inline typename MakeReturn<BinaryNode<OpAnd,
typename CreateLeaf<std::vector<T1> >::Leaf_t,
typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
@@ -842,6 +870,34 @@ operator>=(const std::vector<T1> & l,const Expression<T2>
& r)
}
template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpEQ,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t
+EqualTo(const std::vector<T1> & l,const Expression<T2> & r)
+{
+ typedef BinaryNode<OpEQ,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<std::vector<T1> >::make(l),
+ CreateLeaf<Expression<T2> >::make(r)));
+}
+
+template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpNE,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t
+UnequalTo(const std::vector<T1> & l,const Expression<T2> & r)
+{
+ typedef BinaryNode<OpNE,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<std::vector<T1> >::make(l),
+ CreateLeaf<Expression<T2> >::make(r)));
+}
+
+template<class T1,class T2>
inline typename MakeReturn<BinaryNode<OpAnd,
typename CreateLeaf<std::vector<T1> >::Leaf_t,
typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t
@@ -1164,6 +1220,34 @@ operator>=(const Expression<T1> & l,const
std::vector<T2> & r)
}
template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpEQ,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
+EqualTo(const Expression<T1> & l,const std::vector<T2> & r)
+{
+ typedef BinaryNode<OpEQ,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<Expression<T1> >::make(l),
+ CreateLeaf<std::vector<T2> >::make(r)));
+}
+
+template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpNE,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
+UnequalTo(const Expression<T1> & l,const std::vector<T2> & r)
+{
+ typedef BinaryNode<OpNE,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<Expression<T1> >::make(l),
+ CreateLeaf<std::vector<T2> >::make(r)));
+}
+
+template<class T1,class T2>
inline typename MakeReturn<BinaryNode<OpAnd,
typename CreateLeaf<Expression<T1> >::Leaf_t,
typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
@@ -1486,6 +1570,34 @@ operator>=(const std::vector<T1> & l,const T2 & r)
}
template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpEQ,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<T2 >::Leaf_t> >::Expression_t
+EqualTo(const std::vector<T1> & l,const T2 & r)
+{
+ typedef BinaryNode<OpEQ,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<T2 >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<std::vector<T1> >::make(l),
+ CreateLeaf<T2 >::make(r)));
+}
+
+template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpNE,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<T2 >::Leaf_t> >::Expression_t
+UnequalTo(const std::vector<T1> & l,const T2 & r)
+{
+ typedef BinaryNode<OpNE,
+ typename CreateLeaf<std::vector<T1> >::Leaf_t,
+ typename CreateLeaf<T2 >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<std::vector<T1> >::make(l),
+ CreateLeaf<T2 >::make(r)));
+}
+
+template<class T1,class T2>
inline typename MakeReturn<BinaryNode<OpAnd,
typename CreateLeaf<std::vector<T1> >::Leaf_t,
typename CreateLeaf<T2 >::Leaf_t> >::Expression_t
@@ -1808,6 +1920,34 @@ operator>=(const T1 & l,const std::vector<T2> & r)
}
template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpEQ,
+ typename CreateLeaf<T1 >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
+EqualTo(const T1 & l,const std::vector<T2> & r)
+{
+ typedef BinaryNode<OpEQ,
+ typename CreateLeaf<T1 >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<T1 >::make(l),
+ CreateLeaf<std::vector<T2> >::make(r)));
+}
+
+template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpNE,
+ typename CreateLeaf<T1 >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
+UnequalTo(const T1 & l,const std::vector<T2> & r)
+{
+ typedef BinaryNode<OpNE,
+ typename CreateLeaf<T1 >::Leaf_t,
+ typename CreateLeaf<std::vector<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<T1 >::make(l),
+ CreateLeaf<std::vector<T2> >::make(r)));
+}
+
+template<class T1,class T2>
inline typename MakeReturn<BinaryNode<OpAnd,
typename CreateLeaf<T1 >::Leaf_t,
typename CreateLeaf<std::vector<T2> >::Leaf_t> >::Expression_t
@@ -2404,6 +2544,34 @@ operator>=(const Expression<T1> & l,const Expression<T2>
& r)
}
template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpEQ,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t
+EqualTo(const Expression<T1> & l,const Expression<T2> & r)
+{
+ typedef BinaryNode<OpEQ,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<Expression<T1> >::make(l),
+ CreateLeaf<Expression<T2> >::make(r)));
+}
+
+template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpNE,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t
+UnequalTo(const Expression<T1> & l,const Expression<T2> & r)
+{
+ typedef BinaryNode<OpNE,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<Expression<T1> >::make(l),
+ CreateLeaf<Expression<T2> >::make(r)));
+}
+
+template<class T1,class T2>
inline typename MakeReturn<BinaryNode<OpAnd,
typename CreateLeaf<Expression<T1> >::Leaf_t,
typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t
@@ -2726,6 +2894,34 @@ operator>=(const Expression<T1> & l,const T2 & r)
}
template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpEQ,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<T2 >::Leaf_t> >::Expression_t
+EqualTo(const Expression<T1> & l,const T2 & r)
+{
+ typedef BinaryNode<OpEQ,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<T2 >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<Expression<T1> >::make(l),
+ CreateLeaf<T2 >::make(r)));
+}
+
+template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpNE,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<T2 >::Leaf_t> >::Expression_t
+UnequalTo(const Expression<T1> & l,const T2 & r)
+{
+ typedef BinaryNode<OpNE,
+ typename CreateLeaf<Expression<T1> >::Leaf_t,
+ typename CreateLeaf<T2 >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<Expression<T1> >::make(l),
+ CreateLeaf<T2 >::make(r)));
+}
+
+template<class T1,class T2>
inline typename MakeReturn<BinaryNode<OpAnd,
typename CreateLeaf<Expression<T1> >::Leaf_t,
typename CreateLeaf<T2 >::Leaf_t> >::Expression_t
@@ -3048,6 +3244,34 @@ operator>=(const T1 & l,const Expression<T2> & r)
}
template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpEQ,
+ typename CreateLeaf<T1 >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t
+EqualTo(const T1 & l,const Expression<T2> & r)
+{
+ typedef BinaryNode<OpEQ,
+ typename CreateLeaf<T1 >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<T1 >::make(l),
+ CreateLeaf<Expression<T2> >::make(r)));
+}
+
+template<class T1,class T2>
+inline typename MakeReturn<BinaryNode<OpNE,
+ typename CreateLeaf<T1 >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t
+UnequalTo(const T1 & l,const Expression<T2> & r)
+{
+ typedef BinaryNode<OpNE,
+ typename CreateLeaf<T1 >::Leaf_t,
+ typename CreateLeaf<Expression<T2> >::Leaf_t> Tree_t;
+ return MakeReturn<Tree_t>::make(Tree_t(
+ CreateLeaf<T1 >::make(l),
+ CreateLeaf<Expression<T2> >::make(r)));
+}
+
+template<class T1,class T2>
inline typename MakeReturn<BinaryNode<OpAnd,
typename CreateLeaf<T1 >::Leaf_t,
typename CreateLeaf<Expression<T2> >::Leaf_t> >::Expression_t