C++ UnLock函数代码示例

static boolean isAmigaDirectory (const char *const name)
{
	boolean result = FALSE;
	struct FileInfoBlock *const fib = xMalloc (1, struct FileInfoBlock);
	if (fib != NULL)
	{
		const BPTR flock = Lock ((UBYTE *) name, (long) ACCESS_READ);

		if (flock != (BPTR) NULL)
		{
			if (Examine (flock, fib))
				result = ((fib->fib_DirEntryType >= 0) ? TRUE : FALSE);
			UnLock (flock);
		}
		eFree (fib);
	}
	return result;
}

void OMXPlayerAudio::Flush()
{
  Lock();
  LockDecoder();
  m_flush = true;
  while (!m_packets.empty())
  {
    OMXPacket *pkt = m_packets.front(); 
    m_packets.pop_front();
    OMXReader::FreePacket(pkt);
  }
  m_iCurrentPts = DVD_NOPTS_VALUE;
  m_cached_size = 0;
  if(m_decoder)
    m_decoder->Flush();
  UnLockDecoder();
  UnLock();
}

BOOL TInifile::WriteIni()
{
	Lock();

	BOOL	ret = FALSE;
	HANDLE	hFile = ::CreateFileW(iniFile, GENERIC_WRITE, 0, 0, CREATE_ALWAYS,
									FILE_ATTRIBUTE_NORMAL, 0);

	if (hFile != INVALID_HANDLE_VALUE) {
#define MIN_INI_ALLOC (64 * 1024)
#define MAX_INI_ALLOC (10 * 1024 * 1024)
#define MIN_LINE_SIZE (2 * 1024)
		VBuf	vbuf(MIN_INI_ALLOC, MAX_INI_ALLOC);
		char	*p = (char *)vbuf.Buf();

		for (TIniSection *sec = TopObj(); sec && p; sec = NextObj(sec)) {
			TIniKey *key = sec->TopObj();
			int		len = 0;
			if (key) {
				if (sec->Name()) {
					len = sprintf(p, "[%s]\r\n", sec->Name());
					p = NextBuf(&vbuf, len, MIN_LINE_SIZE, MIN_INI_ALLOC);
				}
				while (key) {
					if (key->Key())	{
						len = sprintf(p, "%s=\"%s\"\r\n", key->Key(), key->Val());
						p = NextBuf(&vbuf, len, MIN_LINE_SIZE, MIN_INI_ALLOC);
					}
					else {
						len = sprintf(p, "%s\r\n", key->Val());
						p = NextBuf(&vbuf, len, MIN_LINE_SIZE, MIN_INI_ALLOC);
					}
					key = sec->NextObj(key);
				}
			}
		}
		DWORD	size;
		ret = ::WriteFile(hFile, vbuf.Buf(), (DWORD)vbuf.UsedSize(), &size, 0);
		::CloseHandle(hFile);
	}
	UnLock();

	return	ret;
}

// Get disk info
LONG GetDiskInfo(char *device,struct InfoData *info)
{
	struct DevProc *proc;
	struct DosList *dos;
	LONG res=0;

	// Get device proc
	if (!(proc=GetDeviceProc(device,0)))
		return 0;

	// Send packet
#ifdef __AROS__
	if (((struct Library *)DOSBase)->lib_Version<50)
	{
		//res=Info(proc->dvp_Lock,info);
		BPTR lock;
		if ((lock=Lock(device,SHARED_LOCK)))
		{
			res=Info(lock,info);
			UnLock(lock);
		}
	}
	else
#endif
	res=DoPkt(proc->dvp_Port,ACTION_DISK_INFO,MKBADDR(info),0,0,0,0);

	// Clear "in use" flag to indicate formatting by default
	info->id_InUse=0;

	// Get doslist pointer
	if ((dos=DeviceFromHandler(proc->dvp_Port,NULL)))
	{
		// Invalid device?
		if (!GetDeviceUnit(dos->dol_misc.dol_handler.dol_Startup,NULL,NULL))
		{
			// Disk can't be formatted
			info->id_InUse=1;
		}
	}

	// Free device proc
	FreeDeviceProc(proc);
	return res;
}

