/* * Copyright 1999-2000,2004 The Apache Software Foundation. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * $Log: XML256TableTranscoder.hpp,v $ * Revision 1.5 2004/09/08 13:56:23 peiyongz * Apache License Version 2.0 * * Revision 1.4 2003/12/17 00:18:35 cargilld * Update to memory management so that the static memory manager (one used to call Initialize) is only for static data. * * Revision 1.3 2003/03/07 18:11:55 tng * Return a reference instead of void for operator= * * Revision 1.2 2002/11/04 15:22:05 tng * C++ Namespace Support. * * Revision 1.1.1.1 2002/02/01 22:22:13 peiyongz * sane_include * * Revision 1.1 2000/03/18 00:00:32 roddey * Initial updates for two way transcoding support * */ #ifndef XML256TABLETRANSCODER_HPP #define XML256TABLETRANSCODER_HPP #include XERCES_CPP_NAMESPACE_BEGIN // // This class implements the functionality of a common type of transcoder // for an 8 bit, single byte encoding based on a set of 'to' and 'from' // translation tables. Actual derived classes are trivial and just have to // provide us with pointers to their tables and we do all the work. // class XMLUTIL_EXPORT XML256TableTranscoder : public XMLTranscoder { public : // ----------------------------------------------------------------------- // Public constructors and destructor // ----------------------------------------------------------------------- virtual ~XML256TableTranscoder(); // ----------------------------------------------------------------------- // The virtual transcoding interface // ----------------------------------------------------------------------- virtual unsigned int transcodeFrom ( const XMLByte* const srcData , const unsigned int srcCount , XMLCh* const toFill , const unsigned int maxChars , unsigned int& bytesEaten , unsigned char* const charSizes ); virtual unsigned int transcodeTo ( const XMLCh* const srcData , const unsigned int srcCount , XMLByte* const toFill , const unsigned int maxBytes , unsigned int& charsEaten , const UnRepOpts options ); virtual bool canTranscodeTo ( const unsigned int toCheck ) const; protected : // ----------------------------------------------------------------------- // Hidden constructors // ----------------------------------------------------------------------- XML256TableTranscoder ( const XMLCh* const encodingName , const unsigned int blockSize , const XMLCh* const fromTable , const XMLTransService::TransRec* const toTable , const unsigned int toTableSize , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager ); // ----------------------------------------------------------------------- // Protected helper methods // ----------------------------------------------------------------------- XMLByte xlatOneTo ( const XMLCh toXlat ) const; private : // ----------------------------------------------------------------------- // Unimplemented constructors and operators // ----------------------------------------------------------------------- XML256TableTranscoder(); XML256TableTranscoder(const XML256TableTranscoder&); XML256TableTranscoder& operator=(const XML256TableTranscoder&); // ----------------------------------------------------------------------- // Private data members // // fFromTable // This is the 'from' table that we were given during construction. // It is a 256 entry table of XMLCh chars. Each entry is the // Unicode code point for the external encoding point of that value. // So fFromTable[N] is the Unicode translation of code point N of // the source encoding. // // We don't own this table, we just refer to it. It is assumed that // the table is static, for performance reasons. // // fToSize // The 'to' table is variable sized. This indicates how many records // are in it. // // fToTable // This is a variable sized table of TransRec structures. It must // be sorted by the intCh field, i.e. the XMLCh field. It is searched // binarily to find the record for a particular Unicode char. Then // that record's extch field is the translation record. // // We don't own this table, we just refer to it. It is assumed that // the table is static, for performance reasons. // // NOTE: There may be dups of the extCh field, since there might be // multiple Unicode code points which map to the same external code // point. Normally this won't happen, since the parser assumes that // internalization is normalized, but we have to be prepared to do // the right thing if some client code gives us non-normalized data // itself. // ----------------------------------------------------------------------- const XMLCh* fFromTable; unsigned int fToSize; const XMLTransService::TransRec* fToTable; }; XERCES_CPP_NAMESPACE_END #endif