ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

get this wrapper basically to compile

Browse source 
the simple case of an embedded pointer actualy works already
This commit is contained in:
Fischlurch 2017-01-12 06:27:31 +01:00
parent 9ba2618844
commit e60abf66c0
2 changed files with 57 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
src/lib/replaceable-item.hpp
View file

@ -52,6 +52,7 @@ namespace wrapper {
// using util::unConst; // using util::unConst;
using util::isSameObject; using util::isSameObject;
using std::forward;
// using lumiera::error::LUMIERA_ERROR_BOTTOM_VALUE; // using lumiera::error::LUMIERA_ERROR_BOTTOM_VALUE;
@ -99,6 +100,9 @@ namespace wrapper {
return access(); return access();
} }
X& get() { return access(); }
private: private:
X& X&
access() const access() const
@ -131,11 +135,38 @@ namespace wrapper {
} }
}; };
template<typename X> template<typename X>
class ReplaceableItem<X, meta::enable_if<std::is_copy_assignable<X>>> struct is_assignable_value
: public X : std::__and_<std::is_copy_assignable<X>, std::__not_<std::is_reference<X>>>
{ { };
using X::X;
template<typename X>
class ReplaceableItem<X, meta::enable_if<is_assignable_value<X>>>
{
X val_;
public:
ReplaceableItem() : val_() { }
ReplaceableItem(X const& val) : val_(val) { }
ReplaceableItem(X && val) : val_(forward<X>(val)) { }
ReplaceableItem& operator= (X const& val) { val_=val; return *this; }
ReplaceableItem& operator= (X && val) { val_=forward<X>(val); return *this; }
operator X&() { return val_; }
operator X const&() const { return val_; }
X& get() { return val_; }
};
template<typename X>
class ReplaceableItem<X, meta::enable_if<std::is_reference<X>>>
{
static_assert( not sizeof(X), "ReplaceableItem for references is pointless");
}; };

40
tests/library/replaceable-item-test.cpp
View file

@ -25,6 +25,7 @@
#include "lib/test/run.hpp" #include "lib/test/run.hpp"
#include "lib/test/test-helper.hpp" #include "lib/test/test-helper.hpp"
#include "lib/util.hpp" #include "lib/util.hpp"
#include "lib/format-cout.hpp"////////////TODO
#include "lib/replaceable-item.hpp" #include "lib/replaceable-item.hpp"
@ -49,8 +50,6 @@ namespace test{
using std::vector; using std::vector;
using std::string; using std::string;
using std::rand; using std::rand;
using std::cout;
using std::endl;
@ -102,6 +101,13 @@ namespace test{
string s2 (randStr(50)); string s2 (randStr(50));
const char* cp (s1.c_str()); const char* cp (s1.c_str());
cout << std::boolalpha << is_assignable_value<int>::value <<endl;
cout << std::boolalpha << is_assignable_value<int&>::value <<endl;
cout << std::boolalpha << is_assignable_value<int&&>::value <<endl;
cout << std::boolalpha << is_assignable_value<int const&>::value <<endl;
cout << std::boolalpha << is_assignable_value<int*>::value <<endl;
#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #888
verifyWrapper<ulong> (l1, l2); verifyWrapper<ulong> (l1, l2);
verifyWrapper<ulong&> (l1, l2); verifyWrapper<ulong&> (l1, l2);
verifyWrapper<ulong*> (&l1, &l2); verifyWrapper<ulong*> (&l1, &l2);
@ -117,9 +123,11 @@ namespace test{
verifySaneInstanceHandling(); verifySaneInstanceHandling();
verifyWrappedRef (); #endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #888
verifyWrappedPtr ();
} }
#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #888
template<typename X, typename Y> template<typename X, typename Y>
void void
@ -188,30 +196,26 @@ namespace test{
} }
CHECK (0 == cntTracker); CHECK (0 == cntTracker);
} }
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #888
/** @test verify especially that we can handle /** @test verify especially that we can handle and re-"assign" an embedded pointer */
* and re-"assign" an embedded reference
*/
void void
verifyWrappedRef () verifyWrappedPtr ()
{ {
int x = 5; int x = 5;
ReplaceableItem<int&> refWrap; ReplaceableItem<int*> ptrWrap;
CHECK (refWrap == 0); CHECK (ptrWrap.get() == NULL);
refWrap = x; ptrWrap = &x;
CHECK (5 == refWrap); CHECK (5 == *ptrWrap.get());
CHECK (x == refWrap); CHECK (&x == ptrWrap.get());
refWrap += 5; *ptrWrap.get() += 5;
CHECK (x == 10); CHECK (x == 10);
ItemWrapper<int*> ptrWrap (& static_cast<int&>(refWrap)); CHECK ( isSameObject (*ptrWrap.get(), x));
CHECK ( isSameObject (*static_cast<int*>(ptrWrap), x)); CHECK (!isSameObject ( ptrWrap.get(), x));
CHECK (!isSameObject ( static_cast<int*>(ptrWrap), &x));
*static_cast<int*>(ptrWrap) += 13;
CHECK (x == 23);
} }
}; };