C++ CDateTime::getString方法代码示例

void checkFilePart(IChecker *checker,IDistributedFilePart *part,bool blocked)
{
    StringBuffer tmp;
    checker->add("getPartIndex",part->getPartIndex());
    unsigned n = part->numCopies();
    checker->add("numCopies",part->numCopies());
    checker->add("maxCopies",n);
    RemoteFilename rfn;
    for (unsigned copy=0;copy<n;copy++) {
        INode *node = part->queryNode(copy);
        if (node)
            checker->add(copy,"queryNode",node->endpoint().getUrlStr(tmp.clear()).str());
        else
            checker->error("missing node");
        checker->add(copy,"getFilename",part->getFilename(rfn,copy).getRemotePath(tmp.clear()).str());
    }
    checker->add("getPartName",part->getPartName(tmp.clear()).str());
#ifndef COMPAT
    checker->add("getPartDirectory",part->getPartDirectory(tmp.clear()).str());
#endif
    checker->add("queryProperties()",toXML(&part->queryAttributes(),tmp.clear()).str());
    checker->add("isHost",part->isHost()?1:0);
    checker->add("getFileSize",part->getFileSize(false,false));
    CDateTime dt;
    if (part->getModifiedTime(false,false,dt))
        dt.getString(tmp.clear());
    else
        tmp.clear().append("nodatetime");
    checker->add("getModifiedTime",tmp.str());
    unsigned crc;
    if (part->getCrc(crc)&&!blocked)
        checker->add("getCrc",crc);
    else
        checker->add("getCrc","nocrc");
}

bool Cws_accountEx::onMyAccount(IEspContext &context, IEspMyAccountRequest &req, IEspMyAccountResponse &resp)
{
    try
    {
        ISecUser* user = context.queryUser();
        if(user != NULL)
        {
            CDateTime dt;
            user->getPasswordExpiration(dt);
            StringBuffer sb;
            if (dt.isNull())
                sb.append("Never");
            else
            {
                dt.getString(sb);
                sb.replace('T', (char)0);//chop off timestring
            }
            resp.setPasswordExpiration(sb.str());
            resp.setPasswordDaysRemaining(user->getPasswordDaysRemaining());
            resp.setFirstName(user->getFirstName());
            resp.setLastName(user->getLastName());
            resp.setUsername(user->getName());
        }
    }
    catch(IException* e)
    {
        FORWARDEXCEPTION(context, e, ECLWATCH_INTERNAL_ERROR);
    }
    return true;
}

