Namen in IStorage

Ein Eigenschaftensatz wird mit einem Formatbezeichner (FMTID) in der IPropertySetStorage Schnittstelle identifiziert. Im IStorage Schnittstelle wird ein Eigenschaftensatz mit einer mit Null beendeten Unicode-Zeichenfolge mit maximal 32 Zeichen benannt. Um die Interoperabilität zu aktivieren, muss eine Zuordnung zwischen einer FMTID und einer entsprechenden mit Null beendeten Unicode-Zeichenfolge eingerichtet werden.

Konvertieren eines Eigenschaftensatzes aus einer FMTID in einen Zeichenfolgennamen

Stellen Sie beim Konvertieren von einer FMTID in einen entsprechenden Unicode-Zeichenfolgennamen zuerst sicher, dass die FMTID ein bekannter Wert ist, der in der folgenden Tabelle aufgeführt ist. Wenn ja, verwenden Sie den entsprechenden bekannten Zeichenfolgennamen.

Wenn die FMTID kein bekannter Wert ist, verwenden Sie das folgende Verfahren, um einen Zeichenfolgennamen algorithmisch zu bilden.

To algorithmisch formieren einen Zeichenfolgennamen

1. Konvertieren Sie die FMTID bei Bedarf in eine Kleine-End-Byte-Reihenfolge.
2. Nehmen Sie die 128 Bits der FMTID und betrachten Sie sie als eine lange Bitzeichenfolge, indem Sie die einzelnen Bytes miteinander verketten. Das erste Bit des 128-Bit-Werts ist das am wenigsten signifikante Bit des ersten Byte im Arbeitsspeicher der FMTID; Das letzte Bit des 128-Bit-Werts ist das wichtigste Bit des letzten Byte im Speicher der FMTID. Erweitern Sie diese 128 Bit auf 130 Bit, indem Sie am Ende zwei Nullbits hinzufügen.
3. Dividieren Sie die 130 Bits in Gruppen von fünf Bits; es werden 26 solche Gruppen vorhanden sein. Betrachten Sie jede Gruppe als ganze Zahl mit umgekehrter Bitrangfolge. Beispielsweise ist die erste der 128 Bits das geringste signifikante Bit der ersten Gruppe von fünf Bits; Der fünfte der 128 Bits ist das wichtigste Bit der ersten Gruppe.
4. Ordnen Sie jede dieser ganzzahligen Zahlen als Index dem Array von dreißig zwei Zeichen zu: ABCDEFGHIJKLMNOPQRSTUVWXYZ012345. Dadurch wird eine Abfolge von 26 Unicode-Zeichen erzielt, die nur Großbuchstaben und Ziffern verwenden. Die Groß- und Kleinschreibung wird nicht berücksichtigt, sodass jedes Zeichen in jedem Gebietsschema eindeutig ist.
5. Erstellen Sie die endgültige Zeichenfolge, indem Sie die Zeichenfolge "\005" an die Vorderseite dieser 26 Zeichen verketten, 27 Zeichen lang.

Der folgende Beispielcode zeigt, wie eine FMTID einer Eigenschaftszeichenfolge zugeordnet wird.

#define CBIT_BYTE        8
#define CBIT_CHARMASK    5
#define CCH_MAP          (1 << CBIT_CHARMASK)    // 32
#define CHARMASK         (CCH_MAP - 1)           // 0x1f
 
CHAR awcMap[CCH_MAP + 1] = "abcdefghijklmnopqrstuvwxyz012345";
 
WCHAR MapChar(ULONG I) {
    return((WCHAR) awcMap[i & CHARMASK]);
    }
 
VOID GuidToPropertyStringName(GUID *pguid, WCHAR awcname[]) {
    BYTE *pb = (BYTE *) pguid;
    BYTE *pbEnd = pb + sizeof(*pguid);
    ULONG cbitRemain = CBIT_BYTE;
    WCHAR *pwc = awcname;
 
    *pwc++ = ((WCHAR) 0x0005);
    while (pb < pbEnd) {
        ULONG i = *pb >> (CBIT_BYTE - cbitRemain);
        if (cbitRemain >= CBIT_CHARMASK) {
            *pwc = MapChar(i);
            if (cbitRemain == CBIT_BYTE && 
                                    *pwc >= L'a' && *pwc <= L'z')
                {
                *pwc += (WCHAR) (L'A' - L'a');
                }
            pwc++;
            cbitRemain -= CBIT_CHARMASK;
            if (cbitRemain == 0) {
                pb++;
                cbitRemain = CBIT_BYTE;
                }
            }
        else {
            if (++pb < pbEnd) {
                i |= *pb << cbitRemain;
                }
            *pwc++ = MapChar(i);
            cbitRemain += CBIT_BYTE - CBIT_CHARMASK;
            }
        }
    *pwc = L'\0';
    }

