C++ CIArrayOf类代码示例

void StackElement::gatherPoolPending(CIArrayOf<StackElement> & pending)
{
    if (prev && !prev->IsShared())
        pending.append(*prev.getClear());
    if (sibling && !sibling->IsShared())
        pending.append(*sibling.getClear());
}

void associateRemoteInputs(CIArrayOf<OrderedInput> & orderedInputs, unsigned numPriorityInputs)
{
    //If we know for sure the primary input, then tag it as worth reading ahead - otherwise it will be dynamically set later.
    if (numPriorityInputs > 0)
    {
        OrderedInput & input0 = orderedInputs.item(0);
        //Only read ahead etc. if this is a real index - not if it is a join.
        if (!input0.isJoin())
        {
            input0.setReadAhead(true);
            input0.setAlwaysReadExact();
        }
    }

    //Work out the last input of known priority which is read remotely.
    unsigned maxPriorityRemote = numPriorityInputs;
    while ((maxPriorityRemote >= 2) && !orderedInputs.item(maxPriorityRemote-1).readsRowsRemotely())
        maxPriorityRemote--;

    //If the second ordered input is known to be read remotely, then we want to send multiple seek requests at the same time.
    //MORE: Maybe we should consider doing this to all other inputs if only one priority input is known.
    if (maxPriorityRemote >= 2)
    {
        for (unsigned i=1; i < maxPriorityRemote; i++)
        {
            IMultipleStepSeekInfo * seekInfo = orderedInputs.item(i-1).createMutipleReadWrapper();
            orderedInputs.item(i).createMultipleSeekWrapper(seekInfo);
        }
    }
}

//---------------------------------------------------------------------------
void doUnwindRelease(GrammarSymbol * symbol, CIArrayOf<GrammarSymbol> & pending)
{
    if (!symbol->isPacked())
    {
        unsigned level = pending.ordinality();
        unsigned num = symbol->numChildren();
        for (unsigned i = 0; i < num; i++)
            pending.append(*LINK(symbol->queryChild(i)));
        if (!symbol->Release())
            pending.trunc(level);
    }
    else
        symbol->Release();
}

