PlatformUtils.hpp Source File

| 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.16 2003/05/22 22:54:25 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
    00156
    00157
    00160
    00191     static void Initialize(const char*          const locale = XMLUni::fgXercescDefaultLocale
    00192                          , const char*          const nlsHome = 0
    00193                          ,       PanicHandler*  const panicHandler = 0
    00194                          ,       MemoryManager* const memoryManager = 0);
    00195
    00202     static void Terminate();
    00203
    00220     static void panic
    00221     (
    00222         const   PanicHandler::PanicReasons    reason
    00223     );
    00224
    00226
    00229
    00242     static unsigned int curFilePos(FileHandle theFile);
    00243
    00253     static void closeFile(FileHandle theFile);
    00254
    00265     static unsigned int fileSize(FileHandle theFile);
    00266
    00277     static FileHandle openFile(const char* const fileName);
    00278
    00289     static FileHandle openFile(const XMLCh* const fileName);
    00290
    00301     static FileHandle openFileToWrite(const char* const fileName);
    00302
    00313     static FileHandle openFileToWrite(const XMLCh* const fileName);
    00314
    00324     static FileHandle openStdInHandle();
    00325
    00341     static unsigned int readFileBuffer
    00342     (
    00343                 FileHandle      theFile
    00344         , const unsigned int    toRead
    00345         ,       XMLByte* const  toFill
    00346     );
    00347
    00362     static void writeBufferToFile
    00363     (
    00364           FileHandle     const  theFile
    00365         , long                  toWrite
    00366         , const XMLByte* const  toFlush
    00367     );
    00368
    00377     static void resetFile(FileHandle theFile);
    00378
    00380
    00381
    00402     static XMLCh* getFullPath
    00403     (
    00404         const XMLCh* const srcPath
    00405         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    00406     );
    00407
    00421     static XMLCh* getCurrentDirectory
    00422     (
    00423         MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    00424     );
    00425
    00435     static inline bool isAnySlash(XMLCh c);
    00436
    00446     static void   removeDotSlash(XMLCh* const srcPath);
    00447
    00458     static void   removeDotDotSlash(XMLCh* const srcPath);
    00459
    00473     static bool isRelative(const XMLCh* const toCheck);
    00474
    00494     static XMLCh* weavePaths
    00495     (
    00496         const   XMLCh* const    basePath
    00497         , const XMLCh* const    relativePath
    00498     );
    00500
    00503
    00513     static unsigned long getCurrentMillis();
    00515
    00518
    00526     static void closeMutex(void* const mtxHandle);
    00527
    00535     static void lockMutex(void* const mtxHandle);
    00536
    00544     static void* makeMutex();
    00545
    00558     static void unlockMutex(void* const mtxHandle);
    00559
    00561
    00562
    00565
    00573     static XMLMsgLoader* loadMsgSet(const XMLCh* const msgDomain);
    00574
    00576
    00579
    00605     static void* compareAndSwap
    00606     (
    00607                 void**      toFill
    00608         , const void* const newValue
    00609         , const void* const toCompare
    00610     );
    00611
    00613
    00614
    00617
    00637     static int atomicIncrement(int& location);
    00638
    00658     static int atomicDecrement(int& location);
    00659
    00661
    00675     static void recognizeNEL(bool state);
    00676
    00680     static bool isNELRecognized();
    00682
    00694     static void strictIANAEncoding(const bool state);
    00695
    00700     static bool isStrictIANAEncoding();
    00702
    00710     static inline size_t alignPointerForNewBlockAllocation(size_t ptrSize);
    00711
    00712 private :
    00715
    00721     static XMLMsgLoader* loadAMsgSet(const XMLCh* const msgDomain);
    00722
    00732     static XMLNetAccessor* makeNetAccessor();
    00733
    00744     static XMLTransService* makeTransService();
    00745
    00752     static void platformInit();
    00753
    00760     static void platformTerm();
    00761
    00769     static int  searchSlashDotDotSlash(XMLCh* const srcPath);
    00770
    00772
    00775
    00782     static bool fgMemMgrAdopted;
    00783
    00785 };
    00786
    00787
    00788 MakeXMLException(XMLPlatformUtilsException, )
    00789
    00790
    00791 // ---------------------------------------------------------------------------
    00792 //  XMLPlatformUtils: alignPointerForNewBlockAllocation
    00793 // ---------------------------------------------------------------------------
    00794 //  Calculate alignment required by platform for a new
    00795 //  block allocation. We use this in our custom allocators
    00796 //  to ensure that returned blocks are properly aligned.
    00797 // Note that, although this will take a pointer and return the position
    00798 // at which it should be placed for correct alignment, in our code
    00799 // we normally use size_t parameters to discover what the alignment
    00800 // of header blocks should be.  Thus, if this is to be
    00801 // used for the former purpose, to make compilers happy
    00802 // some casting will be necessary - neilg.
    00803 inline size_t
    00804 XMLPlatformUtils::alignPointerForNewBlockAllocation(size_t ptrSize)
    00805 {
    00806     //  Macro XML_PLATFORM_NEW_BLOCK_ALIGNMENT may be defined
    00807     //  as needed to dictate alignment requirements on a
    00808     //  per-architecture basis. In the absense of that we
    00809     //  take an educated guess.
    00810     #ifdef XML_PLATFORM_NEW_BLOCK_ALIGNMENT
    00811         size_t alignment = XML_PLATFORM_NEW_BLOCK_ALIGNMENT;
    00812     #else
    00813         size_t alignment = (sizeof(void*) >= sizeof(double)) ? sizeof(void*) : sizeof(double);
    00814     #endif
    00815
    00816     //  Calculate current alignment of pointer
    00817     size_t current = ptrSize % alignment;
    00818
    00819     //  Adjust pointer alignment as needed
    00820     return (current == 0)
    00821          ? ptrSize
    00822          : (ptrSize + alignment - current);
    00823 }
    00824
    00825
    00826
    00827 // ---------------------------------------------------------------------------
    00828 //  XMLDeleter: Public Destructor
    00829 // ---------------------------------------------------------------------------
    00830 inline XMLDeleter::~XMLDeleter()
    00831 {
    00832 }
    00833
    00834 // ---------------------------------------------------------------------------
    00835 //  XMLDeleter: Hidden constructors and operators
    00836 // ---------------------------------------------------------------------------
    00837 inline XMLDeleter::XMLDeleter()
    00838 {
    00839 }
    00840
    00841 XERCES_CPP_NAMESPACE_END
    00842
    00843 #endif

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