byteseq.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you 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 .
 */

/*
 * This file is part of LibreOffice published API.
 */
#ifndef INCLUDED_RTL_BYTESEQ_H
#define INCLUDED_RTL_BYTESEQ_H

#include "sal/config.h"

#include "rtl/alloc.h"
#include "sal/saldllapi.h"
#include "sal/types.h"

#ifdef __cplusplus
extern "C"
{
#endif

SAL_DLLPUBLIC void SAL_CALL rtl_byte_sequence_reference2One(
    sal_Sequence ** ppSequence )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC void SAL_CALL rtl_byte_sequence_realloc(
    sal_Sequence ** ppSequence, sal_Int32 nSize )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC void SAL_CALL rtl_byte_sequence_acquire(
    sal_Sequence *pSequence )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC void SAL_CALL rtl_byte_sequence_release(
    sal_Sequence *pSequence )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC void SAL_CALL rtl_byte_sequence_construct(
    sal_Sequence **ppSequence , sal_Int32 nLength )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC void SAL_CALL rtl_byte_sequence_constructNoDefault(
    sal_Sequence **ppSequence , sal_Int32 nLength )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC void SAL_CALL rtl_byte_sequence_constructFromArray(
    sal_Sequence **ppSequence, const sal_Int8 *pData , sal_Int32 nLength )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC void SAL_CALL rtl_byte_sequence_assign(
    sal_Sequence **ppSequence , sal_Sequence *pSequence )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC sal_Bool SAL_CALL rtl_byte_sequence_equals(
    sal_Sequence *pSequence1 , sal_Sequence *pSequence2 )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC const sal_Int8 *SAL_CALL rtl_byte_sequence_getConstArray(
    sal_Sequence *pSequence )
    SAL_THROW_EXTERN_C();

SAL_DLLPUBLIC sal_Int32 SAL_CALL rtl_byte_sequence_getLength(
    sal_Sequence *pSequence )
    SAL_THROW_EXTERN_C();

#ifdef __cplusplus
}
namespace rtl
{

enum __ByteSequence_NoDefault
{
    BYTESEQ_NODEFAULT = 0xcafe
};

enum __ByteSequence_NoAcquire
{
    BYTESEQ_NOACQUIRE =
#if defined _MSC_VER
        int(0xcafebabe)
#else
        0xcafebabe
#endif
};

class SAL_WARN_UNUSED ByteSequence
{
    sal_Sequence * _pSequence;

public:
    // these are here to force memory de/allocation to sal lib.
    static void * SAL_CALL operator new ( size_t nSize )
        { return ::rtl_allocateMemory( nSize ); }
    static void SAL_CALL operator delete ( void * pMem )
        { ::rtl_freeMemory( pMem ); }
    static void * SAL_CALL operator new ( size_t, void * pMem )
        { return pMem; }
    static void SAL_CALL operator delete ( void *, void * )
        {}

    inline ByteSequence();
    inline ByteSequence( const ByteSequence & rSeq );
#if defined LIBO_INTERNAL_ONLY
    inline ByteSequence( ByteSequence && rSeq ) noexcept;
#endif

    inline ByteSequence( sal_Sequence *pSequence );
    inline ByteSequence( const sal_Int8 * pElements, sal_Int32 len );
    inline ByteSequence( sal_Int32 len );
    inline ByteSequence( sal_Int32 len , enum __ByteSequence_NoDefault nodefault );
    inline ByteSequence( sal_Sequence *pSequence , enum __ByteSequence_NoAcquire noacquire );
    inline ~ByteSequence();

    inline ByteSequence & SAL_CALL operator = ( const ByteSequence & rSeq );
#if defined LIBO_INTERNAL_ONLY
    inline ByteSequence & operator = ( ByteSequence && rSeq ) noexcept;
#endif

    sal_Int32 SAL_CALL getLength() const
        { return _pSequence->nElements; }

    const sal_Int8 * SAL_CALL getConstArray() const
        { return reinterpret_cast<sal_Int8 *>(_pSequence->elements); }
    inline sal_Int8 * SAL_CALL getArray();

    inline sal_Int8 & SAL_CALL operator [] ( sal_Int32 nIndex );

    const sal_Int8 & SAL_CALL operator [] ( sal_Int32 nIndex ) const
        { return getConstArray()[ nIndex ]; }

    inline bool SAL_CALL operator == ( const ByteSequence & rSeq ) const;
    inline bool SAL_CALL operator != ( const ByteSequence & rSeq ) const;

    inline void SAL_CALL realloc( sal_Int32 nSize );

    sal_Sequence * SAL_CALL getHandle() const
        { return _pSequence; }
    sal_Sequence * SAL_CALL get() const
        { return _pSequence; }
};

}
#endif
#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */