template<class T, class U> inline bool operator!=(smart_ptr<T> & a, smart_ptr<U> & b)

{

return a.get() != b.get();

}

	//Turns on and off standard and error logging
	void log::receiveChanged(smart_ptr<logStatusHolder> h)
	{
		if(h==&logStatus)
		{
			if(!std_log->getSpecialCase()) std_log->setIsOn(h->getSTDStatus());
			if(!err_log->getSpecialCase()) err_log->setIsOn(h->getERRStatus());
		}
	}

void smart_ptr_tests::test_case_dereference()
{
    const smart_ptr<char> ptr1;
    assert(ptr1 == nullptr);
    assert(ptr1.use_count() == 0);

    const smart_ptr<char> ptr2(new char);
    *ptr2 = 123;
    assert(*ptr2 == 123);
}

	//Send data
	bool UDPClient::send(smart_ptr<UDPPacket> pck)
	{
		if(!pck)
			return false;
		
		os::smart_ptr<uint8_t> sent = pck->sendData();
        sockaddr* cast;
        if(addr.isIPv6())
            cast= (sockaddr*) &ipv6_addr;
        else
            cast= (sockaddr*) &ipv4_addr;
		if (sendto(s, (char*)sent.get(), (int) (pck->getLength()+2), 0 , cast, slen) > 0)
			return true;
		return false;
	}

int FillPreallocatedBuckets(smart_ptr<DhtImpl> &dhtObj, time_t rtt)
{
	int added = 0;

	DhtID dctr;
	DhtPeerID peerId;
	peerId.addr.set_port(128);
	peerId.addr.set_addr4(0xf0f0f0f0);

	for(int ctr=0; ctr<32; ++ctr)
	{
		dctr.id[4] = ctr;

		// put 8 nodes in the bucket
		for(int nodenum=0; nodenum<8; nodenum++)
		{
			// make a random myID
			for(int y=0; y<5; ++y)
				peerId.id.id[y] = rand();

			// copy the counter bits (5 bits) into the upper 5 bits of the id to be added
			// (to address the particular preallocated bucket)
			for(int x=0; x<5; ++x)
			{
				ProgramBit(peerId.id, 159-x, GetBit(dctr, 4-x));
			}

			// add the node
			(dhtObj->Update(peerId, 0, true, rtt))? ++added:0;
		}
	}
	return added;
}

int OverFillBuckets(smart_ptr<DhtImpl> &dhtObj, time_t rtt)
{
	int added = 0;
	DhtID dctr;
	DhtPeerID peerId;
	peerId.addr.set_port(128);
	peerId.addr.set_addr4(0xf0f0f0f0);
	int numPrefixBits;

	for(int bucketNum=0; bucketNum < dhtObj->_buckets.size(); ++bucketNum)
	{
		numPrefixBits = 160 - dhtObj->_buckets[bucketNum]->span;
		for(int ctr=0; ctr<16; ++ctr)
		{
			// copy "first"
			for(int y=0; y<5; ++y)
				peerId.id.id[y] = dhtObj->_buckets[bucketNum]->first.id[y];

			dctr.id[4] = ctr;
			// move the counter bits (4 bits) into the bits immediatly following the prefix bits
			// the bit range is 0 -> 159
			for(int x=0; x<4; ++x)
			{
				ProgramBit(peerId.id, 159-numPrefixBits-x, GetBit(dctr, 3-x));
			}
			(dhtObj->Update(peerId, 0, true, rtt))? ++added:0;
		}
	}
	return added;
}

inline void swap (smart_ptr<T> &pt, 
                  smart_ptr<T> &pt2)
{  
   typename smart_ptr<T>::value_type *ptr = pt.get();
   pt = pt2;
   pt2 = ptr;
}

  void
  calc_model_data_tmp_holder::save (const smart_ptr <calc_model> &cm)
  {
    pressure->assign (cm->pressure->begin (), cm->pressure->end ());
    saturation_3p->assign (cm->saturation_3p->begin (), cm->saturation_3p->end ());

    if (cm->is_gas ())
      {
        gas_oil_ratio->assign (cm->gas_oil_ratio->begin (), cm->gas_oil_ratio->end ());
        main_var.assign (cm->main_variable.begin (), cm->main_variable.end ());
      }
  }

