| API Docs for SAX and DOM |

Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members

# PlatformUtils.hpp

Go to the documentation of this file.

    00001 /*
    00002  * The Apache Software License, Version 1.1
    00003  *
    00004  * Copyright (c) 1999-2003 The Apache Software Foundation.  All rights
    00005  * reserved.
    00006  *
    00007  * Redistribution and use in source and binary forms, with or without
    00008  * modification, are permitted provided that the following conditions
    00009  * are met:
    00010  *
    00011  * 1. Redistributions of source code must retain the above copyright
    00012  *    notice, this list of conditions and the following disclaimer.
    00013  *
    00014  * 2. Redistributions in binary form must reproduce the above copyright
    00015  *    notice, this list of conditions and the following disclaimer in
    00016  *    the documentation and/or other materials provided with the
    00017  *    distribution.
    00018  *
    00019  * 3. The end-user documentation included with the redistribution,
    00020  *    if any, must include the following acknowledgment:
    00021  *       "This product includes software developed by the
    00022  *        Apache Software Foundation (http://www.apache.org/)."
    00023  *    Alternately, this acknowledgment may appear in the software itself,
    00024  *    if and wherever such third-party acknowledgments normally appear.
    00025  *
    00026  * 4. The names "Xerces" and "Apache Software Foundation" must
    00027  *    not be used to endorse or promote products derived from this
    00028  *    software without prior written permission. For written
    00029  *    permission, please contact apache\@apache.org.
    00030  *
    00031  * 5. Products derived from this software may not be called "Apache",
    00032  *    nor may "Apache" appear in their name, without prior written
    00033  *    permission of the Apache Software Foundation.
    00034  *
    00035  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
    00036  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    00037  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    00038  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
    00039  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    00040  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    00041  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
    00042  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
    00043  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    00044  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
    00045  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    00046  * SUCH DAMAGE.
    00047  * ====================================================================
    00048  *
    00049  * This software consists of voluntary contributions made by many
    00050  * individuals on behalf of the Apache Software Foundation, and was
    00051  * originally based on software copyright (c) 1999, International
    00052  * Business Machines, Inc., http://www.ibm.com .  For more information
    00053  * on the Apache Software Foundation, please see
    00054  * <http://www.apache.org/>.
    00055  */
    00056
    00057 /*
    00058  * $Id: PlatformUtils.hpp,v 1.19 2003/12/01 23:23:27 neilg Exp $
    00059  */
    00060
    00061
    00062 #if !defined(PLATFORMUTILS_HPP)
    00063 #define PLATFORMUTILS_HPP
    00064
    00065 #include <xercesc/util/XMLException.hpp>
    00066 #include <xercesc/util/PanicHandler.hpp>
    00067
    00068 XERCES_CPP_NAMESPACE_BEGIN
    00069
    00070 class XMLMsgLoader;
    00071 class XMLNetAccessor;
    00072 class XMLTransService;
    00073 class MemoryManager;
    00074
    00075 //
    00076 //  For internal use only
    00077 //
    00078 //  This class provides a simple abstract API via which lazily evaluated
    00079 //  data can be cleaned up.
    00080 //
    00081 class  XMLDeleter
    00082 {
    00083 public :
    00084     virtual ~XMLDeleter();
    00085
    00086 protected :
    00087     XMLDeleter();
    00088
    00089 private :
    00090     XMLDeleter(const XMLDeleter&);
    00091     XMLDeleter& operator=(const XMLDeleter&);
    00092 };
    00093
    00094
    00103 class  XMLPlatformUtils
    00104 {
    00105 public :
    00106
    00109
    00122     static XMLNetAccessor*      fgNetAccessor;
    00123
    00134     static XMLTransService*     fgTransService;
    00135
    00140     static PanicHandler*        fgUserPanicHandler;
    00141
    00146     static PanicHandler*        fgDefaultPanicHandler;
    00147
    00153     static MemoryManager*       fgMemoryManager;
    00154
    00163     static MemoryManager*       fgArrayMemoryManager;
    00164
    00166
    00167
    00170
    00201     static void Initialize(const char*          const locale = XMLUni::fgXercescDefaultLocale
    00202                          , const char*          const nlsHome = 0
    00203                          ,       PanicHandler*  const panicHandler = 0
    00204                          ,       MemoryManager* const memoryManager = 0);
    00205
    00212     static void Terminate();
    00213
    00230     static void panic
    00231     (
    00232         const   PanicHandler::PanicReasons    reason
    00233     );
    00234
    00236
    00239
    00252     static unsigned int curFilePos(FileHandle theFile);
    00253
    00263     static void closeFile(FileHandle theFile);
    00264
    00275     static unsigned int fileSize(FileHandle theFile);
    00276
    00287     static FileHandle openFile(const char* const fileName);
    00288
    00299     static FileHandle openFile(const XMLCh* const fileName);
    00300
    00311     static FileHandle openFileToWrite(const char* const fileName);
    00312
    00323     static FileHandle openFileToWrite(const XMLCh* const fileName);
    00324
    00334     static FileHandle openStdInHandle();
    00335
    00351     static unsigned int readFileBuffer
    00352     (
    00353                 FileHandle      theFile
    00354         , const unsigned int    toRead
    00355         ,       XMLByte* const  toFill
    00356     );
    00357
    00372     static void writeBufferToFile
    00373     (
    00374           FileHandle     const  theFile
    00375         , long                  toWrite
    00376         , const XMLByte* const  toFlush
    00377     );
    00378
    00387     static void resetFile(FileHandle theFile);
    00388
    00390
    00391
    00415     static XMLCh* getFullPath
    00416     (
    00417         const XMLCh* const srcPath
    00418         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    00419     );
    00420
    00434     static XMLCh* getCurrentDirectory
    00435     (
    00436         MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    00437     );
    00438
    00448     static inline bool isAnySlash(XMLCh c);
    00449
    00459     static void   removeDotSlash(XMLCh* const srcPath);
    00460
    00471     static void   removeDotDotSlash(XMLCh* const srcPath);
    00472
    00486     static bool isRelative(const XMLCh* const toCheck);
    00487
    00507     static XMLCh* weavePaths
    00508     (
    00509         const   XMLCh* const    basePath
    00510         , const XMLCh* const    relativePath
    00511     );
    00513
    00516
    00526     static unsigned long getCurrentMillis();
    00528
    00531
    00539     static void closeMutex(void* const mtxHandle);
    00540
    00548     static void lockMutex(void* const mtxHandle);
    00549
    00557     static void* makeMutex();
    00558
    00571     static void unlockMutex(void* const mtxHandle);
    00572
    00574
    00575
    00578
    00586     static XMLMsgLoader* loadMsgSet(const XMLCh* const msgDomain);
    00587
    00589
    00592
    00618     static void* compareAndSwap
    00619     (
    00620                 void**      toFill
    00621         , const void* const newValue
    00622         , const void* const toCompare
    00623     );
    00624
    00626
    00627
    00630
    00650     static int atomicIncrement(int& location);
    00651
    00671     static int atomicDecrement(int& location);
    00672
    00674
    00688     static void recognizeNEL(bool state);
    00689
    00693     static bool isNELRecognized();
    00695
    00707     static void strictIANAEncoding(const bool state);
    00708
    00713     static bool isStrictIANAEncoding();
    00715
    00723     static inline size_t alignPointerForNewBlockAllocation(size_t ptrSize);
    00724
    00725 private :
    00728
    00734     static XMLMsgLoader* loadAMsgSet(const XMLCh* const msgDomain);
    00735
    00745     static XMLNetAccessor* makeNetAccessor();
    00746
    00757     static XMLTransService* makeTransService();
    00758
    00765     static void platformInit();
    00766
    00773     static void platformTerm();
    00774
    00782     static int  searchSlashDotDotSlash(XMLCh* const srcPath);
    00783
    00785
    00788
    00795     static bool fgMemMgrAdopted;
    00796
    00798 };
    00799
    00800
    00801 MakeXMLException(XMLPlatformUtilsException, )
    00802
    00803
    00804 // ---------------------------------------------------------------------------
    00805 //  XMLPlatformUtils: alignPointerForNewBlockAllocation
    00806 // ---------------------------------------------------------------------------
    00807 //  Calculate alignment required by platform for a new
    00808 //  block allocation. We use this in our custom allocators
    00809 //  to ensure that returned blocks are properly aligned.
    00810 //  Note that, although this will take a pointer and return the position
    00811 //  at which it should be placed for correct alignment, in our code
    00812 //  we normally use size_t parameters to discover what the alignment
    00813 //  of header blocks should be.  Thus, if this is to be
    00814 //  used for the former purpose, to make compilers happy
    00815 //  some casting will be necessary - neilg.
    00816 //
    00817 //  Note: XML_PLATFORM_NEW_BLOCK_ALIGNMENT may be specified on a
    00818 //        per-architecture basis to dictate the alignment requirements
    00819 //        of the architecture. In the absense of this specification,
    00820 //        this routine guesses at the correct alignment value.
    00821 //
    00822 //        A XML_PLATFORM_NEW_BLOCK_ALIGNMENT value of zero is illegal.
    00823 //        If a platform requires absolutely no alignment, a value
    00824 //        of 1 should be specified ("align pointers on 1 byte boundaries").
    00825 //
    00826 inline size_t
    00827 XMLPlatformUtils::alignPointerForNewBlockAllocation(size_t ptrSize)
    00828 {
    00829     //  Macro XML_PLATFORM_NEW_BLOCK_ALIGNMENT may be defined
    00830     //  as needed to dictate alignment requirements on a
    00831     //  per-architecture basis. In the absense of that we
    00832     //  take an educated guess.
    00833     #ifdef XML_PLATFORM_NEW_BLOCK_ALIGNMENT
    00834         size_t alignment = XML_PLATFORM_NEW_BLOCK_ALIGNMENT;
    00835     #else
    00836         size_t alignment = (sizeof(void*) >= sizeof(double)) ? sizeof(void*) : sizeof(double);
    00837     #endif
    00838
    00839     //  Calculate current alignment of pointer
    00840     size_t current = ptrSize % alignment;
    00841
    00842     //  Adjust pointer alignment as needed
    00843     return (current == 0)
    00844          ? ptrSize
    00845          : (ptrSize + alignment - current);
    00846 }
    00847
    00848
    00849
    00850 // ---------------------------------------------------------------------------
    00851 //  XMLDeleter: Public Destructor
    00852 // ---------------------------------------------------------------------------
    00853 inline XMLDeleter::~XMLDeleter()
    00854 {
    00855 }
    00856
    00857 // ---------------------------------------------------------------------------
    00858 //  XMLDeleter: Hidden constructors and operators
    00859 // ---------------------------------------------------------------------------
    00860 inline XMLDeleter::XMLDeleter()
    00861 {
    00862 }
    00863
    00864 XERCES_CPP_NAMESPACE_END
    00865
    00866 #endif

Copyright © 2003 The Apache Software Foundation. All Rights Reserved.