/**
	 * Determine the fully qualified URI for a string.
	 *
	 * @param urlString string to qualify
	 * @return string to fully qualified URI
	 */
	static void
	getURLStringFromString(
			const XalanDOMString&	urlString,
			XalanDOMString&			theNormalizedURI)
	{
		getURLStringFromString(urlString.c_str(), urlString.length(), theNormalizedURI);
	}

    static const DOMStringType
    XalanDOMStringToXercesDOMString(const XalanDOMString&   theString)
    {
        assert(XercesStringLengthType(theString.length()) == theString.length());

        return DOMStringType(&theString[0], XercesStringLengthType(theString.length()));
    }

XSLTInputSource::XSLTInputSource(
            const XalanDOMString&   systemId,
            const XalanDOMString&   publicId,
            MemoryManager&          theMemoryManager) :
    InputSource(
        systemId.c_str(),
        publicId.c_str(),
        &theMemoryManager),
    m_stream(0),
    m_node(0)
{
}

TranscodeToLocalCodePage(
            const XalanDOMString&   theSourceString,
            CharVectorType&         theTargetVector,
            bool                    terminate,
            char                    theSubstitutionChar)
{
    doTranscodeToLocalCodePage(
        theSourceString.c_str(),
        theSourceString.length(),
        true,
        theTargetVector,
        terminate,
        theSubstitutionChar);
}

XalanOutputStream::UnsupportedEncodingException::UnsupportedEncodingException(
            const XalanDOMString&   theEncoding,
            XalanDOMString&         theBuffer) :
    XalanOutputStreamException(
        XalanMessageLoader::getMessage(
            theBuffer,
            XalanMessages::UnsupportedEncoding_1Param,
            theEncoding),
        theBuffer.getMemoryManager()),
   m_encoding(
       theEncoding, 
       theBuffer.getMemoryManager())
{
}

void
XUnknown::str(
            XPathExecutionContext&  /* executionContext */,
            XalanDOMString&         theBuffer) const
{
    theBuffer.append(m_value);
}

void
XTokenNumberAdapter::str(
            XPathExecutionContext&  /* executionContext */,
            XalanDOMString&         theBuffer) const
{
    theBuffer.append(m_value.str());
}

 /**
  * Static conversion function. Appends the supplied boolean
  * value to a string.
  *
  * @param theBool The boolean value to convert.
  * @param theString The string value of the provided boolean value.
  */
 static void
 string(
         bool                theBool,
         XalanDOMString&     theString)
 {
     theString.append(theBool == true ? s_trueString : s_falseString);
 }

TranscodeFromLocalCodePage(
            const CharVectorType&   theSourceString,
            XalanDOMString&         result)
{
    if (theSourceString.empty() == true)
    {
        result.erase();

        return result;
    }
    else
    {
        typedef XalanDOMString::size_type       size_type;

        const CharVectorType::size_type     theSize = theSourceString.size();

        if (theSourceString[theSize - 1] == CharVectorType::value_type(0))
        {
            return TranscodeFromLocalCodePage(&*theSourceString.begin(), result , size_type(theSize) - 1);
        }
        else
        {
            return TranscodeFromLocalCodePage(&*theSourceString.begin(), result , size_type(theSize));
        }
    }
}

void
XalanXMLSerializerFactory::setEncoding(
                             MemoryManager&          theManager,
                             Writer&            theWriter,
                             XalanDOMString&    theEncoding)
{
    XalanOutputStream* stream = theWriter.getStream();

    if(stream != 0)
    {
        if(theEncoding.empty())
        {
            // Default to UTF-8 if the requested encoding is not supported...
            stream->setOutputEncoding(XalanDOMString(XalanTranscodingServices::s_utf8String, theManager));

            theEncoding = XalanTranscodingServices::s_utf8String;
        }
        else
        {
            try
            {
                stream->setOutputEncoding(theEncoding);
            }
            catch(const XalanOutputStream::UnsupportedEncodingException&)
            {
                // Default to UTF-8 if the requested encoding is not supported...
                stream->setOutputEncoding(XalanDOMString(XalanTranscodingServices::s_utf8String, theManager));

                theEncoding = XalanTranscodingServices::s_utf8String;
            }
        }

    }
}

	/**
	 * Determine the fully qualified URI for a string.
	 *
	 * @param urlString string to qualify
	 * @param url to update with the qualified string.
	 */
	static void
	getURLFromString(
			const XalanDOMString&	urlString,
			XMLURLType&				url,
            MemoryManagerType&      theManager)
	{
		getURLFromString(urlString.c_str(), url, theManager);
	}

