boostorg/typeof
1
0
Fork 1
mirror of https://github.com/boostorg/typeof.git synced 2025-07-31 13:27:30 +02:00
Code Issues Packages Projects Releases Wiki Activity

Added vintage test case

Browse Source 
[SVN r2358]
This commit is contained in:
Peder Holt
2004-11-12 23:13:52 +00:00
parent 6f0177d472
commit 8c056fdba7
7 changed files with 516 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

324
test/vintage/main.cpp Normal file
View File

@ -0,0 +1,324 @@
// Copyright (C) 2004 Arkadiy Vertleyb
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#pragma message("including typeof.hpp...")
#include <boost/typeof/typeof.hpp>
#pragma message("done")
#include <boost/noncopyable.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/static_assert.hpp>
#pragma message("registering")
#include "stl/register.hpp"
#include "mpl/register.hpp"
//#include "spirit/register.hpp"
//#include "lambda/register.hpp"
#pragma message("done")
#include <cassert>
#include <iostream>
#include <vector>
//#include <boost/lambda/lambda.hpp>
//#include <boost/spirit.hpp>
#include <boost/mpl/vector.hpp>
#include "typeid.hpp"
using namespace std;
#pragma message("started")
double f_0()
{
cout << "functions with no params" << endl;
return 0;
}
double f_9(int, double, short, char*, bool, char, float, long, unsigned short)
{
cout << "functions with 9 params" << endl;
return 0;
}
void vf_0()
{
cout << "void functions with 0 params" << endl;
}
void vf_9(int, double, short, char*, bool, char, float, long, unsigned short)
{
cout << "void functions with 9 params" << endl;
}
struct x
{
int f_0() volatile
{
cout << "member functions with no params" << endl;
return 0;
}
int f_9(int, double, char, int, double, char, int, double, char)
{
cout << "member functions with 9 params" << endl;
return 0;
}
void vf_0()
{
cout << "void member functions with no params" << endl;
}
void vf_9(int, double, char, int, double, char, int, double, char)
{
cout << "void member functions with 9 params" << endl;
}
int cf_0() const volatile
{
cout << "const member functions with no params" << endl;
return 0;
}
int cf_9(int, double, char, int, double, char, int, double, char) const
{
cout << "const member functions with 9 params" << endl;
return 0;
}
void cvf_0() const
{
cout << "const void member functions with no params" << endl;
}
void cvf_9(int, double, char, int, double, char, int, double, char) const
{
cout << "const void member functions with 9 params" << endl;
}
static void sf_0()
{
cout << "static member function" << endl;
}
std::vector<int> m_v;
};
struct noncop : boost::noncopyable
{};
const noncop& foo_nc()
{
static noncop nc;
return nc;
}
template<class T, char c, unsigned short us,
int i, unsigned long ul, bool b1, bool b2, unsigned u> struct with_integrals
{};
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
BOOST_TYPEOF_REGISTER_TYPE(x)
BOOST_TYPEOF_REGISTER_TEMPLATE_X(with_integrals,
(class)
(char)
(unsigned short)
(int)
(unsigned long)
(bool)
(bool)
(unsigned)
);
BOOST_TYPEOF_REGISTER_TYPE(noncop)
main()
{
#pragma message("integral...")
{
with_integrals<int, 5, 4, 3, 2, true, false, 5> expr;
BOOST_AUTO(v, expr);
v;
with_integrals<int, 1, 1, 0, ULONG_MAX, false, true, 0> expr1;
BOOST_AUTO(v1, expr1);
v1;
}
#pragma message("Noncopyable...")
{
//BOOST_AUTO(v, foo_nc());
BOOST_AUTO(const& v, foo_nc());
}
#pragma message("Lvalue preserving...")
{
int n;
const int cn = 0;
int& rn = n;
const int& rcn = cn;
int f();
//const int cf();
int& rf();
const int& rcf();
cout << type_id<BOOST_LVALUE_TYPEOF(n)>::name() << endl;
cout << type_id<BOOST_LVALUE_TYPEOF(cn)>::name() << endl;
cout << type_id<BOOST_LVALUE_TYPEOF(rn)>::name() << endl;
cout << type_id<BOOST_LVALUE_TYPEOF(rcn)>::name() << endl;
cout << type_id<BOOST_LVALUE_TYPEOF(f())>::name() << endl;
//cout << type_id<BOOST_LVALUE_TYPEOF(cf())>::name() << endl;
cout << type_id<BOOST_LVALUE_TYPEOF(rf())>::name() << endl;
cout << type_id<BOOST_LVALUE_TYPEOF(rcf())>::name() << endl;
cout << type_id<BOOST_LVALUE_TYPEOF(21)>::name() << endl;
cout << type_id<BOOST_LVALUE_TYPEOF(int(21))>::name() << endl;
BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(n), int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(cn), const int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(rn), int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(rcn), const int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(f()), int>::value));
//BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(cf()), const int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(rf()), int&>::value));
BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(rcf()), const int&>::value));
// BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(21), int>::value));
BOOST_STATIC_ASSERT((boost::is_same<BOOST_LVALUE_TYPEOF(int(21)), int>::value));
}
/*#pragma message("compiling Lambda example...")
{
using namespace boost::lambda;
BOOST_AUTO(fun, _1 > 15 && _2 < 20);
int n = 19;
assert(fun(n, n));
std::cout << typeid(fun).name() << std::endl;
}
#pragma message("compiling Spirit example...")
{
// spirit example
using namespace boost::spirit;
using namespace boost::lambda;
using namespace std;
vector<double> v;
BOOST_AUTO(parser,
(real_p[push_back_a(v)] >> *(',' >> real_p[push_back_a(v)]))
);
parse("3.14159, 2.71828", parser, space_p);
for_each(v.begin(), v.end(), cout << _1 << ' ');
cout << endl;
}
#pragma message("compiling another Spirit example...")
{
// more spirit...
using namespace boost::spirit;
BOOST_AUTO(
skipper,
( space_p
| "//" >> *(anychar_p - '\n') >> '\n'
| "/*" >> *(anychar_p - "* /") >> "* /"
)
);
bool success = parse(
"/*this is a comment* /\n//this is a c++ comment\n\n",
*skipper).full;
assert(success);
}*/
#pragma message("compiling Modifiers example...")
{
//modifiers
using namespace std;
using namespace boost;
// top-level pointers are preserved...
mpl::vector3<const int* const, const int[20], const int&>* foo();
cout << typeid(BOOST_TYPEOF(foo())).name() << endl;
// ... but top-level refs are not :(
mpl::vector2<const int* const, const int&>& bar();
cout << typeid(BOOST_TYPEOF(bar())).name() << endl;
mpl::vector1<int[5]> vi;
cout << "int[5]" << endl;
cout << typeid(BOOST_TYPEOF(vi)).name() << endl;
mpl::vector1<const int[5]> vci;
cout << "const int[5]" << endl;
cout << typeid(BOOST_TYPEOF(vci)).name() << endl;
}
#pragma message("compiling functions example...")
{
BOOST_AUTO(p0, &f_0);
(*p0)();
BOOST_AUTO(p9, &f_9);
(*p9)(0, 0, 0, 0, 0, 0, 0, 0, 0);
}
#pragma message("compiling void functions example...")
{
BOOST_AUTO(p0, &vf_0);
(*p0)();
BOOST_AUTO(p9, &vf_9);
(*p9)(0, 0, 0, 0, 0, 0, 0, 0, 0);
}
#pragma message("compiling member functions example...")
{
x xx;
BOOST_AUTO(p0, &x::f_0);
(xx.*p0)();
BOOST_AUTO(p9, &x::f_9);
(xx.*p9)(0, 0, 0, 0, 0, 0, 0, 0, 0);
}
#pragma message("compiling void member functions example...")
{
x xx;
BOOST_AUTO(p0, &x::vf_0);
(xx.*p0)();
BOOST_AUTO(p9, &x::vf_9);
(xx.*p9)(0, 0, 0, 0, 0, 0, 0, 0, 0);
}
#pragma message("compiling const member functions example...")
{
x xx;
BOOST_AUTO(p0, &x::cf_0);
(xx.*p0)();
BOOST_AUTO(p9, &x::cf_9);
(xx.*p9)(0, 0, 0, 0, 0, 0, 0, 0, 0);
}
#pragma message("compiling const void member functions example...")
{
x xx;
BOOST_AUTO(p0, &x::cvf_0);
(xx.*p0)();
BOOST_AUTO(p9, &x::cvf_9);
(xx.*p9)(0, 0, 0, 0, 0, 0, 0, 0, 0);
}
#pragma message("compiling static member functions example...")
{
BOOST_AUTO(p0, &x::sf_0);
(*p0)();
}
#pragma message("pointers to data members...")
{
BOOST_AUTO(p, &x::m_v);
x xx;
(xx.*p).push_back(1);
}
#pragma message("ODR")
void odr_test1();
void odr_test2();
odr_test1();
odr_test2();
#pragma message("done!")
}

