uint64_t randomize( fc::vector<char>& data, uint64_t seed ) {
fc::vector<char> tmp(data.size());
do {
++seed;
boost::random::mt19937 gen(seed);
uint32_t* src = (uint32_t*)data.data();
uint32_t* end = src +(data.size()/sizeof(uint32_t));
uint32_t* dst = (uint32_t*)tmp.data();
if( data.size() > 3 ) {
gen.generate( dst, dst + (tmp.size()/sizeof(uint32_t)) );
while( src != end ) {
*dst = *src ^ *dst;
++dst;
++src;
}
}
if( int extra = data.size() % 4 ) {
int t = 0;
int r = 0;
gen.generate( &r, (&r)+1 );
memcpy( &t, src, extra );
t ^= r;
memcpy( dst, &t, extra );
}
} while ( !is_random(tmp) );
fc_swap(data,tmp);
return seed;
}
bigint bigint::operator /= ( const bigint& a ) {
BN_CTX* ctx = BN_CTX_new();
bigint tmp;
BN_div( tmp.n, NULL, n, a.n, ctx );
fc_swap( tmp.n, n );
BN_CTX_free(ctx);
return tmp;
}
variant_object& variant_object::operator=( variant_object&& obj )
{
if (this != &obj)
{
fc_swap(_key_value, obj._key_value );
assert( _key_value != nullptr );
}
return *this;
}
server& server::operator=(server&& s) { fc_swap(my,s.my); return *this; }
server::response& server::response::operator=(server::response&& s) { fc_swap(my,s.my); return *this; }
future& operator=(future<void>&& f ) {
fc_swap(m_prom,f.m_prom);
return *this;
}
logger& logger::operator=( logger&& l ){
fc_swap(my,l.my);
return *this;
}
void variant_object::entry::set( variant v )
{
fc_swap( _value, v );
}
variant_object::entry& variant_object::entry::operator=( variant_object::entry&& e )
{
fc_swap( _key, e._key );
fc_swap( _value, e._value );
return *this;
}
cafs::resource& cafs::resource::operator = ( cafs::resource&& c ) {
fc_swap(c._data,_data);
return *this;
}
cafs& cafs::operator = ( cafs&& c ) {
fc_swap(my,c.my);
return *this;
}
bigint& bigint::operator = ( bigint&& a ) {
fc_swap( a.n, n );
return *this;
}
unique_ptr& operator=( unique_ptr&& o )
{
fc_swap( _p, o._p );
return *this;
}