void MessageGenerator::initDefaultValues()
{
    char dbuf[64];

    CDateTime now;
    now.setNow();
    
    StringBuffer nowstr;
    now.getString(nowstr, true);
    
    unsigned y, m, d;
    now.getDate(y, m, d, true);
    unsigned h, minute, s, nano;
    now.getTime(h, minute, s, nano, true);

    m_defaultvalues["string"] = "string";
    m_defaultvalues["boolean"] = "1";
    m_defaultvalues["decimal"] = "3.1415926535897932384626433832795";
    m_defaultvalues["float"] = "3.14159";
    m_defaultvalues["double"] = "3.14159265358979";
    m_defaultvalues["duration"] = "P1Y2M3DT10H30M";
    m_defaultvalues["dateTime"] = nowstr.str();
    sprintf(dbuf, "%02d:%02d:%02d", h,minute,s);
    m_defaultvalues["time"] = dbuf;
    sprintf(dbuf, "%04d-%02d-%02d", y, m, d);
    m_defaultvalues["date"] = dbuf;
    sprintf(dbuf, "%04d-%02d", y, m);
    m_defaultvalues["gYearMonth"] = dbuf;
    sprintf(dbuf, "%04d", y);
    m_defaultvalues["gYear"] = dbuf;
    sprintf(dbuf, "--%02d-%02d", m, d);
    m_defaultvalues["gMonthDay"] = dbuf;
    sprintf(dbuf, "---%02d", d);
    m_defaultvalues["gDay"] = dbuf;
    sprintf(dbuf, "--%02d--", m);
    m_defaultvalues["gMonth"] = dbuf;
    m_defaultvalues["hexBinary"] = "A9D4C56EFB";
    m_defaultvalues["base64Binary"] = "YmFzZTY0QmluYXJ5";
    m_defaultvalues["anyURI"] = "http://anyURI/";
    m_defaultvalues["QName"] = "q:name";
    m_defaultvalues["NOTATION"] = "NOTATION";
    m_defaultvalues["normalizedString"] = "normalizedString";
    m_defaultvalues["token"] = "token";
    m_defaultvalues["language"] = "en-us";
    m_defaultvalues["integer"] = "0";
    m_defaultvalues["nonPositiveInteger"] = "-1";
    m_defaultvalues["negativeInteger"] = "-2";
    m_defaultvalues["long"] = "2147483647";
    m_defaultvalues["int"] = "32716";
    m_defaultvalues["short"] = "4096";
    m_defaultvalues["byte"] = "127";
    m_defaultvalues["nonNegativeInteger"] = "3";
    m_defaultvalues["positiveInteger"] = "2";
    m_defaultvalues["unsignedLong"] = "4294967295";
    m_defaultvalues["unsignedInt"] = "4";
    m_defaultvalues["unsignedShort"] = "65535";
    m_defaultvalues["unsignedByte"] = "255";
}

CSDSServerStatus::CSDSServerStatus(const char *servername)
{
    conn = querySDS().connect("Status/Servers/Server", myProcessSession(), RTM_CREATE_ADD | RTM_LOCK_READ | RTM_DELETE_ON_DISCONNECT, 5*60*1000);
    if (conn) {
        IPropertyTree &root = *conn->queryRoot();
        root.setProp("@name",servername);
        StringBuffer node;
        queryMyNode()->endpoint().getIpText(node);
        root.setProp("@node",node.str());
        root.setPropInt("@mpport",queryMyNode()->endpoint().port);
        CDateTime dt;
        dt.setNow();
        StringBuffer str;
        root.setProp("@started",dt.getString(str).str());
        conn->commit();
    }
}

    void CleanFiles()
    {
        //DBGLOG("directory len %d and ext len: %d",Directory.length(),Ext.length());
        
        if (Directory.length() == 0 || Ext.length() == 0)
            return;

        CDateTime currentTime;
        currentTime.setNow();

        int fileCounter = 0;
//      DBGLOG("Directory:%s for files of ext:%s",Directory.str(), Ext.str());
        Owned<IDirectoryIterator> di = createDirectoryIterator(Directory.str(), Ext.str());
        ForEach (*di)
        {
            IFile &file = di->query();
        
            CDateTime createTime, modifiedTime,accessedTime;
            file.getTime( &createTime,  &modifiedTime, &accessedTime);

            StringBuffer accessedTimeStr,currentTimeStr;
            accessedTime.getString(accessedTimeStr);
        
            accessedTime.adjustTime(+m_CacheTimeoutPeriod);
            accessedTimeStr.clear();

            accessedTime.getString(accessedTimeStr);
            
            currentTime.getString(currentTimeStr);

            if (accessedTime.compare(currentTime) < 0)
            {
                const char* fileName = file.queryFilename();
                DBGLOG("Trying to remove:%s",fileName);
                if (file.exists() == true)
                {
                    fileCounter++;
                    bool bDeleteOk = file.remove();
                    if (!bDeleteOk)
                        WARNLOG("ERROR Removing old cache file %s",fileName);
                }
            }
        }
    }