19
test/vintage/mpl/register.hpp Normal file
View File

@ -0,0 +1,19 @@
// Copyright (C) 2004 Arkadiy Vertleyb
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef MPL_REGISTER_HPP_INCLUDED
#define MPL_REGISTER_HPP_INCLUDED
#include <boost/typeof/typeof.hpp>
#include <boost/mpl/vector.hpp>
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
BOOST_TYPEOF_REGISTER_TYPE(boost::mpl::vector0<>);
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::mpl::vector1, 1);
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::mpl::vector2, 2);
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::mpl::vector3, 3);
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::mpl::vector4, 4);
#endif//MPL_REGISTER_HPP_INCLUDED

54
test/vintage/odr.hpp Normal file
View File

@ -0,0 +1,54 @@
// Copyright (C) 2004 Arkadiy Vertleyb
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef ODR_HPP_INCLUDED
#define ODR_HPP_INCLUDED
#include <boost/typeof/typeof.hpp>
void odr_test1();
void odr_test2();
// trying to cause ODR violation in a class template
template<class T, class U>
class sum_t
{
public:
typedef BOOST_TYPEOF_TPL(T() + U()) result_type;
sum_t(const T& t, const U& u);
BOOST_TYPEOF_TPL(T() + U()) operator()();
private:
BOOST_TYPEOF_TPL(T() + U()) m_sum;
};
template<class T, class U>
sum_t<T,U>::sum_t(const T& t, const U& u)
: m_sum(t + u)
{}
template<class T, class U>
sum_t<T,U>::result_type sum_t<T,U>::operator()()
{
// BOOST_AUTO_TPL(result, m_sum);
return m_sum;
}
template<class T, class U>
sum_t<T, U> make_sum(const T& t, const U& u)
{
return sum_t<T, U>(t, u);
}
// trying to cause ODR violation in a function template
template<class T, class U>
typename sum_t<T, U>::result_type sum(const T& t, const U& u)
{
BOOST_AUTO_TPL(result, t + u);
return result;
}
#endif//ODR_HPP_INCLUDED

