utf8string.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Andreas Huggel (ahu)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.11 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _UTF8STRING_H_
#define _UTF8STRING_H_

// *********************************************************************
// included header files
// + standard includes
#include <string>

// + local headers
#include "utf8stringC.h"

namespace OSB_CORBA {
    using corba::common::Utf8String;

// *********************************************************************
// inline definitions

    inline std::string::size_type toSizeType(CORBA::ULong l)
    {
        return l; // let the compiler complain
    }

    inline CORBA::ULong toULong(std::string::size_type st)
    {
        return st; // let the compiler complain
    }

    inline const char* toConstCharPtr(const CORBA::Octet* o)
    {
        const unsigned char* uc = o; // let the compiler complain
        return reinterpret_cast<const char*>(uc);
    }

    inline char* toCharPtr(CORBA::Octet* o)
    {
        unsigned char* uc = o; // let the compiler complain
        return reinterpret_cast<char*>(uc);
    }

    inline const CORBA::Octet* toConstOctetPtr(const char* c)
    {
        const unsigned char* uc
            = reinterpret_cast<const unsigned char*>(c);
        const CORBA::Octet* o = uc; // let the compiler complain
        return o;
    }

    inline CORBA::Octet* toOctetPtr(char* c)
    {
        unsigned char* uc = reinterpret_cast<unsigned char*>(c);
        CORBA::Octet* o = uc;  // let the compiler complain
        return o;
    }

    inline std::string& fromUtf8(
              std::string& dest,
        const Utf8String&  src
    )
    {
        const CORBA::Octet* o = src.get_buffer();
        if (o == 0) return dest = std::string("");
        // the string constructor will throw exception
        // when the char* parameter pointer empty
        return dest = std::string(toConstCharPtr(o),
                                  toSizeType(src.length()));
    }

    inline std::string fromUtf8(const Utf8String& src)
    {
        std::string rc;
        return fromUtf8(rc, src);
    }

    inline Utf8String* toUtf8(const std::string& src)
    {
        // First use allocbuf() to allocate a buffer to hold the string
        // and copy the contents from the C++ string into this
        // buffer. This does not make assumptions about the string
        // containing zeros. Then use C++ new and the Corba data
        // constructor of the Utf8String to dynamically allocate a
        // Utf8String and initialise it. Set the release flag to true,
        // indicating that the Utf8String should take ownership of the
        // passed buffer (and deallocate it with freebuf()).

        // Note 1: This is exception safe because allocbuf() does not
        //         throw.

        // Note 2: No UTF8 conversion is currently done.

        // ToDo: what happens if allocbuf() fails (returns 0)?
        //       - should we return an 'empty' Utf8String?
        //         (current behaviour, which is easier to handle
        //          for the caller)
        //       - or should we return 0
        //         (like other Corba function do)

        CORBA::ULong len = src.length();
        CORBA::Octet* buf = Utf8String::allocbuf(len);
        if (buf != 0) src.copy(toCharPtr(buf), toSizeType(len));

        return new Utf8String(len, len, buf, 1);    // can throw.
    }
}                                       // namespace OSB_CORBA
#endif                                  // #ifndef _UTF8STRING_H_

---