static void EnumerateOneInstance()

in source/code/providers/SCX_FileSystem_Class_Provider.cpp [33:147]
87 lines of code
18 McCabe index (conditional complexity)

static void EnumerateOneInstance(
    Context& context,
    SCX_FileSystem_Class& inst,
    bool keysOnly,
    SCXHandle<SCXSystemLib::StaticLogicalDiskInstance> diskinst)
{
    SCXCoreLib::NameResolver nr;
    std::wstring hostname = nr.GetHostDomainname();

    diskinst->Update();

    std::wstring name;
    if (diskinst->GetDeviceName(name)) 
    {
        inst.Name_value(StrToMultibyte(name).c_str());
    }

    inst.CreationClassName_value("SCX_FileSystem");
    inst.CSCreationClassName_value("SCX_ComputerSystem");
    inst.CSName_value(StrToMultibyte(hostname).c_str());

    if (!keysOnly) 
    {
        inst.Caption_value("File system information");
        inst.Description_value("Information about a logical unit of secondary storage");

        scxulong data;
        std::wstring sdata;
        bool bdata;

        if (diskinst->GetHealthState(bdata)) 
        {
            inst.IsOnline_value(bdata);
        }

        if (diskinst->GetMountpoint(sdata)) 
        {
            inst.Root_value(StrToMultibyte(sdata).c_str());
        }

        if (diskinst->GetFileSystemType(sdata)) 
        {
            inst.FileSystemType_value(StrToMultibyte(sdata).c_str());
        }

        if (diskinst->GetSizeInBytes(data)) 
        {
            inst.FileSystemSize_value(data);
        }

        if (diskinst->GetCompressionMethod(sdata)) 
        {
            inst.CompressionMethod_value(StrToMultibyte(sdata).c_str());
        }

        if (diskinst->GetIsReadOnly(bdata)) 
        {
            inst.ReadOnly_value(bdata);
        }

        if (diskinst->GetEncryptionMethod(sdata)) 
        {
            inst.EncryptionMethod_value(StrToMultibyte(sdata).c_str());
        }

        int idata;
        if (diskinst->GetPersistenceType(idata)) 
        {
            inst.PersistenceType_value(static_cast<unsigned short>(idata));
        }

        if (diskinst->GetBlockSize(data)) 
        {
            inst.BlockSize_value(data);
        }

        if (diskinst->GetAvailableSpaceInBytes(data)) 
        {
            inst.AvailableSpace_value(data);
        }
                         
        scxulong inodesTotal, inodesFree;
        if (diskinst->GetTotalInodes(inodesTotal) && diskinst->GetAvailableInodes(inodesFree)) 
        {
            inst.TotalInodes_value(inodesTotal);
            inst.FreeInodes_value(inodesFree);
            inst.NumberOfFiles_value(inodesTotal - inodesFree);
        }

        if (diskinst->GetIsCaseSensitive(bdata)) 
        {
            inst.CaseSensitive_value(bdata);
        }

        if (diskinst->GetIsCasePreserved(bdata)) 
        {
            inst.CasePreserved_value(bdata);
        }
        
        /*
          if (diskinst->GetCodeSet(idata))
          {
          Uint16A tmp;
          tmp[0] = (Uint16)idata;
          inst.CodeSet_value(tmp);
          }
        */

        if (diskinst->GetMaxFilenameLen(data)) 
        {
            inst.MaxFileNameLength_value(static_cast<unsigned int>(data));
        }
    }
    context.Post(inst);
}