// Delete any temporary files
void delete_temp_files(struct DateStamp *last)
{
	struct AnchorPath *anchor;
	BPTR old,lock;

	// Lock T: and cd
	if ((lock=Lock("t:",ACCESS_READ)))
	{
		// CD to t:
		old=CurrentDir(lock);

		// Allocate an anchor
		if ((anchor=AllocVec(sizeof(struct AnchorPath),MEMF_CLEAR)))
		{
			short error;
			struct FileInfoBlock fibcopy;

			// See if any script files already exist
			error=MatchFirst("T:dopus#?tmp#?",anchor);
			while (!error)
			{
				// Copy fib
				fibcopy=anchor->ap_Info;

				// Get next
				error=MatchNext(anchor);

				// Check datestamp
				if (!last ||
					CompareDates(&fibcopy.fib_Date,last)>=0)
				{
					// Try to delete file
					DeleteFile(fibcopy.fib_FileName);
				}
			}

			// Cleanup anchor
			MatchEnd(anchor);
			FreeVec(anchor);
		}

		UnLock(CurrentDir(old));
	}
}

TInt RSignalSession::OnDemandConnection()
	{
	TInt err = KErrNone;
	//On Demand connection
	if ( !iIsConnected )
		{
		Lock();
		if ( !iIsConnected )
			{
			err = Connect ();
			if ( KErrNone == err)
				{
				iIsConnected = ETrue;
				}
			}
		UnLock();
		}
	return err;
	}

//自ストリームのサービス一覧を取得する
//戻り値：
// エラーコード
//引数：
// serviceList				[OUT]サービス情報のリスト
DWORD CBonCtrl::GetServiceListActual(
	vector<TS_SERVICE_INFO>* serviceList
	)
{
	if( Lock(L"GetServiceListActual") == FALSE ) return EpgNoData;

	DWORD _serviceListSize = 0;
	SERVICE_INFO* _serviceList = NULL;
	DWORD err = this->tsOut.GetServiceListActual(&_serviceListSize, &_serviceList);
	if( err == NO_ERR ){
		for( DWORD i=0; i<_serviceListSize; i++ ){
			TS_SERVICE_INFO item;
			item.ONID = _serviceList[i].original_network_id;
			item.TSID = _serviceList[i].transport_stream_id;
			item.SID = _serviceList[i].service_id;
			if( _serviceList[i].extInfo != NULL ){
				item.serviceType = _serviceList[i].extInfo->service_type;
				item.partialFlag = _serviceList[i].extInfo->partialReceptionFlag;
				if( _serviceList[i].extInfo->service_name != NULL ){
					item.serviceName = _serviceList[i].extInfo->service_name;
				}else{
					item.serviceName = L"";
				}
				if( _serviceList[i].extInfo->network_name != NULL ){
					item.networkName = _serviceList[i].extInfo->network_name;
				}else{
					item.networkName = L"";
				}
				item.remoteControlKeyID = _serviceList[i].extInfo->remote_control_key_id;
			}else{
				item.serviceType = 0;
				item.partialFlag = 0;
				item.serviceName = L"";
				item.networkName = L"";
				item.remoteControlKeyID = 0;
			}
			serviceList->push_back(item);
		}
	}

	UnLock();
	return err;
}

void COMXCoreComponent::FlushInput()
{
    if(!m_handle)
        return;

    Lock();

    OMX_ERRORTYPE omx_err = OMX_ErrorNone;

    omx_err = OMX_SendCommand(m_handle, OMX_CommandFlush, m_input_port, NULL);

    if(omx_err != OMX_ErrorNone) {
        Logger::LogOut(LOG_LEVEL_ERROR, "COMXCoreComponent::FlushInput - Error on component %s omx_err(0x%08x)",
                m_componentName.c_str(), (int)omx_err);
    }
    WaitForCommand(OMX_CommandFlush, m_input_port);

    UnLock();
}

bool OMXClock::OMXResume(bool lock /* = true */)
{
  if(m_omx_clock.GetComponent() == NULL)
    return false;

  if(m_pause)
  {
    if(lock)
      Lock();

    if (OMXSetSpeed(m_omx_speed, false, true))
      m_pause = false;

    m_last_media_time = 0.0f;
    if(lock)
      UnLock();
  }
  return m_pause == false;
}