Konvertieren eines Eigenschaftensatzes aus einem Zeichenfolgennamen in eine FMTID

Konverter von Eigenschaftszeichenfolgennamen in GUIDs sollten Kleinbuchstaben als Synonym für ihre Großbuchstaben akzeptieren.

Im folgenden Beispielcode wird gezeigt, wie sie von einer Eigenschaftszeichenfolge zu einer FMTID zuordnen.

#include "stdafx.h"
#define _INC_OLE
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define CBIT_CHARMASK 5
#define CBIT_BYTE     8
#define CBIT_GUID    (CBIT_BYTE * sizeof(GUID))
#define CWC_PROPSET  (1 + (CBIT_GUID + CBIT_CHARMASK-1)/CBIT_CHARMASK)
#define WC_PROPSET0  ((WCHAR) 0x0005)
#define CCH_MAP      (1 << CBIT_CHARMASK)        // 32
#define CHARMASK     (CCH_MAP - 1)            // 0x1f
CHAR awcMap[CCH_MAP + 1] = "abcdefghijklmnopqrstuvwxyz012345";
#define CALPHACHARS  ('z' - 'a' + 1)

GUID guidSummary =
{ 0xf29f85e0,0x4ff9, 0x1068,
{ 0xab, 0x91, 0x08, 0x00, 0x2b, 0x27, 0xb3, 0xd9 } };

WCHAR wszSummary[] = L"SummaryInformation";

GUID guidDocumentSummary =
    { 0xd5cdd502,
      0x2e9c, 0x101b,
      { 0x93, 0x97, 0x08, 0x00, 0x2b, 0x2c, 0xf9, 0xae } };

WCHAR wszDocumentSummary[] = L"DocumentSummaryInformation";
__inline WCHAR

MapChar(IN ULONG i)
{
    return((WCHAR) awcMap[i & CHARMASK]);
}

ULONG PropertySetNameToGuid(
    IN ULONG cwcname,
    IN WCHAR const awcname[],
    OUT GUID *pguid)
{
    ULONG Status = ERROR_INVALID_PARAMETER;
    WCHAR const *pwc = awcname;

    if (pwc[0] == WC_PROPSET0)
    {
        //Note: cwcname includes the WC_PROPSET0, and
        //sizeof(wsz...) includes the trailing L'\0', but
        //the comparison excludes both the leading
        //WC_PROPSET0 and the trailing L'\0'.
        if (cwcname == sizeof(wszSummary)/sizeof(WCHAR) &&
            wcsnicmp(&pwc[1], wszSummary, cwcname - 1) == 0)
        {
            *pguid = guidSummary;
            return(NO_ERROR);
        }
        if (cwcname == CWC_PROPSET)
        {
            ULONG cbit;
            BYTE *pb = (BYTE *) pguid - 1;
            ZeroMemory(pguid, sizeof(*pguid));
            for (cbit = 0; cbit < CBIT_GUID; cbit += 
            CBIT_CHARMASK)
            {
                ULONG cbitUsed = cbit % CBIT_BYTE;
                ULONG cbitStored;
                WCHAR wc;
                if (cbitUsed == 0)
                {
                    pb++;
                }
                wc = *++pwc - L'A';        //assume uppercase
                if (wc > CALPHACHARS)
                {
                    wc += (WCHAR) (L'A' - L'a'); //try lowercase
                    if (wc > CALPHACHARS)
                    {
                        wc += L'a' - L'0' + CALPHACHARS; 
                        if (wc > CHARMASK)
                        {
                            goto fail;       //invalid character
                        }
                    }
                }
                *pb |= (BYTE) (wc << cbitUsed);
                cbitStored = min(CBIT_BYTE - cbitUsed, 
                CBIT_CHARMASK);

                //If the translated bits will not fit in the 
                //current byte
                if (cbitStored < CBIT_CHARMASK)
                {
                    wc >>= CBIT_BYTE - cbitUsed;
                    if (cbit + cbitStored == CBIT_GUID)
                    {
                       if (wc != 0)
                       {
                           goto fail;        //extra bits
                       }
                       break;
                    }
                    pb++;
                    *pb |= (BYTE) wc;
                }
           }
           Status = NO_ERROR;
      }
    }
fail:
    return(Status);
}

Beim Versuch, einen vorhandenen Eigenschaftensatz zu öffnen, wird in IPropertySetStorage::Opendie FMTID (Stamm)-FMTID wie oben beschrieben in eine Zeichenfolge konvertiert. Wenn ein Element der IStorage dieses Namens vorhanden ist, wird es verwendet. Andernfalls schlägt das Öffnen fehl.

Beim Erstellen eines neuen Eigenschaftensatzes bestimmt die obige Zuordnung den verwendeten Zeichenfolgennamen.