source: icXML/icXML-devel/src/icxercesc/util/PlatformUtils.hpp

Last change on this file was 3178, checked in by cameron, 6 years ago

Penultimate check-in for icXML 0.9

File size: 32.0 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: PlatformUtils.hpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_PLATFORMUTILS_HPP)
23#define XERCESC_INCLUDE_GUARD_PLATFORMUTILS_HPP
24
25#include <xercesc/util/XercesDefs.hpp>
26#include <xercesc/util/XMLException.hpp>
27#include <xercesc/util/PanicHandler.hpp>
28
29#include <xercesc/util/XMLFileMgr.hpp>
30#include <xercesc/util/XMLMutexMgr.hpp>
31
32XERCES_CPP_NAMESPACE_BEGIN
33
34class XMLMsgLoader;
35class XMLNetAccessor;
36class XMLTransService;
37class MemoryManager;
38class XMLMutex;
39
40//
41//  For internal use only
42//
43//  This class provides a simple abstract API via which lazily evaluated
44//  data can be cleaned up.
45//
46class XMLUTIL_EXPORT XMLDeleter
47{
48public :
49    virtual ~XMLDeleter();
50
51protected :
52    XMLDeleter();
53
54private :
55    XMLDeleter(const XMLDeleter&);
56    XMLDeleter& operator=(const XMLDeleter&);
57};
58
59
60/**
61  * Utilities that must be implemented in a platform-specific way.
62  *
63  * This class contains methods that must be implemented in a platform
64  * specific manner. The actual implementations of these methods are
65  * available in the per-platform files inside <code>src/util/Platforms
66  * </code>.
67  */
68class XMLUTIL_EXPORT XMLPlatformUtils
69{
70public :
71
72    /** @name Public Static Data */
73    //@{
74
75    /** The network accessor
76      *
77      * This is provided by the per-platform driver, so each platform can
78      * choose what actual implementation it wants to use. The object must
79      * be dynamically allocated.
80      *
81      * <i>Note that you may optionally, if your platform driver does not
82      * install a network accessor, set it manually from your client code
83      * after calling Initialize(). This works because this object is
84      * not required during initialization, and only comes into play during
85      * actual XML parsing.</i>
86      */
87    static XMLNetAccessor*      fgNetAccessor;
88
89    /** The transcoding service.
90      *
91      * This is provided by the per platform driver, so each platform can
92      * choose what implementation it wants to use. When the platform
93      * independent initialization code needs to get a transcoding service
94      * object, it will call <code>makeTransService()</code> to ask the
95      * per-platform code to create one. Only one transcoding service
96      * object is requested per-process, so it is shared and synchronized
97      * among parser instances within that process.
98      */
99    static XMLTransService*     fgTransService;
100#ifdef OS390
101    static XMLTransService*     fgTransService2;
102#endif
103
104    /** The Panic Handler
105      *
106      *   This is the application provided panic handler.
107      */
108    static PanicHandler*        fgUserPanicHandler;
109
110    /** The Panic Handler
111      *
112      *   This is the default panic handler.
113      */
114    static PanicHandler*        fgDefaultPanicHandler;
115
116    /** The configurable memory manager
117      *
118      *   This is the pluggable memory manager. If it is not provided by an
119      *   application, a default implementation is used.
120      */
121    static MemoryManager*       fgMemoryManager;
122
123    static XMLFileMgr*          fgFileMgr;
124    static XMLMutexMgr*         fgMutexMgr;
125
126    /** Global mutex for fast or infrequent operations.
127      *
128      *   Use this mutex only for fast (e.g., increment an integer,
129      *   check flag, etc.) or infrequent (e.g., once-off initialization)
130      *   operations.
131      */
132    static XMLMutex*            fgAtomicMutex;
133
134    static bool                 fgXMLChBigEndian;
135    static bool                 fgSSE2ok;
136    //@}
137
138
139    /** @name Initialization and Panic methods */
140    //@{
141
142    /** Perform per-process parser initialization
143      *
144      * Initialization <b>must</b> be called first in any client code.
145      *
146      * @param locale The locale to use for messages.
147      *
148      * The locale is set iff the Initialize() is invoked for the very first time,
149      * to ensure that each and every message loader, in the process space, share
150      * the same locale.
151      *
152      * All subsequent invocations of Initialize(), with a different locale, have
153      * no effect on the message loaders, either instantiated, or to be instantiated.
154      *
155      * To set to a different locale, client application needs to Terminate() (or
156      * multiple Terminate() in the case where multiple Initialize() have been invoked
157      * before), followed by Initialize(new_locale).
158      *
159      * The default locale is "en_US".
160      *
161      * @param nlsHome User specified location where MsgLoader retrieves error message files.
162      *                the discussion above with regard to locale, applies to nlsHome as well.
163      *
164      * @param panicHandler Application's panic handler, application owns this handler.
165      *                     Application shall make sure that the plugged panic handler persists
166      *                     through the call to XMLPlatformUtils::Terminate().
167      *
168      * @param memoryManager Plugged-in memory manager which is owned by the
169      *                      application. Applications must make sure that the
170      *                      plugged-in memory manager persist through the call to
171      *                      XMLPlatformUtils::Terminate()
172      */
173    static void Initialize(const char*          const locale = XMLUni::fgXercescDefaultLocale
174                         , const char*          const nlsHome = 0
175                         ,       PanicHandler*  const panicHandler = 0
176                         ,       MemoryManager* const memoryManager = 0);
177
178      /** Perform per-process parser initialization
179      *
180      * Initialization <b>must</b> be called first in any client code.
181      *
182      * @param initialDOMHeapAllocSize The size of the first memory block
183      * allocated by the DOMDocument heap. Note that changing this parameter
184      * may result in poor performance and/or excessive memory usage. For
185      * the default value refer to dom/impl/DOMDocumentImpl.cpp.
186      *
187      * @param maxDOMHeapAllocSize The maximum size of the memory block
188      * allocated by the DOMDocument heap. As the document grows, the
189      * allocated by the heap memory blocks grow from initialDOMHeapAllocSize
190      * to maxDOMHeapAllocSize. Note that changing this parameter may result
191      * in poor performance and/or excessive memory usage. For the default
192      * value refer to dom/impl/DOMDocumentImpl.cpp.
193      *
194      * @param maxDOMSubAllocationSize The maximum size of the memory block
195      * requested that is handled by the DOMDocument heap. A request for a
196      * larger block is handled directly by the memory manager. Note that
197      * changing this parameter may result in poor performance and/or
198      * excessive memory usage. For the default value refer to
199      * dom/impl/DOMDocumentImpl.cpp.
200      *
201      * @param locale The locale to use for messages.
202      *
203      * The locale is set iff the Initialize() is invoked for the very first time,
204      * to ensure that each and every message loader, in the process space, share
205      * the same locale.
206      *
207      * All subsequent invocations of Initialize(), with a different locale, have
208      * no effect on the message loaders, either instantiated, or to be instantiated.
209      *
210      * To set to a different locale, client application needs to Terminate() (or
211      * multiple Terminate() in the case where multiple Initialize() have been invoked
212      * before), followed by Initialize(new_locale).
213      *
214      * The default locale is "en_US".
215      *
216      * @param nlsHome User specified location where MsgLoader retrieves error message files.
217      * the discussion above with regard to locale, applies to nlsHome as well.
218      *
219      * @param panicHandler Application's panic handler, application owns this handler.
220      * Application shall make sure that the plugged panic handler persists
221      * through the call to XMLPlatformUtils::Terminate().
222      *
223      * @param memoryManager Plugged-in memory manager which is owned by the
224      * application. Applications must make sure that the plugged-in memory
225      * manager persist through the call to XMLPlatformUtils::Terminate()
226      */
227    static void Initialize(XMLSize_t initialDOMHeapAllocSize
228                         , XMLSize_t maxDOMHeapAllocSize
229                         , XMLSize_t maxDOMSubAllocationSize
230                         , const char*          const locale = XMLUni::fgXercescDefaultLocale
231                         , const char*          const nlsHome = 0
232                         ,       PanicHandler*  const panicHandler = 0
233                         ,       MemoryManager* const memoryManager = 0);
234
235    /** Perform per-process parser termination
236      *
237      * The termination call is currently optional, to aid those dynamically
238      * loading the parser to clean up before exit, or to avoid spurious
239      * reports from leak detectors.
240      */
241    static void Terminate();
242
243    /** The panic mechanism.
244      *
245      * If, during initialization, we cannot even get far enough along
246      * to get transcoding up or get message loading working, we call
247      * this method.</p>
248      *
249      * Each platform can implement it however they want. This method will
250      * delegate the panic handling to a user specified panic handler or
251      * in the absence of it, the default panic handler.
252      *
253      * In case the default panic handler does not support a particular
254      * platform, the platform specific panic handling shall be implemented
255      * here </p>.
256      *
257      * @param reason The enumeration that defines the cause of the failure
258      */
259    static void panic
260    (
261        const   PanicHandler::PanicReasons    reason
262    );
263
264    //@}
265
266    /** @name File Methods */
267    //@{
268
269    /** Make a new file object appropriate for the platform.
270      *
271      * @param manager The MemoryManager to use to allocate objects
272      */
273    static XMLFileMgr* makeFileMgr(MemoryManager* const manager);
274
275    /** Get the current file position
276      *
277      * This must be implemented by the per-platform driver, which should
278      * use local file services to determine the current position within
279      * the passed file.
280      *
281      * Since the file API provided here only reads, if the host platform
282      * supports separate read/write positions, only the read position is
283      * of any interest, and hence should be the one returned.
284      *
285      * @param theFile The file handle
286      * @param manager The MemoryManager to use to allocate objects
287      */
288    static XMLFilePos curFilePos(FileHandle theFile
289        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
290
291    /** Closes the file handle
292      *
293      * This must be implemented by the per-platform driver, which should
294      * use local file services to close the passed file handle, and to
295      * destroy the passed file handle and any allocated data or system
296      * resources it contains.
297      *
298      * @param theFile The file handle to close
299      * @param manager The MemoryManager to use to allocate objects
300      */
301    static void closeFile(FileHandle theFile
302        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
303
304    /** Returns the file size
305      *
306      * This must be implemented by the per-platform driver, which should
307      * use local file services to determine the current size of the file
308      * represented by the passed handle.
309      *
310      * @param theFile The file handle whose size you want
311      * @param manager The MemoryManager to use to allocate objects
312      * @return Returns the size of the file in bytes
313      */
314    static XMLFilePos fileSize(FileHandle theFile
315        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
316
317    /** Opens the file
318      *
319      * This must be implemented by the per-platform driver, which should
320      * use local file services to open passed file. If it fails, a
321      * null handle pointer should be returned.
322      *
323      * @param fileName The string containing the name of the file
324      * @param manager The MemoryManager to use to allocate objects
325      * @return The file handle of the opened file
326      */
327    static FileHandle openFile(const char* const fileName
328        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
329
330    /** Opens a named file
331      *
332      * This must be implemented by the per-platform driver, which should
333      * use local file services to open the passed file. If it fails, a
334      * null handle pointer should be returned.
335      *
336      * @param fileName The string containing the name of the file
337      * @param manager The MemoryManager to use to allocate objects
338      * @return The file handle of the opened file
339      */
340    static FileHandle openFile(const XMLCh* const fileName
341        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
342
343    /** Open a named file to write
344      *
345      * This must be implemented by the per-platform driver, which should
346      * use local file services to open passed file. If it fails, a
347      * null handle pointer should be returned.
348      *
349      * @param fileName The string containing the name of the file
350      * @param manager The MemoryManager to use to allocate objects
351      * @return The file handle of the opened file
352      */
353    static FileHandle openFileToWrite(const char* const fileName
354        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
355
356    /** Open a named file to write
357      *
358      * This must be implemented by the per-platform driver, which should
359      * use local file services to open the passed file. If it fails, a
360      * null handle pointer should be returned.
361      *
362      * @param fileName The string containing the name of the file
363      * @param manager The MemoryManager to use to allocate objects
364      * @return The file handle of the opened file
365      */
366    static FileHandle openFileToWrite(const XMLCh* const fileName
367        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
368
369    /** Opens the standard input as a file
370      *
371      * This must be implemented by the per-platform driver, which should
372      * use local file services to open a handle to the standard input.
373      * It should be a copy of the standard input handle, since it will
374      * be closed later!
375      *
376      * @param manager The MemoryManager to use to allocate objects
377      * @return The file handle of the standard input stream
378      */
379    static FileHandle openStdInHandle(MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
380
381    /** Reads the file buffer
382      *
383      * This must be implemented by the per-platform driver, which should
384      * use local file services to read up to 'toRead' bytes of data from
385      * the passed file, and return those bytes in the 'toFill' buffer. It
386      * is not an error not to read the requested number of bytes. When the
387      * end of file is reached, zero should be returned.
388      *
389      * @param theFile The file handle to be read from.
390      * @param toRead The maximum number of byte to read from the current
391      * position
392      * @param toFill The byte buffer to fill
393      * @param manager The MemoryManager to use to allocate objects
394      *
395      * @return Returns the number of bytes read from the stream or file
396      */
397    static XMLSize_t readFileBuffer
398    (
399                FileHandle      theFile
400        , const XMLSize_t       toRead
401        ,       XMLByte* const  toFill
402        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager
403    );
404
405    /** Writes the buffer to the file
406      *
407      * This must be implemented by the per-platform driver, which should
408      * use local file services to write up to 'toWrite' bytes of data to
409      * the passed file. Unless exception raised by local file services,
410      * 'toWrite' bytes of data is to be written to the passed file.
411      *
412      * @param theFile The file handle to be written to.
413      * @param toWrite The maximum number of byte to write from the current
414      * position
415      * @param toFlush The byte buffer to flush
416      * @param manager The MemoryManager to use to allocate objects
417      * @return void
418      */
419    static void writeBufferToFile
420    (
421          FileHandle     const  theFile
422        , XMLSize_t             toWrite
423        , const XMLByte* const  toFlush
424        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager
425    );
426
427    /** Resets the file handle
428      *
429      * This must be implemented by the per-platform driver which will use
430      * local file services to reset the file position to the start of the
431      * the file.
432      *
433      * @param theFile The file handle that you want to reset
434      * @param manager The MemoryManager to use to allocate objects
435      */
436    static void resetFile(FileHandle theFile
437        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
438
439    //@}
440
441
442    /** @name File System Methods */
443    //@{
444    /** Gets the full path from a relative path
445      *
446      * This must be implemented by the per-platform driver. It should
447      * complete a relative path using the 'current directory', or whatever
448      * the local equivalent of a current directory is. If the passed
449      * source path is actually fully qualified, then a straight copy of it
450      * will be returned.
451      *
452      * @param srcPath The path of the file for which you want the full path
453      *
454      * @param manager Pointer to the memory manager to be used to
455      *                allocate objects.
456      *
457      * @return Returns the fully qualified path of the file name including
458      *         the file name. This is dyanmically allocated and must be
459      *         deleted  by the caller when its no longer needed! The memory
460      *         returned will beallocated using the static memory manager, if
461      *         user do not supply a memory manager. Users then need to make
462      *         sure to use either the default or user specific memory manager
463      *         to deallocate the memory.
464      */
465    static XMLCh* getFullPath
466    (
467        const XMLCh* const srcPath
468        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
469    );
470
471    /** Gets the current working directory
472      *
473      * This must be implemented by the per-platform driver. It returns
474      * the current working directory is.
475      * @param manager The MemoryManager to use to allocate objects
476      * @return Returns the current working directory.
477      *         This is dyanmically allocated and must be deleted
478      *         by the caller when its no longer needed! The memory returned
479      *         will be allocated using the static memory manager, if users
480      *         do not supply a memory manager. Users then need to make sure
481      *         to use either the default or user specific memory manager to
482      *         deallocate the memory.
483      */
484    static XMLCh* getCurrentDirectory
485    (
486        MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
487    );
488
489    /** Check if a character is a slash
490      *
491      * This must be implemented by the per-platform driver.
492      *
493      * @param c the character to be examined
494      *
495      * @return true  if the character examined is a slash
496      *         false otherwise
497      */
498    static inline bool isAnySlash(XMLCh c);
499
500    /** Remove occurrences of the pair of dot slash
501      *
502      * To remove the sequence, dot slash if it is part of the sequence,
503      * slash dot slash.
504      *
505      * @param srcPath The path for which you want to remove the dot slash sequence.
506      * @param manager The MemoryManager to use to allocate objects
507      * @return
508      */
509    static void   removeDotSlash(XMLCh* const srcPath
510        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
511
512    /** Remove occurrences of the dot dot slash
513      *
514      * To remove the sequence, slash dot dot slash and its preceding path segment
515      * if and only if the preceding path segment is not slash dot dot slash.
516      *
517      * @param srcPath The path for which you want to remove the slash dot
518      *        dot slash sequence and its preceding path segment.
519      * @param manager The MemoryManager to use to allocate objects
520      * @return
521      */
522    static void   removeDotDotSlash(XMLCh* const srcPath
523        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
524
525    /** Determines if a path is relative or absolute
526      *
527      * This must be implemented by the per-platform driver, which should
528      * determine whether the passed path is relative or not. The concept
529      * of relative and absolute might be... well relative on different
530      * platforms. But, as long as the determination is made consistently
531      * and in coordination with the weavePaths() method, it should work
532      * for any platform.
533      *
534      * @param toCheck The file name which you want to check
535      * @param manager The MemoryManager to use to allocate objects
536      * @return Returns true if the filename appears to be relative
537      */
538    static bool isRelative(const XMLCh* const toCheck
539        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
540        );
541
542    /** Utility to join two paths
543      *
544      * This must be implemented by the per-platform driver, and should
545      * weave the relative path part together with the base part and return
546      * a new path that represents this combination.
547      *
548      * If the relative part turns out to be fully qualified, it will be
549      * returned as is. If it is not, then it will be woven onto the
550      * passed base path, by removing one path component for each leading
551      * "../" (or whatever is the equivalent in the local system) in the
552      * relative path.
553      *
554      * @param basePath The string containing the base path
555      * @param relativePath The string containing the relative path
556      * @param manager The MemoryManager to use to allocate objects
557      * @return Returns a string containing the 'woven' path. It should
558      * be dynamically allocated and becomes the responsibility of the
559      * caller to delete.
560      */
561    static XMLCh* weavePaths
562    (
563        const   XMLCh* const    basePath
564        , const XMLCh* const    relativePath
565        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
566    );
567    //@}
568
569    /** @name Timing Methods */
570    //@{
571
572    /** Gets the system time in milliseconds
573      *
574      * This must be implemented by the per-platform driver, which should
575      * use local services to return the current value of a running
576      * millisecond timer. Note that the value returned is only as accurate
577      * as the millisecond time of the underlying host system.
578      *
579      * @return Returns the system time as an unsigned long
580      */
581    static unsigned long getCurrentMillis();
582    //@}
583
584    /** @name Mutex Methods */
585    //@{
586
587    /** Factory method for creating MutexMgr object.
588      *
589      * This factory method creates a mutexmgr that will be used
590      * on the particular platform.
591      *
592      * @param manager The MemoryManager to use to allocate objects
593      */
594    static XMLMutexMgr* makeMutexMgr(MemoryManager* const manager);
595
596    /** Closes a mutex handle
597      *
598      * Each per-platform driver must implement this. Only it knows what
599      * the actual content of the passed mutex handle is.
600      *
601      * @param mtxHandle The mutex handle that you want to close
602      * @param manager The MemoryManager used to allocate the object
603      */
604    static void closeMutex(void* const mtxHandle, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
605
606    /** Locks a mutex handle
607      *
608      * Each per-platform driver must implement this. Only it knows what
609      * the actual content of the passed mutex handle is.
610      *
611      * @param mtxHandle The mutex handle that you want to lock
612      */
613    static void lockMutex(void* const mtxHandle);
614
615    /** Make a new mutex
616      *
617      * Each per-platform driver must implement this. Only it knows what
618      * the actual content of the passed mutex handle is. The returned
619      * handle pointer will be eventually passed to closeMutex() which is
620      * also implemented by the platform driver.
621      *
622      * @param manager The MemoryManager to use to allocate objects
623      */
624    static void* makeMutex(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
625
626    /** Unlocks a mutex
627      *
628      * Each per-platform driver must implement this. Only it knows what
629      * the actual content of the passed mutex handle is.
630      *
631      * Note that, since the underlying system synchronization services
632      * are used, Xerces cannot guarantee that lock/unlock operations are
633      * correctly enforced on a per-thread basis or that incorrect nesting
634      * of lock/unlock operations will be caught.
635      *
636      * @param mtxHandle The mutex handle that you want to unlock
637      */
638    static void unlockMutex(void* const mtxHandle);
639
640    //@}
641
642
643    /** @name External Message Support */
644    //@{
645
646    /** Loads the message set from among the available domains
647      *
648      * The returned object must be dynamically allocated and the caller
649      * becomes responsible for cleaning it up.
650      *
651      * @param msgDomain The message domain which you want to load
652      */
653    static XMLMsgLoader* loadMsgSet(const XMLCh* const msgDomain);
654
655    //@}
656
657
658    /** @name NEL Character Handling  */
659    //@{
660    /**
661      * This function enables the recognition of NEL(0x85) char and LSEP (0x2028) as newline chars
662      * which is disabled by default.
663      * It is only called once per process. Once it is set, any subsequent calls
664      * will result in exception being thrown.
665      *
666      * Note: 1. Turning this option on will make the parser non compliant to XML 1.0.
667      *       2. This option has no effect to document conforming to XML 1.1 compliant,
668      *          which always recognize these two chars (0x85 and 0x2028) as newline characters.
669      *
670      */
671    static void recognizeNEL(bool state
672        , MemoryManager* const manager  = XMLPlatformUtils::fgMemoryManager);
673
674    /**
675      * Return the value of fgNEL flag.
676      */
677    static bool isNELRecognized();
678    //@}
679
680    /** @name Strict IANA Encoding Checking */
681    //@{
682    /**
683      * This function enables/disables strict IANA encoding names checking.
684      *
685      * The strict checking is disabled by default.
686      *
687      * @param state If true, a strict IANA encoding name check is performed,
688      *              otherwise, no checking.
689      *
690      */
691    static void strictIANAEncoding(const bool state);
692
693    /**
694      * Returns whether a strict IANA encoding name check is enabled or
695      * disabled.
696      */
697    static bool isStrictIANAEncoding();
698    //@}
699
700    /**
701      * Aligns the specified pointer per platform block allocation
702      * requirements.
703      *
704      * The results of this function may be altered by defining
705      * XML_PLATFORM_NEW_BLOCK_ALIGNMENT.
706      */
707    static inline XMLSize_t alignPointerForNewBlockAllocation(XMLSize_t ptrSize);
708
709private :
710    // -----------------------------------------------------------------------
711    //  Unimplemented constructors and operators
712    // -----------------------------------------------------------------------
713    XMLPlatformUtils();
714
715    /** @name Private static methods */
716    //@{
717
718    /** Loads a message set from the available domains
719      *
720      * @param msgDomain The message domain containing the message to be
721      * loaded
722      */
723    static XMLMsgLoader* loadAMsgSet(const XMLCh* const msgDomain);
724
725    /** Creates a net accessor object.
726      *
727      * Each per-platform driver must implement this method. However,
728      * having a Net Accessor is optional and this method can return a
729      * null pointer if remote access via HTTP and FTP URLs is not required.
730      *
731      * @return An object derived from XMLNetAccessor. It must be dynamically
732      *         allocated, since it will be deleted later.
733      */
734    static XMLNetAccessor* makeNetAccessor();
735
736    /** Creates a Transcoding service
737      *
738      * Each per-platform driver must implement this method and return some
739      * derivative of the XMLTransService class. This object serves as the
740      * transcoder factory for this process. The object must be dynamically
741      * allocated and the caller is responsible for cleaning it up.
742      *
743      * @return A dynamically allocated object of some class derived from
744      *         the XMLTransService class.
745      */
746    static XMLTransService* makeTransService();
747
748    /** Search for sequence, slash dot dot slash
749      *
750      * @param srcPath the path to search
751      *
752      * @return   the position of the first occurrence of slash dot dot slash
753      *            -1 if no such sequence is found
754      */
755    static int  searchSlashDotDotSlash(XMLCh* const srcPath);
756
757    //@}
758
759    /** @name Private static methods */
760    //@{
761
762    /**
763      * Indicates whether the memory manager was supplied by the user
764      * or not. Users own the memory manager, and if none is supplied,
765      * Xerces uses a default one that it owns and is responsible for
766      * deleting in Terminate().
767      */
768    static bool fgMemMgrAdopted;
769
770    //@}
771};
772
773
774MakeXMLException(XMLPlatformUtilsException, XMLUTIL_EXPORT)
775
776
777// ---------------------------------------------------------------------------
778//  XMLPlatformUtils: alignPointerForNewBlockAllocation
779// ---------------------------------------------------------------------------
780//  Calculate alignment required by platform for a new
781//  block allocation. We use this in our custom allocators
782//  to ensure that returned blocks are properly aligned.
783//  Note that, although this will take a pointer and return the position
784//  at which it should be placed for correct alignment, in our code
785//  we normally use XMLSize_t parameters to discover what the alignment
786//  of header blocks should be.  Thus, if this is to be
787//  used for the former purpose, to make compilers happy
788//  some casting will be necessary - neilg.
789//
790//  Note: XML_PLATFORM_NEW_BLOCK_ALIGNMENT may be specified on a
791//        per-architecture basis to dictate the alignment requirements
792//        of the architecture. In the absense of this specification,
793//        this routine guesses at the correct alignment value.
794//
795//        A XML_PLATFORM_NEW_BLOCK_ALIGNMENT value of zero is illegal.
796//        If a platform requires absolutely no alignment, a value
797//        of 1 should be specified ("align pointers on 1 byte boundaries").
798//
799inline XMLSize_t
800XMLPlatformUtils::alignPointerForNewBlockAllocation(XMLSize_t ptrSize)
801{
802    //    Macro XML_PLATFORM_NEW_BLOCK_ALIGNMENT may be defined
803    //    as needed to dictate alignment requirements on a
804    //    per-architecture basis. In the absense of that we
805    //    take an educated guess.
806#ifdef XML_PLATFORM_NEW_BLOCK_ALIGNMENT
807    static const XMLSize_t alignment = XML_PLATFORM_NEW_BLOCK_ALIGNMENT;
808#else
809    static const XMLSize_t alignment = (sizeof(void*) >= sizeof(double)) ? sizeof(void*) : sizeof(double);
810#endif
811
812    //    Calculate current alignment of pointer
813    XMLSize_t current = ptrSize % alignment;
814
815    //    Adjust pointer alignment as needed
816    return (current == 0)
817         ? ptrSize
818         : (ptrSize + alignment - current);
819}
820
821
822
823// ---------------------------------------------------------------------------
824//  XMLDeleter: Public Destructor
825// ---------------------------------------------------------------------------
826inline XMLDeleter::~XMLDeleter()
827{
828}
829
830// ---------------------------------------------------------------------------
831//  XMLDeleter: Hidden constructors and operators
832// ---------------------------------------------------------------------------
833inline XMLDeleter::XMLDeleter()
834{
835}
836
837XERCES_CPP_NAMESPACE_END
838
839#endif
Note: See TracBrowser for help on using the repository browser.