ListUtils.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="ListUtils.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2024 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------
 
#include <system/enumerator_adapter.h>
#include <system/default.h>
#include <system/collections/list.h>
#include <system/collections/ilist.h>
#include <system/collections/ienumerable.h>
#include <system/collections/icomparer.h>
#include <system/collections/icollection.h>
#include <system/array.h>
 
#include "aspose.tasks.cpp/Util/ICondition.h"
#include "aspose.tasks.cpp/Util/IAlgorithm.h"
#include "aspose.tasks.cpp/aspose_tasks_api_defs.h"
 
namespace Aspose
{
namespace LicenseV2
{
class LicenseCore;
} // namespace LicenseV2
namespace Tasks
{
namespace IO
{
namespace MSProject
{
namespace Decryptor
{
class AgilePasswordVerifier;
class MPP14StreamEncryptorDecryptorBase;
} // namespace Decryptor
class FixedWriter;
namespace Metadata
{
class FixedDataOffsets;
class VarDataOffsets;
} // namespace Metadata
class Mpp12CalendarWriter;
class MPP12TaskReader;
class MPP14TaskReader;
class Mpp9CalendarWriter;
class MPP9ExtendedAttributeDefinitionWriter;
class MPP9OutlineCodeDefinitionWriter;
class MPPExtendedAttributeWriter;
class MPPOutlineCodeDefinitionWriter;
class MppPdfOleObjectWriter;
class MppTimephasedDataWriter;
class VarVarWriter;
} // namespace MSProject
namespace PrimaveraXml
{
class PrimaveraReader;
} // namespace PrimaveraXml
} // namespace IO
class OptimizedForSearchingTimephasedDataCollection;
class PluginLicensesHelper;
namespace Saving
{
class MpxSavingUtils;
class TemplateProjectLoader;
} // namespace Saving
namespace Util
{
class ByteSpan;
} // namespace Util
} // namespace Tasks
} // namespace Aspose
 
namespace Aspose {
 
namespace Tasks {
 
namespace Util {
 
/// <summary>
/// Utility class for list processing.
/// </summary>
class ASPOSE_TASKS_SHARED_CLASS ListUtils
{
    typedef ListUtils ThisType;
    
    friend class Aspose::Tasks::IO::MSProject::Metadata::VarDataOffsets;
    friend class Aspose::Tasks::IO::MSProject::Decryptor::MPP14StreamEncryptorDecryptorBase;
    friend class Aspose::Tasks::IO::MSProject::Metadata::FixedDataOffsets;
    friend class Aspose::Tasks::IO::MSProject::MppPdfOleObjectWriter;
    friend class Aspose::Tasks::IO::PrimaveraXml::PrimaveraReader;
    friend class Aspose::Tasks::PluginLicensesHelper;
    friend class Aspose::Tasks::Saving::TemplateProjectLoader;
    friend class Aspose::Tasks::IO::MSProject::Decryptor::AgilePasswordVerifier;
    friend class Aspose::Tasks::IO::MSProject::MPP12TaskReader;
    friend class Aspose::Tasks::IO::MSProject::MPP14TaskReader;
    friend class Aspose::Tasks::IO::MSProject::FixedWriter;
    friend class Aspose::Tasks::IO::MSProject::Mpp12CalendarWriter;
    friend class Aspose::Tasks::IO::MSProject::MPPExtendedAttributeWriter;
    friend class Aspose::Tasks::IO::MSProject::MPPOutlineCodeDefinitionWriter;
    friend class Aspose::Tasks::IO::MSProject::Mpp9CalendarWriter;
    friend class Aspose::Tasks::IO::MSProject::MPP9ExtendedAttributeDefinitionWriter;
    friend class Aspose::Tasks::IO::MSProject::MPP9OutlineCodeDefinitionWriter;
    friend class Aspose::Tasks::IO::MSProject::MppTimephasedDataWriter;
    friend class Aspose::Tasks::IO::MSProject::VarVarWriter;
    friend class Aspose::Tasks::OptimizedForSearchingTimephasedDataCollection;
    friend class Aspose::Tasks::Saving::MpxSavingUtils;
    friend class Aspose::LicenseV2::LicenseCore;
    
public:
 
