C++ CFile::IsPending方法代码示例

bool CTorrent::AddTorrentFromFile(const QByteArray& Torrent)
{
    CFile* pFile = GetFile();

    m_TorrentInfo = new CTorrentInfo(this);
    if(!m_TorrentInfo->LoadTorrentFile(Torrent))
        return false;

    // Privat etorrents should only be shared on the torrent network
    // Note: we overwrite any user choices except the file is completed than the use has all liberties
    if(pFile->IsIncomplete() && m_TorrentInfo->IsPrivate())
        pFile->SetProperty("Torrent", 2);

    if(!pFile->IsPending())
        SaveTorrentToFile();

    pFile->SetFileSize(m_TorrentInfo->GetTotalLength());
    LoadPieceHashes();

    theCore->m_TorrentManager->RegisterInfoHash(m_TorrentInfo->GetInfoHash());

    pFile->SetMasterHash(m_pHash);

    pFile->SetFileName(m_TorrentInfo->GetTorrentName());

    pFile->SetProperty("Description", m_TorrentInfo->GetProperty("Description"));

    SetupPartMap();

    return true;
}

bool CTorrent::InstallMetadata()
{
    CFile* pFile = GetFile();

    ASSERT(m_TorrentInfo);

    CPartMap* pPartMap = pFile->GetPartMap();
    if(pPartMap && !CompareSubFiles(pPartMap))
    {
        if(pFile->GetInspector()->BadMetaData(GetHash()))
            pPartMap = NULL;
        else
            return false;
    }

    if(m_pHash->Compare(pFile->GetMasterHash().data()))
        pFile->SetFileName(m_TorrentInfo->GetTorrentName());

    bool bOpenIO = false;
    CJoinedPartMap* pJoinedParts = qobject_cast<CJoinedPartMap*>(pPartMap);
    if((pPartMap == NULL && !pFile->IsComplete()) || (pJoinedParts && pJoinedParts->GetLinks().isEmpty()))
    {
        bOpenIO = true;
        if(!pPartMap)
            pFile->SetFileSize(m_TorrentInfo->GetTotalLength());

        SetupPartMap();

        if(!pPartMap && !pFile->IsPending())
            pFile->SetFilePath();
    }

    LoadPieceHashes();

    if(pFile->IsIncomplete() && pFile->GetMasterHash()->GetType() == HashTorrent)
        pFile->CleanUpHashes();

    // Note: if neo is the masterhash the IO is already opened
    if(bOpenIO && !pFile->IsPending())
        pFile->Resume();
    return true;
}

void CTorrent::SetupPartMap()
{
    ASSERT(!m_TorrentInfo->IsEmpty());

    CFile* pFile = GetFile();

    // Single File
    if(!m_TorrentInfo->IsMultiFile())
    {
        if(!pFile->GetPartMap())
            pFile->SetPartMap(CPartMapPtr(new CSynced<CPartMap>(m_TorrentInfo->GetTotalLength())));
        return;
    }

    // Multi File:

    CJoinedPartMap* pParts = qobject_cast<CJoinedPartMap*>(pFile->GetPartMap());
    if(pParts)
    {
        ASSERT(!pParts->GetLinks().isEmpty());
        return; // is already set up
    }
    pParts = new CJoinedPartMap(pFile->GetFileSize());

    pFile->GetInspector()->SetIndexSource(HashTorrent);

    CFileList* pList = pFile->GetList();

    uint64 Offset = 0;
    foreach(const CTorrentInfo::SFileInfo& SubFile, m_TorrentInfo->GetFiles())
    {
        if(SubFile.Length == 0)
        {
            LogLine(LOG_DEBUG | LOG_WARNING, tr("Ignoring empty file '%1' in torrent '%2'").arg(SubFile.FileName).arg(pFile->GetFileName()));
            continue;
        }

        CFile* pSubFile = new CFile();
        if(pFile->GetProperty("Temp").toBool())
            pSubFile->SetProperty("Temp", true);

        QString Dir = pFile->GetFileDir();
        Dir += pFile->GetFileName() + "/";
        if(!SubFile.FilePath.isEmpty())
            Dir += SubFile.FilePath.join("/") + "/";
        pSubFile->SetFileDir(Dir);

        pSubFile->AddEmpty(HashTorrent, SubFile.FileName, SubFile.Length, pFile->IsPending());

        // Note: SubFile->MasterHash is set in MasterFile->Resume

        uint64 uBegin = Offset;
        uint64 uEnd = Offset + SubFile.Length;
        Offset += SubFile.Length;

        CSharedPartMap* pSubParts = new CSharedPartMap(uEnd - uBegin);
        pSubFile->SetPartMap(CPartMapPtr(pSubParts));

        pParts->SetupLink(uBegin, uEnd, pSubFile->GetFileID());
        pSubParts->SetupLink(uBegin, uEnd, pFile->GetFileID());

        pList->AddFile(pSubFile);

        if(!pSubFile->IsPending())
            pSubFile->Resume();

        if(pFile->IsPaused(true))
            pSubFile->Pause();
        else if(pFile->IsStarted())
            pSubFile->Start();
    }

    pFile->SetPartMap(CPartMapPtr(pParts));
}