bool
XalanDOMString::equals(
            const XalanDOMString&   theLHS,
            const XalanDOMString&   theRHS)
{
    const XalanDOMString::size_type     theLHSLength = theLHS.size();
    const XalanDOMString::size_type     theRHSLength = theRHS.size();

    if (theLHSLength != theRHSLength)
    {
        return false;
    }
    else
    {
        return equals(theLHS.c_str(), theLHSLength, theRHS.c_str(), theRHSLength);
    }
}

XALAN_CPP_NAMESPACE_BEGIN



DOMStringPrintWriter::DOMStringPrintWriter(XalanDOMString&	theString) :
PrintWriter(true, theString.getMemoryManager()),
	m_outputString(&theString)
{
}

void
AVTPartSimple::evaluate(
            XalanDOMString&         buf,
            const PrefixResolver&   /* prefixResolver */,
            XPathExecutionContext&  /* executionContext */) const

{
    buf.append(m_val, m_len);
}

inline void
reset_func(XalanDOMString& obj, MemoryManager&    theManager, Type string)
{
    assert( string != 0 );

    XalanDOMString tmpString(string, theManager);

    obj.swap(tmpString);
}

XalanDOMString::XalanDOMString(
            const XalanDOMString&   theSource,
            MemoryManager&      theManager,
            size_type               theStartPosition,
            size_type               theCount) :
    m_data(theManager),
    m_size(0)
{
    if (theSource.length() != 0)
    {
        append(theSource, theStartPosition, theCount);
    }
}

XObjectPtr
FunctionSample::execute(
            XPathExecutionContext&  executionContext,
            XalanNode*              /* context */,          
            const XObjectPtr        arg1,
            const XObjectPtr        arg2,
            const Locator*          /* locator */) const
{
   assert(arg1.null() == false);
   assert(arg2.null() == false);

   XalanDOMString path;
   arg1->str(path);
   const bool bLinux = arg2->boolean();

   XalanDOMChar dchOld;
   XalanDOMChar dchNew;

   if (bLinux)
   {
      dchOld = '\\';
      dchNew = '/';
   }
   else
   {
      dchOld = '/';
      dchOld = '\\';
   }

    int len = path.length();
   for (int i=0; i<len; i++)
      if (path[i] == dchOld)
         path[i] = dchNew;

    return executionContext.getXObjectFactory().createString(path); 
}

	/**
	 * Append the value to the buffer.
	 *
	 * @param buf              buffer to write into
	 * @param prefixResolver   prefix resolver to use
	 * @param executionContext execution context
	 */
	void
	evaluate(
			XalanDOMString&			buf,
			const PrefixResolver&	prefixResolver,
			XPathExecutionContext&	executionContext) const
	{
		if(m_simpleString != 0)
		{
			buf.assign(m_simpleString, m_simpleStringLength);
		}
		else
		{
			doEvaluate(buf, prefixResolver, executionContext);
		}
	}

XalanFileOutputStream::XalanFileOutputStreamWriteException::XalanFileOutputStreamWriteException(
        const XalanDOMString&   theFileName,
        int                     theErrorCode,
        XalanDOMString&         theBuffer,
        const Locator*          theLocator) :
    XalanOutputStreamException(
        formatMessage(
            XalanMessageLoader::getMessage(
                theBuffer,
                XalanMessages::ErrorWritingFile_1Param,
                theFileName),
            theErrorCode,
            theBuffer),
        theBuffer.getMemoryManager(),
        theLocator)
{
}

void
ExtensionNSHandler::setElements(const XalanDOMString&   elemNames)
{
    if (elemNames.empty() == false)
    {
        StringTokenizer     st(elemNames, s_tokenDelimiterCharacters, false);

        XalanDOMString theResult(m_elements.getMemoryManager());

        while (st.hasMoreTokens() == true)
        {
            st.nextToken(theResult);

            m_elements.insert(theResult); // just stick it in there basically
        }
    
        m_componentDescLoaded = true;
    }
}