BOOL CEpgDBManager::ReloadEpgData()
{
	if( Lock() == FALSE ) return FALSE;

	BOOL ret = TRUE;
	if( this->loadThread == NULL ){
		//受信スレッド起動
		ClearEpgData();
		ResetEvent(this->loadStopEvent);
		this->loadThread = (HANDLE)_beginthreadex(NULL, 0, LoadThread, (LPVOID)this, CREATE_SUSPENDED, NULL);
		SetThreadPriority( this->loadThread, THREAD_PRIORITY_NORMAL );
		ResumeThread(this->loadThread);
	}else{
		ret = FALSE;
	}

	UnLock();
	return ret;
}

inline s32 Factory::AddVIPC(VIPCDeviceParam & pParam)
{
    s32 nId = GetVIPCID();
    FactoryDeviceChangeData change;

    VDC_DEBUG( "%s GetDeviceID %d\n",__FUNCTION__, nId);

    Lock();
    pParam.m_Conf.data.conf.nId = nId;
    m_VIPCDeviceParamMap[nId] = pParam;

    m_Conf.AddVIPC(pParam.m_Conf, nId);
    UnLock();
    change.id = nId;
    change.type = FACTORY_VIPC_ADD;
    CallDeviceChange(change);
	
    return nId;
}

/*
=================
Sys_SetBinaryPath
=================
*/
void Sys_SetBinaryPath(const char *path)
{
#ifdef __AROS__
	if (!strcmp(path, "."))
	{
		BPTR lock = Lock("PROGDIR:", ACCESS_READ);

		if (lock)
		{
			NameFromLock(lock, binaryPath, sizeof(binaryPath));
			UnLock(lock);
		}
	}
	else
#endif
	{
		Q_strncpyz(binaryPath, path, sizeof(binaryPath));
	}
}

/* return malloc'd version of full pathname of orig_name */
int archdep_expand_path(char **return_path, const char *orig_name)
{
    BPTR lock;

    lock = Lock(orig_name, ACCESS_READ);
    if (lock) {
        char name[1024];
        LONG rc;

        rc = NameFromLock(lock, name, 1024);
        UnLock(lock);
        if (rc) {
            *return_path = lib_stralloc(name);
            return 0;
        }
    }
    *return_path = lib_stralloc(orig_name);
    return 0;
}

//タイムシフト送信を開始する
//戻り値：
// TRUE（成功）、FALSE（失敗）
BOOL CTimeShiftUtil::StartTimeShift()
{
	if( Lock() == FALSE ) return FALSE;
	BOOL ret = TRUE;
	if( this->filePath.size() == 0 ){
		ret = FALSE;
	}else{
		if( this->readThread == NULL ){
			//受信スレッド起動
			ResetEvent(this->readStopEvent);
			this->readThread = (HANDLE)_beginthreadex(NULL, 0, ReadThread, (LPVOID)this, CREATE_SUSPENDED, NULL);
			SetThreadPriority( this->readThread, THREAD_PRIORITY_NORMAL );
			ResumeThread(this->readThread);
		}
	}

	UnLock();
	return ret;
}

struct List *LoadBlankerEntries( STRPTR Path )
{
    struct FileInfoBlock *Blk;
    struct List *Entries = 0L;
    BlankerEntry *New;
    BPTR DirLock;
	
    if(!( Entries = AllocVec( sizeof( struct List ), MEMF_CLEAR )))
        return 0L;
    else
        NewList( Entries );
	
    NumBlankEntries = 0;
    
    if( DirLock = Lock( Path, ACCESS_READ ))
    {
        if(( Blk = AllocDosObject( DOS_FIB, 0L ))&&( Examine( DirLock, Blk )))
        {
            while( ExNext( DirLock, Blk ))
            {
                if(( Blk->fib_FileName )&&
                   ( FileIsModule( Path, Blk->fib_FileName )))
                {
                    if( New = NewBlankerEntry( Path, Blk->fib_FileName,
											  Blk->fib_Comment ))
                    {
                        New->be_Node.ln_Pri = 128 - ( New->be_Name[0] - 'a' );
                        Enqueue( Entries, ( struct Node * )New );
                        NumBlankEntries++;
                    }
                }
            }
            FreeDosObject( DOS_FIB, Blk );
        }
        UnLock( DirLock );
    }
    
    if( New = NewBlankerEntry( ":", "Random", "" ))
        AddTail( Entries, ( struct Node * )New );
	
    return Entries;
}