/**
	Uses the dht's ID (myId) as the base for nodes to be added.  New nodes are always added
	to the bucket that contains myId thus forcing the split.  The dht buckets quit splitting
	once the span of the bucket containing myId reaches 3 (decending from 160).  At this
	there are only 8 possible ID's that can fill the 8 slots in the bucket.

	Note that the number of additions returned includes both new nodes added and existing
	nodes already in the list that are updated.
*/
int FillBucketList(smart_ptr<DhtImpl> &dhtObj, time_t rtt, SubPrefixType subPrefixType, int numPrefixBits = 0, int diff = 1)
{
	int added = 0;
	if(numPrefixBits >=160 || numPrefixBits < 0)
		return added;

	DhtID subPrefixBits;
	DhtPeerID peerId;
	peerId.addr.set_port(128);
	peerId.addr.set_addr4(0xf0f0f0f0);

	for(int ctr=0; ctr<16; ++ctr)
	{
		// copy myID
		for(int y=0; y<5; ++y)
			peerId.id.id[y] = dhtObj->_my_id.id[y];

		subPrefixBits.id[4] = subPrefixType==evenBitDistribution ? ctr : rand()*rand();
		if(subPrefixType==evenBitDistribution)
		{
			// move the counter bits (4 bits) into the bits immediatly following the prefix bits
			// the bit range is 0 -> 159
			for(int x=0; x<4; ++x)
			{
				ProgramBit(peerId.id, 159-numPrefixBits-x, GetBit(subPrefixBits, 3-x));
			}
		}
		else
		{
			for(int x=0; x<32; ++x)
			{
				ProgramBit(peerId.id, 159-numPrefixBits-x, GetBit(subPrefixBits, x));
			}
		}


		//dctr.id[4] = subPrefixType==evenBitDistribution ? ctr : rand()*rand();
		//// move the counter bits (4 bits) into the bits immediatly following the prefix bits
		//// the bit range is 0 -> 159
		//for(int x=0; x<32; ++x)
		//{
		//	ProgramBit(peerId.id, 159-numPrefixBits-x, GetBit(dctr, x));
		//}
		(dhtObj->Update(peerId, 0, true, rtt))? ++added:0;
	}
	added += FillBucketList(dhtObj, rtt, subPrefixType, numPrefixBits+diff, diff);

	return added;
}

inline bool operator>= (const smart_ptr<T1> &pt1, 
                        const smart_ptr<T2> &pt2)
{  return pt1.get() >= pt2.get();  }

 smart_ptr(const smart_ptr<Y> & r, detail::reinterpret_cast_tag)
    :  m_ptr(reinterpret_cast<PointedType*>(r.get()))
 {}

bool uiRunExe(wxFrame* parent,const wxString& path,const wxString& labelOutput, wxWindow* progressDialog,smart_ptr<InterfLogger> extLogger)
{
    _("Elapsed time : ");
    _("Remaining time : ");
    _("Close");
    _("Cancel");
    _("unknown");
    wxProgressDialog * progDialog=wxDynamicCast(progressDialog,wxProgressDialog);
    bool hasOutput=true;
    processManager* process = new processManager(parent,path);
    if(extLogger.get()!=NULL)
        process->AddLogger(extLogger);

    wxLogInfo(_("Execution d'un programme externe :"));
    wxLogInfo(path);

    int processId=wxExecute(path,wxEXEC_ASYNC,process);
    if(!processId)
    {
        wxLogInfo("L'execution du programme a échoué");
        delete process;
        return false;
    }
    float percFinish=0;
    wxDateTime lastProgShow=wxDateTime::UNow();
    while(process->IsRunning())
    {
        hasOutput=true;
        wxMilliSleep(50);
        while(hasOutput) //&& (!progDialog || progDialog->Update(percFinish*100))
        {
            process->LogOutput(hasOutput,labelOutput,&percFinish);
        }
        if(wxDateTime::UNow().GetValue()-lastProgShow.GetValue()>500)
        {
            lastProgShow=wxDateTime::UNow();
            if(parent)
                parent->Update();
            if(percFinish>99.f)
                percFinish=99;
            if(progDialog && !progDialog->Update(percFinish*100))
            {
                wxKillError killerror=wxProcess::Kill(processId,wxSIGKILL);
                wxLogInfo(_("Execution du programme externe annulé."));
                wxLogInfo(_("Réponse du processus :"));
                switch(killerror)
                {
                case wxKILL_OK:              // no error
                    wxLogInfo(_("Pas d'erreur."));
                    break;
                case wxKILL_BAD_SIGNAL:      // no such signal
                    wxLogError(_("Le signal n'existe pas."));
                    break;
                case wxKILL_ACCESS_DENIED:   // permission denied
                    wxLogError(_("Fermeture du processus non autorisée."));
                    break;
                case wxKILL_NO_PROCESS:      // no such process
                    wxLogError(_("Ce processus n'existe pas."));
                    break;
                case wxKILL_ERROR :           // another, unspecified error
                    wxLogError(_("Retour du processus non spécifié"));
                    break;
                default:
                    wxLogError(_("Retour du processus inconnue"));
                    break;
                }
                //Si on supprime le processus maintenant on aura une erreur
                //Si on ne le supprime pas il y a une fuite mémoire
                //delete process;
                return false;
            }
        }
    }
    // On récupère les derniers messages
    wxMilliSleep(150);
    process->LogOutput(hasOutput,labelOutput,&percFinish);
    while(hasOutput)
        process->LogOutput(hasOutput,labelOutput,&percFinish);
    delete process;
    return true;
}

	friend bool operator!= (const smart_ptr &left, nullptr_t)
	{
		return left.get() != nullptr;
	}

