C++ SCXHandle::IsTotal方法代码示例

MI_BEGIN_NAMESPACE

static void EnumerateOneInstance(
    Context& context,
    SCX_MemoryStatisticalInformation_Class& inst,
    bool keysOnly,
    SCXCoreLib::SCXHandle<SCXSystemLib::MemoryInstance> meminst)
{
    // Populate the key values
    inst.Name_value("Memory");

    if (!keysOnly)
    {
        scxulong physmem = 0;
        scxulong resmem = 0;
        scxulong usermem = 0;
        scxulong avail = 0;
        scxulong data = 0;
        scxulong data2 = 0;

        inst.Caption_value("Memory information");
        inst.Description_value("Memory usage and performance statistics");

        inst.IsAggregate_value(meminst->IsTotal());

        if (meminst->GetTotalPhysicalMemory(physmem))
        {
            // Adjust numbers from PAL to Megabytes
            physmem = BytesToMegaBytes(physmem);

            if (meminst->GetReservedMemory(resmem))
            {
                resmem = BytesToMegaBytes(resmem);
            }
            else
            {
                resmem = 0;
            }

            // If available, get memory unavailable for user processes and remove it from physical memory
            usermem = physmem - resmem;
        }

        if (meminst->GetAvailableMemory(avail))
        {
            // Adjust numbers from PAL to Megabytes
            avail = BytesToMegaBytes(avail);
            inst.AvailableMemory_value(avail);

            // If we have a number for physical memory use it to compute a percentage
            if (usermem > 0)
            {
                // Need an unsigned char since this is what is required by the MOF
                unsigned char percent = static_cast<unsigned char> (GetPercentage(0, avail, 0, usermem));
                inst.PercentAvailableMemory_value(percent);
            }
        }

        if (meminst->GetUsedMemory(data))
        {
            // Adjust numbers from PAL to Megabytes
            data = BytesToMegaBytes(data);
            inst.UsedMemory_value(data);

            // If we have a number for physical memory use it to compute a percentage
            if (usermem > 0)
            {
                unsigned char percent = static_cast<unsigned char> (GetPercentage(0, data, 0, usermem));
                inst.PercentUsedMemory_value(percent);
            }
        }

        {
            data = 0;
            unsigned char percent = static_cast<unsigned char> (0);

            if (meminst->GetCacheSize(data) && usermem > 0)
            {
                percent = static_cast<unsigned char> (GetPercentage(0, BytesToMegaBytes(data), 0, usermem));
            }
            inst.PercentUsedByCache_value(percent);
        }

        bool pageReadsAvailable = meminst->GetPageReads(data);
        bool pageWritesAvailable = meminst->GetPageWrites(data2);
        if (pageReadsAvailable && pageWritesAvailable)
        {
            inst.PagesPerSec_value(data + data2);
        }

        if (pageReadsAvailable)
        {
            inst.PagesReadPerSec_value(data);
        }

        if (pageWritesAvailable)
        {
            inst.PagesWrittenPerSec_value(data2);
        }

//.........这里部分代码省略.........

    /**
       Set all properties from the CPUInstance in the SCXInstance

       \param[in]  cpuinst - CPU instance to get data from
       \param[in]  inst    - Instance to populate

       \throws      SCXInvalidArgumentException - If the instance can not be converted to a CPUInstance

       This method knows how to map the values of the CPU PAL to the CMPI class
       definition.

    */
    void CPUProvider::AddProperties(SCXCoreLib::SCXHandle<SCXSystemLib::CPUInstance> cpuinst, SCXInstance &inst) // private
    {
        scxulong data;

        if (cpuinst == NULL)
        {
            throw SCXInvalidArgumentException(L"einst", L"Not a CPUInstance", SCXSRCLOCATION);
        }

        SCX_LOGTRACE(m_log, L"CPUProvider AddPropeties()");

        SCXProperty total_prop(L"IsAggregate", cpuinst->IsTotal());
        inst.AddProperty(total_prop);

        if (cpuinst->GetProcessorTime(data))
        {
            SCXProperty data_prop(L"PercentProcessorTime", static_cast<unsigned char> (data));
            inst.AddProperty(data_prop);
        }

        if (cpuinst->GetIdleTime(data))
        {
            SCXProperty data_prop(L"PercentIdleTime", static_cast<unsigned char> (data));
            inst.AddProperty(data_prop);
        }

        if (cpuinst->GetUserTime(data))
        {
            SCXProperty data_prop(L"PercentUserTime", static_cast<unsigned char> (data));
            inst.AddProperty(data_prop);
        }

        if (cpuinst->GetNiceTime(data))
        {
            SCXProperty data_prop(L"PercentNiceTime", static_cast<unsigned char> (data));
            inst.AddProperty(data_prop);
        }

        if (cpuinst->GetPrivilegedTime(data))
        {
            SCXProperty data_prop(L"PercentPrivilegedTime", static_cast<unsigned char> (data));
            inst.AddProperty(data_prop);
        }

        if (cpuinst->GetIowaitTime(data))
        {
            SCXProperty data_prop(L"PercentIOWaitTime", static_cast<unsigned char> (data));
            inst.AddProperty(data_prop);
        }

        if (cpuinst->GetInterruptTime(data))
        {
            SCXProperty data_prop(L"PercentInterruptTime", static_cast<unsigned char> (data));
            inst.AddProperty(data_prop);
        }

        if (cpuinst->GetDpcTime(data))
        {
            SCXProperty data_prop(L"PercentDPCTime", static_cast<unsigned char> (data));
            inst.AddProperty(data_prop);
        }

    }