home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / warphead.zip / H / CMAPI.H < prev    next >
C/C++ Source or Header  |  1997-02-28  |  15KB  |  313 lines
  1. /* @(#)Z 1.4 com/src/cm/CMAPI.h, odstorage, od96os2, odos29646d 96/11/15 15:26:40 (96/10/29 09:15:50) */
  2. /*====START_GENERATED_PROLOG======================================
  3.  */
  4. /*
  5.  *   COMPONENT_NAME: odstorage
  6.  *
  7.  *   CLASSES: none
  8.  *
  9.  *   ORIGINS: 82,27
  10.  *
  11.  *
  12.  *   (C) COPYRIGHT International Business Machines Corp. 1995,1996
  13.  *   All Rights Reserved
  14.  *   Licensed Materials - Property of IBM
  15.  *   US Government Users Restricted Rights - Use, duplication or
  16.  *   disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  17.  *       
  18.  *   IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  19.  *   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20.  *   PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  21.  *   CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  22.  *   USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  23.  *   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
  24.  *   OR PERFORMANCE OF THIS SOFTWARE.
  25.  */
  26. /*====END_GENERATED_PROLOG========================================
  27.  */
  28.  
  29. /*
  30.     File:        CMAPI.h
  31.  
  32.     Contains:    Container Manager API
  33.  
  34.     Owned by:    Ira L. Ruben
  35.  
  36.     Owned by:    Ed Lai
  37.  
  38.     Copyright:    ⌐ 1994-95 by Apple Computer, Inc., all rights reserved.
  39.  
  40.     Change History (most recent first):
  41.  
  42.          <5>     5/25/95    jpa        Changed last param of CMOpenNewContainer
  43.                                     for ANSI/CFM68K compatibility. [1241078]
  44.          <4>     3/31/95    EL        1234685: Add CMContainsValidLabel.
  45.          <3>     3/24/95    EL        1209355: add CMTakeSnapShot.
  46.          <2>     8/26/94    EL        #1181622 Ownership update.
  47.          <2>     3/31/94    EL        Add CMMergeContainer call. #1150214
  48.          <8>     3/17/94    EL        Add CMKeepObject call.
  49.          <7>     12/7/93    EL        Add CMGetReferenceForObject call.
  50.          <6>    11/10/93    EL        Add CMCountProperties call.
  51.          <5>     10/6/93    EL        Add CMGetPrevXXXX.
  52.          <4>     9/27/93    VL        Added CMGetPrevObjectProperty and
  53.                                                     CMGetPrevValue.
  54.          <3>      9/8/93    VL        Added GetObject and GetObjectID.
  55.  
  56.     To Do:
  57.     In Progress:
  58.         
  59. */
  60.  
  61. /* (use tabs = 2 to view this file correctly) */
  62. /*---------------------------------------------------------------------------*
  63.  |                                                                           |
  64.  |                             <<< CM_API.h >>>                              |
  65.  |                                                                           |
  66.  |                           Container Manager API                           |
  67.  |                                                                           |
  68.  |                               Ira L. Ruben                                |
  69.  |                                 11/18/91                                  |
  70.  |                                                                           |
  71.  |                  Copyright Apple Computer, Inc. 1991-1995                 |
  72.  |                           All rights reserved.                            |
  73.  |                                                                           |
  74.  *---------------------------------------------------------------------------*
  75.  
  76.  This is the Container Manager API definitions.  All routines needed to communicate with
  77.  the Container Manager are defined here.  This is the only explicit #include needed. All
  78.  other required headers are included from here.
  79.  
  80.  Refer to Container Manager API documentation for details on these routines.
  81.  
  82.  
  83.                                               *------------------------------*
  84.                                                 | NOTE TO DOS (80x86) USERS... |
  85.                                                 *------------------------------*
  86.  
  87.  The Container Manager should be compiled with the "large" memory model so that all
  88.  routines, pointers, etc. are "far".  All external API interfaces are appropriately
  89.  qualified this way.  Since handlers are implementation or user dependent, these files
  90.  must be compiled with the large memory model.  The only exception is local static
  91.  routines which usually can be qualified with "near" (except, of course, for handlers).
  92.  
  93.  This file uses the function and pointer memory model attribute macros defined
  94.  CM_API_Environment.h.  See that file for further details.
  95. */
  96.  
  97. #ifndef __CM_API__
  98. #define __CM_API__
  99.  
  100. #include <stdarg.h>
  101. #include <stdio.h>
  102.  
  103. #ifndef __CM_API_ENV__
  104. #include "CMAPIEnv.h"                                                    /* Environment-specific definitions                */
  105. #endif
  106. #ifndef __CM_API_TYPES__
  107. #include "CMAPITyp.h"                                                    /* API type definitions                                        */
  108. #endif
  109. #ifndef __CM_API_STDOBJIDS__
  110. #include "CMAPIIDs.h"                                                    /* Standard object ID definitions, etc.        */
  111. #endif
  112. #ifndef __CM_API_ERRNO__
  113. #include "CMAPIErr.h"                                                /* Error code numbers and their meaning        */
  114. #endif
  115.  
  116.  
  117.                                                                 CM_CFUNCTIONS
  118.                                                                 
  119. /*---------------------------*
  120.  | Session (task) operations |
  121.  *---------------------------*/
  122.  
  123. CMSession CM_FIXEDARGS CMStartSession(CMMetaHandler metaHandler, CMRefCon sessionRefCon);
  124. void CM_FIXEDARGS CMEndSession(CMSession sessionData, CMBoolean closeOpenContainers);
  125. void CM_FIXEDARGS CMAbortSession(CMSession sessionData);
  126. CMRefCon CM_FIXEDARGS CMGetSessionRefCon(CMContainer container);
  127. void CM_FIXEDARGS CMSetSessionRefCon(CMContainer container, CMRefCon refCon);
  128.  
  129.  
  130. /*--------------------*
  131.  | Handler Operations |
  132.  *--------------------*/
  133.  
  134. CMHandlerAddr CM_FIXEDARGS CMSetMetaHandler(CMconst_CMSession sessionData,
  135.                                                                                         CMconst_CMGlobalName typeName,
  136.                                                                                           CMMetaHandler metaHandler);
  137. CMHandlerAddr CM_FIXEDARGS CMGetMetaHandler(CMconst_CMSession sessionData,
  138.                                                                                         CMconst_CMGlobalName typeName);
  139. CMHandlerAddr CM_FIXEDARGS CMGetOperation(CMType targetType,
  140.                                                                                     CMconst_CMGlobalName operationType);
  141.  
  142.  
  143. /*----------------------*
  144.  | Container Operations |
  145.  *----------------------*/
  146.  
  147. CMContainer CM_FIXEDARGS CMOpenContainer(CMSession sessionData,
  148.                                                                                  CMRefCon attributes,
  149.                                                                                  CMconst_CMGlobalName typeName, 
  150.                                                                                  CMContainerUseMode useFlags);
  151. CMContainer CM_VARARGS CMOpenNewContainer(CMSession sessionData,
  152.                                                                                     CMRefCon attributes,
  153.                                                                                     CMconst_CMGlobalName typeName, 
  154.                                                                                     CMContainerUseMode useFlags,
  155.                                                                                     CMGeneration generation,
  156.                                                                                 /*CMContainerFlags*/ CM_ULONG containerFlags, ...);
  157. CMContainer CM_FIXEDARGS CMVOpenNewContainer(CMSession sessionData,
  158.                                                                                          CMRefCon attributes,
  159.                                                                                          CMconst_CMGlobalName typeName, 
  160.                                                                                          CMContainerUseMode useFlags,
  161.                                                                                          CMGeneration generation,
  162.                                                                                          CMContainerFlags containerFlags,
  163.                                                                                          va_list targetTypeInitParams);
  164. void CM_FIXEDARGS CMCloseContainer(CMconst_CMContainer container);
  165. void CM_FIXEDARGS CMAbortContainer(CMconst_CMContainer container);
  166. void CM_FIXEDARGS CMMergeContainer(CMconst_CMContainer container, CMValue targetValue);
  167. void CM_FIXEDARGS CMGetContainerInfo(CMconst_CMContainer container,
  168.                                                                          CMGeneration CM_PTR *generation, 
  169.                                                                          CM_USHORT CM_PTR *bufSize,
  170.                                                                          CMContainerFlags CM_PTR *containerFlags,
  171.                                                                          CMGlobalName typeName,
  172.                                                                          CMContainerModeFlags CM_PTR *openMode);
  173. CMSession CM_FIXEDARGS CMGetSession(CMContainer container);
  174. void CM_FIXEDARGS CMTakeSnapShot(CMconst_CMContainer container, CMBoolean includeEmbedded);
  175.  
  176.  
  177. /*------------------------------*
  178.  | Type and Property Operations |
  179.  *------------------------------*/
  180.  
  181. CMType CM_FIXEDARGS CMRegisterType(CMContainer targetContainer, CMconst_CMGlobalName name);
  182. CMProperty CM_FIXEDARGS CMRegisterProperty(CMContainer targetContainer,
  183.                                                                                      CMconst_CMGlobalName name);
  184. CMCount CM_FIXEDARGS CMAddBaseType(CMType type, CMType baseType);
  185. CMCount CM_FIXEDARGS CMRemoveBaseType(CMType type, CMType baseType);
  186. CMBoolean CM_FIXEDARGS CMIsType(CMObject theObject);
  187. CMBoolean CM_FIXEDARGS CMIsProperty(CMObject theObject);
  188. CMType CM_FIXEDARGS CMGetNextType(CMContainer targetContainer, CMType currType);
  189. CMType CM_FIXEDARGS CMGetPrevType(CMContainer targetContainer, CMType currType);
  190. CMProperty CM_FIXEDARGS CMGetNextProperty(CMContainer targetContainer,
  191.                                                                                     CMProperty currProperty);
  192. CMProperty CM_FIXEDARGS CMGetPrevProperty(CMContainer targetContainer,
  193.                                                                                     CMProperty currProperty);
  194.  
  195.  
  196. /*-------------------*
  197.  | Object Operations |
  198.  *-------------------*/
  199.  
  200. CMObject CM_FIXEDARGS CMNewObject(CMContainer targetContainer);
  201. CMObject CM_FIXEDARGS CMGetNextObject(CMContainer targetContainer, CMObject currObject);
  202. CMObject CM_FIXEDARGS CMGetPrevObject(CMContainer targetContainer, CMObject currObject);
  203. CMProperty CM_FIXEDARGS CMGetNextObjectProperty(CMObject theObject, CMProperty currProperty);
  204. CMProperty CM_FIXEDARGS CMGetPrevObjectProperty(CMObject theObject, CMProperty currProperty);
  205. CMObject CM_FIXEDARGS CMGetNextObjectWithProperty(CMContainer targetContainer,
  206.                                                                                                     CMObject currObject, CMProperty property);
  207. CMObject CM_FIXEDARGS CMGetPrevObjectWithProperty(CMContainer targetContainer,
  208.                                                                                                     CMObject currObject, CMProperty property);
  209. CMContainer CM_FIXEDARGS CMGetObjectContainer(CMObject theObject);
  210. CMGlobalName CM_FIXEDARGS CMGetGlobalName(CMObject theObject);
  211. CMCount CM_FIXEDARGS CMCountProperties(CMObject object, CMProperty property);
  212. CMRefCon CM_FIXEDARGS CMGetObjectRefCon(CMObject theObject);
  213. void CM_FIXEDARGS CMSetObjectRefCon(CMObject theObject, CMRefCon refCon);
  214. void CM_FIXEDARGS CMDeleteObject(CMObject theObject);
  215. void CM_FIXEDARGS CMDeleteObjectProperty(CMObject theObject, CMProperty theProperty);
  216. void CM_FIXEDARGS CMReleaseObject(CMObject theObject);
  217. void CM_FIXEDARGS CMKeepObject(CMObject theObject);
  218. CMObject CM_FIXEDARGS CMGetObject(CMContainer targetContainer, CMObjectID objectID);
  219. CMObjectID CM_FIXEDARGS CMGetObjectID(CMObject object);
  220.  
  221.  
  222. /*------------------*
  223.  | Value Operations |
  224.  *------------------*/
  225.  
  226. CMCount CM_FIXEDARGS CMCountValues(CMObject object, CMProperty property, CMType type);
  227. CMValue CM_FIXEDARGS CMUseValue(CMObject object, CMProperty property, CMType type);
  228. CMValue CM_FIXEDARGS CMGetNextValue(CMObject object, CMProperty property, CMValue currValue);
  229. CMValue CM_FIXEDARGS CMGetPrevValue(CMObject object, CMProperty property, CMValue currValue);
  230. CMValue CM_VARARGS CMNewValue(CMObject object, CMProperty property, CMType type, ...);
  231. CMValue CM_FIXEDARGS CMVNewValue(CMObject object, CMProperty property, CMType type,
  232.                                                                   va_list dataInitParams);
  233. CMValue CM_FIXEDARGS CMGetBaseValue(CMValue value);
  234. CMSize CM_FIXEDARGS CMGetValueSize(CMValue value);
  235. CMSize CM_FIXEDARGS CMReadValueData(CMValue value, CMPtr buffer, CMCount offset, CMSize maxSize);
  236. void CM_FIXEDARGS CMWriteValueData(CMValue value, CMPtr buffer, CMCount offset, CMSize size);
  237. void CM_FIXEDARGS CMDefineValueData(CMValue value, CMCount offset, CMSize size);
  238. void CM_FIXEDARGS CMInsertValueData(CMValue value, CMPtr buffer, CMCount offset, CMSize size);
  239. void CM_FIXEDARGS CMDeleteValueData(CMValue value, CMCount offset, CMSize size);
  240. void CM_FIXEDARGS CMMoveValue(CMValue value, CMObject object, CMProperty property);
  241. void CM_FIXEDARGS CMGetValueInfo(CMValue value, CMContainer CM_PTR *container,
  242.                                                                  CMObject CM_PTR *object, CMProperty CM_PTR *property,
  243.                                                                  CMType CM_PTR *type, CMGeneration CM_PTR *generation);
  244. void CM_FIXEDARGS CMSetValueType(CMValue value, CMType type);
  245. void CM_FIXEDARGS CMSetValueGeneration(CMValue value, CMGeneration generation);
  246. CMContainer CM_FIXEDARGS CMGetValueContainer(CMValue value);
  247. CMRefCon CM_FIXEDARGS CMGetValueRefCon(CMValue value);
  248. void CM_FIXEDARGS CMSetValueRefCon(CMValue value, CMRefCon refCon);
  249. void CM_FIXEDARGS CMDeleteValue(CMValue value);
  250. void CM_FIXEDARGS CMReleaseValue(CMValue value);
  251. CMBoolean CM_FIXEDARGS CMContainsValidLabel(CMValue value);
  252.  
  253.  
  254. /*----------------------*
  255.  | Reference Operations |
  256.  *----------------------*/
  257.  
  258. CMReference CM_PTR * CM_FIXEDARGS CMNewReference(CMValue value,
  259.                                                                                                  CMObject referencedObject,
  260.                                                                                                   CMReference CM_PTR theReferenceData);
  261. CMReference CM_PTR * CM_FIXEDARGS CMSetReference(CMValue value,
  262.                                                                                                  CMObject referencedObject,
  263.                                                                                                   CMReference CM_PTR theReferenceData);
  264. CMObject CM_FIXEDARGS CMGetReferencedObject(CMValue value, CMReference CM_PTR theReferenceData);
  265. CMReference CM_PTR * CM_FIXEDARGS CMGetReferenceForObject(CMValue value, 
  266.                                                                                                                      CMObject referencedObject,
  267.                                                                                                                     CMReference CM_PTR theReferenceData);
  268. void CM_FIXEDARGS CMDeleteReference(CMValue value, CMReference CM_PTR theReferenceData);
  269. CMCount CM_FIXEDARGS CMCountReferences(CMValue value);
  270. CMReference CM_PTR * CM_FIXEDARGS CMGetNextReference(CMValue value,
  271.                                                                                                          CMReference CM_PTR currReferenceData);
  272. CMReference CM_PTR * CM_FIXEDARGS CMGetPrevReference(CMValue value,
  273.                                                                                                          CMReference CM_PTR currReferenceData);
  274.  
  275.  
  276. /*--------------------------*
  277.  | Value Handler Operations |
  278.  *--------------------------*/
  279.  
  280. CMCount CM_VARARGS CMScanDataPacket(CMType type, CMMetaData metaData,
  281.                                                                         CMDataPacket dataPacket, ...);
  282. CMCount CM_FIXEDARGS CMVScanDataPacket(CMType type, CMMetaData metaData,
  283.                                                                              CMDataPacket dataPacket,
  284.                                                                               va_list dataInitParams);
  285.  
  286.  
  287. /*--------------------------*
  288.  | Error Handler Operations |
  289.  *--------------------------*/
  290.  
  291. char CM_PTR * CM_VARARGS CMAddMsgInserts(char CM_PTR *msgString, CMSize maxLength, ...);
  292. char CM_PTR * CM_FIXEDARGS CMVAddMsgInserts(char CM_PTR *msgString, CMSize maxLength,
  293.                                                                                       va_list inserts);
  294. CMErrorString CM_VARARGS CMGetErrorString(CMErrorString errorString, CMSize maxLength, 
  295.                                                                                       CMErrorNbr errorNumber, ...);
  296. CMErrorString CM_FIXEDARGS CMVGetErrorString(CMErrorString errorString, CMSize maxLength, 
  297.                                                                                         CMErrorNbr errorNumber, va_list inserts);
  298. char CM_PTR * CM_FIXEDARGS CMReturnContainerName(CMContainer container);
  299.  
  300.  
  301. /*--------------------------------*
  302.  | Special Environment Operations |
  303.  *--------------------------------*/
  304.  
  305. void CM_PTR * CM_FIXEDARGS CMMalloc(CMSize size, CMSession sessionData);
  306. void CM_FIXEDARGS CMFree(CMPtr ptr, CMSession sessionData);
  307. void CM_VARARGS CMError(CMSession sessionData, CMErrorString message, ...);
  308. void CM_FIXEDARGS CMVError(CMSession sessionData, CMErrorString message, va_list inserts);
  309.  
  310.                                                         CM_END_CFUNCTIONS
  311.  
  312. #endif
  313.