void CTorrent::OnFileHashed()
{
    CFile* pFile = GetFile();
    ASSERT(m_TorrentInfo);
    if(m_TorrentInfo->IsEmpty()) // are we making a torrent
    {
        QStringList Shared = theCore->Cfg()->GetStringList("Content/Shared");
        Shared.append(theCore->GetIncomingDir());
        Shared.append(theCore->GetTempDir());

        QList<CTorrentInfo::SFileInfo> Files;
        if(CJoinedPartMap* pParts = qobject_cast<CJoinedPartMap*>(pFile->GetPartMap()))
        {
            QMap<uint64, SPartMapLink*> Links = pParts->GetJoints();
            for(QMap<uint64, SPartMapLink*>::iterator I = Links.end(); I != Links.begin();)
            {
                SPartMapLink* pLink = *(--I);

                CFile* pSubFile = pFile->GetList()->GetFileByID(pLink->ID);
                if(!pSubFile)
                {
                    LogLine(LOG_DEBUG | LOG_ERROR, tr("A sub file of %1 has been being removed befoure the torrent was created").arg(pFile->GetFileName()));
                    pFile->TorrentHashed(this, false);
                    return;
                }

                CTorrentInfo::SFileInfo File;
                QString Root;
                QStringList Path = GetRelativeSharedPath(pSubFile->GetFilePath(), Shared, Root).split("/", QString::SkipEmptyParts);
                if(!Path.isEmpty())
                {
                    if(Path.count() > 1)
                        Path.removeFirst();
                    File.FileName = Path.takeLast();
                    File.FilePath = Path;
                }
                else
                    File.FileName = "unknown";
                File.Length = pSubFile->GetFileSize();
                Files.append(File);
            }
        }

        if(CFileHashTree* pHashTree = qobject_cast<CFileHashTree*>(m_pHash.data()))
            m_TorrentInfo->MakeMetadata(Files, pHashTree->GetPartSize(), QList<QByteArray>(), pHashTree->GetRootHash());
        else if(CFileHashSet* pHashSet = qobject_cast<CFileHashSet*>(m_pHash.data()))
            m_TorrentInfo->MakeMetadata(Files, pHashSet->GetPartSize(), pHashSet->GetHashSet());
        else {
            ASSERT(0);
        }

        if(!pFile->IsPending())
            SaveTorrentToFile();

        m_pHash->SetHash(m_TorrentInfo->GetInfoHash());
        theCore->m_TorrentManager->RegisterInfoHash(m_TorrentInfo->GetInfoHash());

        pFile->TorrentHashed(this, true);
    }
    else // we are importing a torrent
    {
        bool bMatch = false;

        if(CFileHashTree* pHashTree = qobject_cast<CFileHashTree*>(m_pHash.data()))
            bMatch = m_TorrentInfo->GetRootHash() == pHashTree->GetRootHash();
        else if(CFileHashSet* pHashSet = qobject_cast<CFileHashSet*>(m_pHash.data()))
            bMatch = m_TorrentInfo->GetPieceHashes() == pHashSet->GetHashSet();
        else {
            ASSERT(0);
        }

        if(bMatch)
        {
            if(!pFile->IsPending())
                SaveTorrentToFile();

            m_pHash->SetHash(m_TorrentInfo->GetInfoHash());
            theCore->m_TorrentManager->RegisterInfoHash(m_TorrentInfo->GetInfoHash());
        }

        pFile->TorrentHashed(this, bMatch);
    }
}