    /// <summary>
    /// Apply algorithm for each list element starting from specified position.
    /// </summary>
    /// <param name="list">List to process.</param>
    /// <param name="algorithm">Applied algorithm.</param>
    /// <param name="startIndex">Start element position.</param>
    /// <typeparam name="T">The type of object to apply algorithm to.</typeparam>
    template <typename T>
    static void Apply(const System::SharedPtr<System::Collections::Generic::IList<T>>& list, const System::SharedPtr<IAlgorithm<T>>& algorithm, int32_t startIndex)
    {
        for (int32_t i = startIndex; i < list->get_Count(); i++)
        {
            T el = list->idx_get(i);
            algorithm->PreAlg(el, i);
            algorithm->Alg(el, i);
            algorithm->PostAlg(el, i);
        }
    }
    
    /// <summary>
    /// Filter list elements by specified condition.
    /// </summary>
    /// <param name="list">A list to process.</param>
    /// <param name="cond">Condition used to filter the specified list.</param>
    /// <typeparam name="T">The type of object to apply filter to.</typeparam>
    /// <returns>Filtered list.</returns>
    template <typename T>
    static System::SharedPtr<System::Collections::Generic::IList<T>> Filter(const System::SharedPtr<System::Collections::Generic::IList<T>>& list, const System::SharedPtr<ICondition<T>>& cond)
    {
        System::SharedPtr<System::Collections::Generic::IList<T>> result = System::MakeObject<System::Collections::Generic::List<T>>();
        for (int32_t i = 0; i < list->get_Count(); i++)
        {
            if (cond->Check(list->idx_get(i)))
            {
                result->Add(list->idx_get(i));
            }
        }
        
        return result;
    }
    
    /// <summary>
    /// Find first occurrence of an list element which satisfy specified condition.
    /// </summary>
    /// <param name="list">A list to process.</param>
    /// <param name="cond">Condition used to find an element in the specified list.</param>
    /// <typeparam name="T">The type of object to find.</typeparam>
    /// <returns>List element or null.</returns>
    template <typename T>
    static T Find(const System::SharedPtr<System::Collections::Generic::IList<T>>& list, const System::SharedPtr<ICondition<T>>& cond)
    {
        for (int32_t i = 0; i < list->get_Count(); i++)
        {
            if (cond->Check(list->idx_get(i)))
            {
                return list->idx_get(i);
            }
        }
        
        return System::Default<T>();
    }
    
    
protected:
 
    static ASPOSE_TASKS_SHARED_API void Resize(System::ArrayPtr<uint8_t>& array, int32_t newSize);
    static ASPOSE_TASKS_SHARED_API System::ArrayPtr<uint8_t> Concat(const System::ArrayPtr<uint8_t>& arr1, const System::ArrayPtr<uint8_t>& arr2);
    static ASPOSE_TASKS_SHARED_API bool Equal(const System::ArrayPtr<uint8_t>& arr1, const System::ArrayPtr<uint8_t>& arr2);
    static ASPOSE_TASKS_SHARED_API bool IsBlank(const System::ArrayPtr<uint8_t>& arr);
    static ASPOSE_TASKS_SHARED_API bool IsBlank(ByteSpan span);
    template <typename T>
    static System::SharedPtr<System::Collections::Generic::List<T>> ToList(const System::SharedPtr<System::Collections::Generic::IEnumerable<T>>& sequence)
    {
        System::SharedPtr<System::Collections::Generic::List<T>> result = System::MakeObject<System::Collections::Generic::List<T>>();
        for (auto&& element : System::IterateOver(sequence))
        {
            result->Add(element);
        }
        
        return result;
    }
    
    template <typename T>
    static int32_t BinarySearch(const System::SharedPtr<System::Collections::Generic::IList<T>>& array, int32_t index, int32_t length, T value, const System::SharedPtr<System::Collections::Generic::IComparer<T>>& comparer)
    {
        int32_t num = index;
        int32_t num2 = index + length - 1;
        while (num <= num2)
        {
            int32_t num3 = num + ((num2 - num) >> 1);
            int32_t num4 = comparer->Compare(array->idx_get(num3), value);
            if (num4 == 0)
            {
                return num3;
            }
            
            if (num4 < 0)
            {
                num = num3 + 1;
            }
            else
            {
                num2 = num3 - 1;
            }
        }
        
        return ~num;
    }
    
    template <typename T>
    static void CopyElements(const System::SharedPtr<System::Collections::Generic::ICollection<T>>& source, const System::SharedPtr<System::Collections::Generic::ICollection<T>>& target)
    {
        for (auto&& element : System::IterateOver(source))
        {
            target->Add(element);
        }
    }
    
    
public:
    ListUtils() = delete;
};
 
} // namespace Util
} // namespace Tasks
} // namespace Aspose