void RowTransformer::generateCopies(unsigned & seq, CIArrayOf<RowRecord> const & records)
{
    sequence = seq++;
    ForEachItemIn(fieldNum, records)
    {
        RowRecord const & record = records.item(fieldNum);
        if(record.isToFpos())
        {
            assertex(sequence == 0);
            if(record.isFromFpos())
                keepFpos = true;
            else
                generateCopyToFpos(record);
        }
        else
        {
            if(record.isFromFpos())
                generateCopyFromFpos(record);
            else
                generateSimpleCopy(seq, record);
        }
    }

void removeAbortHandler(IAbortHandler & handler)
{
    CriticalBlock c(abortCrit);
    ForEachItemInRev(idx, handlers)
    {
        if (handlers.item(idx).ihandler == &handler)
        {
            handlers.remove(idx);
            break;
        }
    }
    queryUninstallAbortHandler();
}

static void UnixAbortHandler(int sig)
{
    hadAbortSignal = true;
    if (handlers.length()==0 || notifyOnAbort())
    {
        _exit(0);
    }
}

 void add(RemoteFilename &filename,unsigned partno,unsigned copy,unsigned crc)
 {
     CFileCrcItem *item = new CFileCrcItem();
     item->filename.set(filename);
     item->partno = partno;
     item->copy = copy;
     item->crc = crc;
     item->requiredcrc = crc;
     list.append(*item);
 }

static void loadMachineMap()
{
    if (machinelist.ordinality())
        return;
    Owned<IRemoteConnection> conn = querySDS().connect("/Environment/Hardware", myProcessSession(), RTM_LOCK_READ, SDS_LOCK_TIMEOUT);
    if (!conn)
        return;
    IPropertyTree* root = conn->queryRoot();
    Owned<IPropertyTreeIterator> machines= root->getElements("Computer");
    if (machines->first()) {
        do {
            IPropertyTree &machine = machines->query();
            SocketEndpoint ep(machine.queryProp("@netAddress"));
            ep.port = getDaliServixPort();
            const char *name = machine.queryProp("@name");
            const char *state=machine.queryProp("@state");
            CMachineEntry *entry = new CMachineEntry(name,ep,!state||stricmp(state,"Available")==0);
            machinemap.setValue(name, entry);
            machinelist.append(*entry);
        } while (machines->next());
    }
}

bool notifyOnAbort()
{
//  DBGLOG("notifyOnAbort %x", GetCurrentThreadId());
//      CriticalBlock c(abortCrit); You would think that this was needed, but it locks up.
//      If it needs to be threadsafe, have to clone the list or something
    bool doExit = false;
    ForEachItemInRev(idx, handlers)
    {
        if (handlers.item(idx).handle())
            doExit = true;
    }
//  DBGLOG("notifyOnAbort returning %d", (int) doExit);
    return doExit;
}

void queryUninstallAbortHandler()
{
    if (handlers.ordinality())
        return;

#if defined(_WIN32)
    if (handlerInstalled)
    {
        SetConsoleCtrlHandler( WindowsAbortHandler, FALSE);
        handlerInstalled = false;
    }
#else
    // Don't uninstall - we always want one for the module exit support
#endif
}

void addAbortHandler(IAbortHandler & handler)
{
    CriticalBlock c(abortCrit);
    queryInstallAbortHandler();
    handlers.append(*new AbortHandlerInfo(&handler));
}

    void verifyFile(const char *name,CDateTime *cutoff)
    {
        Owned<IDistributedFile> file=queryDistributedFileDirectory().lookup(name,UNKNOWN_USER);
        if (!file)
            return;
        IPropertyTree &fileprops = file->queryAttributes();
        bool blocked = false;
        if (file->isCompressed(&blocked)&&!blocked)
            return;
        if (stopped)
            return;
        StringBuffer dtstr;
        if (fileprops.getProp("@verified",dtstr)) {
            if (!cutoff)
                return;
            CDateTime dt;
            dt.setString(dtstr.str());
            if (dt.compare(*cutoff)<=0)
                return;
        }
        list.kill();
        unsigned width = file->numParts();
        unsigned short port = getDaliServixPort();
        try {
            Owned<IDistributedFilePart> testpart = file->getPart(0);
            SocketEndpoint ep(testpart->queryNode()->endpoint()); 
            if (!dafilesrvips.verifyDaliFileServer(ep)) {
                StringBuffer ips;
                ep.getIpText(ips);
                PROGLOG("VERIFY: file %s, cannot run DAFILESRV on %s",name,ips.str());
                return;
            }
        }
        catch (IException *e)
        {
            StringBuffer s;
            s.appendf("VERIFY: file %s",name);
            EXCLOG(e, s.str());
            e->Release();
            return;
        }
        for (unsigned idx=0;idx<width;idx++) {
            Owned<IDistributedFilePart> part = file->getPart(idx);
            for (unsigned copy = 0; copy < part->numCopies(); copy++) {
                if (stopped)
                    return;
                unsigned reqcrc;
                if (!part->getCrc(reqcrc))
                    continue;
                SocketEndpoint ep(part->queryNode()->endpoint());
                if (!dafilesrvips.verifyDaliFileServer(ep)) {
                    StringBuffer ips;
                    ep.getIpText(ips);
                    PROGLOG("VERIFY: file %s, cannot run DAFILESRV on %s",name,ips.str());
                    continue;
                }
                RemoteFilename rfn;
                part->getFilename(rfn,copy);
                rfn.setPort(port); 
                add(rfn,idx,copy,reqcrc);
            }
        }
        if (list.ordinality()==0)
            return;
        PROGLOG("VERIFY: file %s started",name);
        file.clear();
        CriticalSection crit;
        class casyncfor: public CAsyncFor
        {
            CFileCrcList *parent;
            CriticalSection &crit;
        public:
            bool ok;
            casyncfor(CFileCrcList *_parent, CriticalSection &_crit)
                : crit(_crit)
            {
                parent = _parent;
                ok = true;
            }
            void Do(unsigned i)
            {
                CriticalBlock block(crit);
                if (parent->stopped)
                    return;
                CFileCrcItem &item = parent->list.item(i);
                RemoteFilename &rfn = item.filename;
                Owned<IFile> partfile;
                StringBuffer eps;
                try
                {
                    partfile.setown(createIFile(rfn));
                    // PROGLOG("VERIFY: part %s on %s",partfile->queryFilename(),rfn.queryEndpoint().getUrlStr(eps).str());
                    if (partfile) {
                        if (parent->stopped)
                            return;
                        CriticalUnblock unblock(crit);
                        item.crc = partfile->getCRC();
                    }
                    else
                        ok = false;
//.........这里部分代码省略.........