sequence.hxx

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 .
 */

#ifndef INCLUDED_COMPHELPER_SEQUENCE_HXX
#define INCLUDED_COMPHELPER_SEQUENCE_HXX

#include <com/sun/star/uno/Sequence.hxx>
#include <osl/diagnose.h>

#include <algorithm>
#include <vector>

namespace comphelper
{
    template <class T1, class T2>
    inline sal_Int32 findValue(const css::uno::Sequence<T1>& _rList, const T2& _rValue)
    {
        // at which position do I find the value?
        for (sal_Int32 i = 0; i < _rList.getLength(); ++i)
        {
            if (_rList[i] == _rValue)
                return i;
        }

        return -1;
    }

    template <class T, class... Ss>
    inline css::uno::Sequence<T> concatSequences(const css::uno::Sequence<T>& rS1, const Ss&... rSn)
    {
        // unary fold to disallow empty parameter pack: at least have one sequence in rSn
        css::uno::Sequence<T> aReturn(std::size(rS1) + (... + std::size(rSn)));
        T* pReturn = std::copy(std::begin(rS1), std::end(rS1), aReturn.getArray());
        (..., (pReturn = std::copy(std::begin(rSn), std::end(rSn), pReturn)));
        return aReturn;
    }

    template<typename T> inline css::uno::Sequence<T> combineSequences(
        css::uno::Sequence<T> const & left, css::uno::Sequence<T> const & right)
    {
        sal_Int32 n1 = left.getLength();
        css::uno::Sequence<T> ret(n1 + right.getLength());
            //TODO: check for overflow
        auto pRet = ret.getArray();
        std::copy_n(left.getConstArray(), n1, pRet);
        sal_Int32 n2 = n1;
        for (sal_Int32 i = 0; i != right.getLength(); ++i) {
            bool found = false;
            for (sal_Int32 j = 0; j != n1; ++j) {
                if (right[i] == left[j]) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                pRet[n2++] = right[i];
            }
        }
        ret.realloc(n2);
        return ret;
    }

    template<class T>
    inline void removeElementAt(css::uno::Sequence<T>& _rSeq, sal_Int32 _nPos)
    {
        sal_Int32 nLength = _rSeq.getLength();

        OSL_ENSURE(0 <= _nPos && _nPos < nLength, "invalid index");

        T* pPos = _rSeq.getArray() + _nPos;
        std::move(pPos + 1, pPos + nLength - _nPos, pPos);

        _rSeq.realloc(nLength-1);
    }

    template < typename DstType, typename SrcType >
    inline css::uno::Sequence< DstType > arrayToSequence( const SrcType* i_pArray, sal_Int32 nNum )
    {
        if constexpr (std::is_same_v< DstType, SrcType >)
        {
            return css::uno::Sequence< DstType >( i_pArray, nNum );
        }
        else
        {
            css::uno::Sequence< DstType > result( nNum );
            ::std::copy( i_pArray, i_pArray+nNum, result.getArray() );
            return result;
        }
    }


    template < typename DstType, typename SrcType >
    inline DstType* sequenceToArray( DstType* io_pArray, const css::uno::Sequence< SrcType >& i_Sequence )
    {
        ::std::copy( i_Sequence.begin(), i_Sequence.end(), io_pArray );
        return io_pArray;
    }


    template < typename DstElementType, typename SrcType >
    inline css::uno::Sequence< DstElementType > containerToSequence( const SrcType& i_Container )
    {
        using ::std::size, ::std::begin, ::std::end;
        css::uno::Sequence< DstElementType > result( size(i_Container) );
        ::std::copy( begin(i_Container), end(i_Container), result.getArray() );
        return result;
    }

    // this one does better type deduction, but does not allow us to copy into a different element type
    template < typename SrcType >
    inline css::uno::Sequence< typename SrcType::value_type > containerToSequence( const SrcType& i_Container )
    {
        return containerToSequence<typename SrcType::value_type, SrcType>(i_Container);
    }

    // handle arrays
    template<typename ElementType, std::size_t SrcSize>
    inline css::uno::Sequence< ElementType > containerToSequence( ElementType const (&i_Array)[ SrcSize ] )
    {
        return css::uno::Sequence< ElementType >( i_Array, SrcSize );
    }

    template <typename T>
    inline css::uno::Sequence<T> containerToSequence(
        ::std::vector<T> const& v )
    {
        return css::uno::Sequence<T>(
            v.data(), static_cast<sal_Int32>(v.size()) );
    }


    template < typename DstType, typename SrcType >
    inline DstType sequenceToContainer( const css::uno::Sequence< SrcType >& i_Sequence )
    {
        return DstType(i_Sequence.begin(), i_Sequence.end());
    }

    // this one does better type deduction, but does not allow us to copy into a different element type
    template < typename DstType >
    inline DstType sequenceToContainer( const css::uno::Sequence< typename DstType::value_type >& i_Sequence )
    {
        return DstType(i_Sequence.begin(), i_Sequence.end());
    }

    template < typename DstType, typename SrcType >
    inline DstType& sequenceToContainer( DstType& o_Output, const css::uno::Sequence< SrcType >& i_Sequence )
    {
        o_Output.resize( i_Sequence.getLength() );
        ::std::copy( i_Sequence.begin(), i_Sequence.end(), o_Output.begin() );
        return o_Output;
    }

    template < typename M >
    inline css::uno::Sequence< typename M::key_type > mapKeysToSequence( M const& map )
    {
        css::uno::Sequence< typename M::key_type > ret( static_cast<sal_Int32>(map.size()) );
        std::transform(map.begin(), map.end(), ret.getArray(),
                       [](const auto& i) { return i.first; });
        return ret;
    }

    template < typename M >
    inline css::uno::Sequence< typename M::mapped_type > mapValuesToSequence( M const& map )
    {
        css::uno::Sequence< typename M::mapped_type > ret( static_cast<sal_Int32>(map.size()) );
        std::transform(map.begin(), map.end(), ret.getArray(),
                       [](const auto& i) { return i.second; });
        return ret;
    }

}   // namespace comphelper


#endif // INCLUDED_COMPHELPER_SEQUENCE_HXX

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