18
test/vintage/odr1.cpp Normal file
View File

@ -0,0 +1,18 @@
// Copyright (C) 2004 Arkadiy Vertleyb
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include "odr.hpp"
using namespace std;
void odr_test1()
{
char i = 5;
double d = 3.14;
cout << sum(d, i) << endl;
cout << sum(i, d) << endl;
cout << make_sum(d, i)() << endl;
cout << make_sum(i, d)() << endl;
}

18
test/vintage/odr2.cpp Normal file
View File

@ -0,0 +1,18 @@
// Copyright (C) 2004 Arkadiy Vertleyb
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include "odr.hpp"
using namespace std;
void odr_test2()
{
char i = 5;
double d = 3.14;
cout << sum(d, i) << endl;
cout << sum(i, d) << endl;
cout << make_sum(d, i)() << endl;
cout << make_sum(i, d)() << endl;
}

23
test/vintage/stl/register.hpp Normal file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2004 Arkadiy Vertleyb
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef STL_REGISTER_HPP_INCLUDED
#define STL_REGISTER_HPP_INCLUDED
#include <boost/typeof/typeof.hpp>
#include <vector>
#include <set>
#include <list>
#include <map>
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
BOOST_TYPEOF_REGISTER_TEMPLATE_X(std::vector, (class)(class));
BOOST_TYPEOF_REGISTER_TEMPLATE(std::list, 2);
BOOST_TYPEOF_REGISTER_TEMPLATE(std::set, 3);
BOOST_TYPEOF_REGISTER_TEMPLATE(std::allocator, 1);
BOOST_TYPEOF_REGISTER_TEMPLATE(std::less, 1);
#endif//STL_REGISTER_HPP_INCLUDED

60
test/vintage/typeid.hpp Normal file
View File

@ -0,0 +1,60 @@
// Copyright (C) 2004 Arkadiy Vertleyb
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef TYPEID_HPP_INCLUDED
#define TYPEID_HPP_INCLUDED
#include <string>
template<bool IsReference,bool IsConst>
struct typeid_base {
template<typename T>
struct inner {
static std::string name()
{
return typeid(T).name();
}
};
};
template<>
struct typeid_base<true,false> {
template<typename T>
struct inner {
static std::string name()
{
return std::string(typeid(T).name())+"&";
}
};
};
template<>
struct typeid_base<false,true> {
template<typename T>
struct inner {
static std::string name()
{
return std::string(typeid(T).name())+" const";
}
};
};
template<>
struct typeid_base<true,true> {
template<typename T>
struct inner {
static std::string name()
{
return std::string(typeid(T).name())+" const&";
}
};
};
template<class T> struct type_id
: typeid_base<boost::is_reference<T>::value,boost::is_const<T>::value>::inner<T>
{
};
#endif//TYPEID_HPP_INCLUDED