void checkFile(IChecker *checker,IDistributedFile *file)
{
    StringBuffer tmp;
    checker->add("queryLogicalName",file->queryLogicalName());
    unsigned np = file->numParts();
    checker->add("numParts",np);
    checker->add("queryDefaultDir",file->queryDefaultDir());
    if (np>1)
        checker->add("queryPartMask",file->queryPartMask());
    checker->add("queryProperties()",toXML(&file->queryAttributes(),tmp.clear()).str());
    CDateTime dt;
    if (file->getModificationTime(dt))
        dt.getString(tmp.clear());
    else
        tmp.clear().append("nodatetime");

    // Owned<IFileDescriptor> desc = getFileDescriptor();
    // checkFileDescriptor(checker,desc);

    //virtual bool existsPhysicalPartFiles(unsigned short port) = 0;                // returns true if physical patrs all exist (on primary OR secondary)

    //Owned<IPropertyTree> tree = getTreeCopy();
    //checker->add("queryProperties()",toXML(tree,tmp.clear()).str());

    checker->add("getFileSize",file->getFileSize(false,false));
    bool blocked;
    checker->add("isCompressed",file->isCompressed(&blocked)?1:0);
    checker->add("blocked",blocked?1:0);
    unsigned csum;
    if (file->getFileCheckSum(csum)&&!blocked) 
        checker->add("getFileCheckSum",csum);
    else
        checker->add("getFileCheckSum","nochecksum");
    checker->add("isSubFile",file->isSubFile()?1:0);
    StringBuffer clustname;
    checker->add("queryClusterName(0)",file->getClusterName(0,clustname).str());
    for (unsigned i=0;i<np;i++) {
        Owned<IDistributedFilePart> part = file->getPart(i);
        if (part)
            checkFilePart(checker,part,blocked);
    }
        
}

    bool doSingleSwapNode(const char *oldip,const char *newip,unsigned nodenum,IPropertyTree *info,const char *timechecked)
    {
        if (doSwap(oldip,newip)) {
            if (info) {
                StringBuffer times(timechecked);
                if (times.length()==0) {
                    CDateTime dt;
                    dt.setNow();
                    dt.getString(times);
                }
                // TBD tie up with bad node in auto?

                IPropertyTree *swap = info->addPropTree("Swap",createPTree("Swap"));
                swap->setProp("@inNetAddress",newip);
                swap->setProp("@outNetAddress",oldip);
                swap->setProp("@time",times.str());
                if (UINT_MAX != nodenum)
                    swap->setPropInt("@rank",nodenum-1);
            }
            return true;
        }
        return false;
    }

   //---------------------------------------------------------------------------
   //  addTask
   //---------------------------------------------------------------------------
   IPropertyTree* addTask(IDeployTask& task)
   {
      // Get or add Component node
      IPropertyTree* compNode = addComponent(task.getCompName());
      assertex(compNode);

      // Get Tasks node
      IPropertyTree* tasksNode = compNode->queryPropTree("Tasks");
      assertex(tasksNode);

      // Add new task
      IPropertyTree* node = createPTree("Task");
      node->addProp("@action", task.getCaption());
      node->addProp("@source", task.getFileSpec(DT_SOURCE));
      node->addProp("@target", task.getFileSpec(DT_TARGET));

      CDateTime modifiedTime;
      Owned<IFile> pTargetFile = createIFile(task.getFileSpec(DT_TARGET));
      
      if (pTargetFile->getTime(NULL, &modifiedTime, NULL))
      {
         StringBuffer timestamp;
         modifiedTime.getString(timestamp);
         offset_t filesize = pTargetFile->size();

         node->addProp("@date", timestamp.str());
         node->addPropInt64("@size", filesize);
      }

      if (task.getErrorCode())
      {
         node->addProp("@error", task.getErrorString());
         compNode->setProp("@error", "true");
      }
      return tasksNode->addPropTree("Task", node);
   }

const char* CWSESPControlEx::readSessionTimeStamp(int t, StringBuffer& str)
{
    CDateTime time;
    time.set(t);
    return time.getString(str).str();
}