void bar(smart_ptr p) {
  delete p.get(); // expected-note{{Memory is released}}
  p.get()->foo(); // expected-note{{Calling 'smart_ptr::get'}}
}

ulong read_surface(
	const std::string& fname, ulong nx, ulong ny,
	smart_ptr< h5_pool_iface > pool, const std::string& surf_name = "",
	const bool invert_z = false
) {
	// set C locale for proper numbers reading
	setlocale(LC_NUMERIC, "C");

	// open file
	std::ifstream f(fname.c_str(), std::ios::in);
	if(!f) {
		BSERR << "Error opening file " << fname << bs_end;
		return 0;
	}

	std::string linebuf;
	std::istringstream line_s;
	//std::size_t pos;
	//t_float point[3];
	//ulong row, col;

	// setup buffer with dimensions passed
	ulong dims[3] = {nx, ny};
	spv_float databuf = BS_KERNEL.create_object(v_float::bs_type());
	databuf->resize(dims[0] * dims[1] * 3);
	std::fill(databuf->begin(), databuf->end(), 0.);

	// actually read file
	ulong n_points = 0;
	while(std::getline(f, linebuf)) {
		line_s.clear();

		// parse some info from comments
		if(linebuf[0] == '#') {
			if(linebuf.find("Information from grid:") != std::string::npos) {
				// EarthVision grid format
				n_points = read_earth_vision_grid(f, dims, databuf);
				break;
			}
			continue;
		}
		// skip ! comments
		if(linebuf[0] == '!') continue;

		if(linebuf.substr(0, 6) == "FSASCI") {
			// CPS-3 grid format
			n_points = read_cps3_grid(f, dims, databuf);
			break;
		}

		if(linebuf[0] == '@') {
			if(linebuf.find("grid") != std::string::npos) {
				// Zmap+grid format
				n_points = read_zmap_grid(f, dims, databuf);
				break;
			}
		}

		// try to read as Irap classic grid
		// TODO: impleent Irap reading
	}

	// restore locale
	setlocale(LC_NUMERIC, "");

	// check if we read nothing
	if(!n_points) {
		BSERR << "No valid data is read from " << fname << bs_end;
		return n_points;
	}
	else {
		BSOUT << "read_surface: succefully read " << n_points << " points from " << fname << bs_end;
	}

	// find out surface name
	std::string surf_name_ = surf_name;
	if(!surf_name.size()) {
		surf_name_ = fname.substr(0, fname.rfind('.'));
		const std::size_t slashpos = std::min(surf_name_.rfind('/'), surf_name_.rfind('\\'));
		if(slashpos != std::string::npos)
			surf_name_ = surf_name_.substr(slashpos + 1);
	}

	// write array to pool
	if(invert_z) {
		for(ulong i = 0; i < databuf->size() / 3; ++i) {
			databuf->ss(i*3 + 2) = -databuf->ss(i*3 + 2);
		}
	}
	//npy_intp h5p_dims[] = { 0, npy_intp(dims[0]), 0, npy_intp(dims[1]), 0, 1 };
	npy_intp h5p_dims[] = { npy_intp(dims[0]), npy_intp(dims[1]), 3 };
	//pool->declare_fp_data(surf_name_, 0, 3, &h5p_dims[0], 1);
	pool->declare_fp_data(surf_name_, 0, 3, &h5p_dims[0], 0);
	pool->set_fp_data(surf_name_, databuf);
	return n_points;
}