SSL table7.cxx   Sprache: C

 java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
/*
 * 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/.
 */

#{
#include <clipcontext    const     assert(    for (SCCOL nCol = rRange.aStart        CreateColumnIfNotExists(nCol).SwapNonEmpty(rValues,}
#{
    for (SCCOL].PreprocessRangeNameUpdate(rEndListenCxt}
#include <segmenttree.hxx>
#include <sharedformula{
#    for (SCCOL i = 0        aCol[i].PreprocessDBDataUpdate(}
#include <olinetab.hxx>
#include {
#include <columniterator.hxx>
#include <drwlayer.hxx>
#include <compressedarray.hxx>

#include <osl/diagnose.h>
#include <sal/log.hxx>
#include <tools/stream.hxx>

bool ScTable::IsMerged( SCCOL    for (SCCOL i = 0; i         aCol[i].CompileHybridFormula(}
{
    if (!{
        return    if (!IsColValid(nCol1) |        return;

    return aCol[nCol].IsMerged(nRow);
}

sc:}
{
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return }

    if (nCol1 > nCol2 || nRow1 > nRow2)
        // invalid range.
        return sc::MultiDataCellState();

    if (aCol.empty())
        return sc::MultiDataCellState({

    auto setFirstCell    if (!IsColValid(nCol))
    {
        if (rRet.mnCol1 <}
        {
            // First cell not yet set.  Set it.
            rRet.mnCol1 = nCurCol;
            
            sc::SharedFormulaUtil::unshareFormulaCells(rDocument,}
    };

void ScTable::RegroupFormulaCells( SCCOL nCol )
    bool     if (!IsColValid(nCol        return;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    for (SCCOL nCol = nCol1; nCol{
    {
        SCROW nFirstDataRow = -1;
        switch (aCol[
        t SCCOL nMaxCol2 = std::min<SCCOL>( nCol2
            case sc::MultiDataCellState        if (aCol[nCol].HasFormulaCell(            return true;
            {
                setFirstCell(aRet, nCol, nFirstDataRow);

                    if (!IsColValid(nCol))
                ndListeningIntersectedGroup(rCxt, nRow, pGroupPos);
                    
                    aRet.meState    sc::EndListeningContext& rCxt, const SCCOL nCol1, SCROW    std::vector<ScAddress{
                    : GetAllocatedColumnsRange(nCol1, nCol2))
                }
                bHasOnevoid ScTable::EndListeningGroup( sc{
        return;
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            case sc::MultiDataCellState::HasMultipleCells:
            {
                setFirstCell(aRet        return;

    CreateColumnIfNotExists(nCol).SetNeedsListeningGroup(nRow);
                return bool ScTable::IsEditActionAllowed( sc::EditAction eAction,    SCCOL{
            }
        SCROWjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            {
                ;
        }
    }

                    nCol2 = nEndCol;
        aRet.meState            case sc::EditAction:            case sc::EditAction::InsertRowsAfter:

    return                nRow2 = nEndRow;
}

void ScTable            default:
        }
{
    sc:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (!ValidCol(
            if (IsScenario())

    // Pass some stuff to the columns via context.
    rCxt.setTableProtected(IsProtected        return false;
    rCxt.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0

    ScRange        case sc        {
    SCCOL            if (                return false
            {           // TODO: improve the matrix range handling for the insert-before action.            if (                return
        const         }        case sc        {
        for        }
        {            if                return true;
            
    return false}

            const ScColumn& rClipCol = const_cast<ScTable{
            aCol    return const_cast<ScTable*>(this)->CreateColumnIfNotExists(nCol).GetColumnIterator(}
        }
    }

    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
}

void ScTable::CopyOneCellFromClip(
    sc        bool bRet =        bAnyDirty = bAnyDirty || bRet;
{
    ScRange aSrcRange =    return bAnyDirty;
    SCCOL nSrcColSize OutlineImport()

    for (SCCOL nCol    if (pOutlineTable && pRowFlags)
    {
        SCCOL nColOffset = nCol - nCol1;
        nColOffset }
        assert
        CreateColumnIfNotExistsvoid ScTable::StoreToCache(SvStream& rStrm) const

        if (rCxt.getInsertFlag() & java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 24
        {
            for (SCROW nRow = nRow1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                CopyConditionalFormat        aCol[nCol].StoreToCache(rStrm);
                        nRow - java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
    }

    if    rStrm.ReadUInt64(nCols);
    {
        mpRowHeights->setValue(nRow1    {

        if (pRowFlags && pSrcTab->pRowFlags    }
           if (pSrcTab->pRowFlags->OString ScTable::dumpSheetGeomData(bool bColumns{
               eetGeomType::SIZES:
           else            // returns a non-empty space separated list of spans with trailing space.
               pRowFlags->AndValue(nRow1, ~CRFlags::ManualSize);
        }
    }

    // Copy graphics over too
    bool bCopyGraphics
        = (rCxt.getInsertFlag() & InsertDeleteFlags::OBJECTS)         case SheetGeomType::HIDDEN:
    if (!(bCopyGraphics && rCxt            // The format of the span is:
        return;

    ScDrawLayer* pDrawLayer = GetDoc().GetDrawLayer();
    OSL_ENSURE(pDrawLayer, "No drawing layer");
    if (pDrawLayer)
    {
        const ScAddress aSrcStartPos
            = rCxt.getClipDoc()->GetClipParam().getWholeRange().aStart;
        const ScAddress aSrcEndPos = rCxt.getClipDoc()->GetClipParam().getWholeRange().aEnd;
        ScRange aSourceRange(aSrcStartPos, aSrcEndPos);
        ScRange aDestRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab);
        pDrawLayer->CopyFromClip(rCxt.getClipDoc()->mpDrawLayer.get(), aSrcStartPos.Tab(),
                                 aSourceRange            // spans can have the same state by definition of span.
    }
}

void ScTable::SetValues( const SCCOL nCol, const SCROW nRow, const std::vector<double>& rVals )
{
    if (!ValidCol(nCol))
        return;

    CreateColumnIfNotExists(nCol).SetValues(nRow, rVals);
}

void ScTable::TransferCellValuesTo( const SCCOL nCol, SCROW nRow, size_t nLen, sc::CellValues& rDest )
{
    if (!ValidCol(nCol))
        return;

    CreateColumnIfNotExists(nCol).TransferCellValuesTo(nRow, nLen, rDest);
}

void ScTable::CopyCellValuesFrom( const SCCOL nCol, SCROW nRow, const sc::CellValues& ;rSrc )
{
    if            // has exactly the same format as 'hidden'.
        return;

    CreateColumnIfNotExists(nCol).CopyCellValuesFrom            return dumpHiddenFiltered(bColumns /*bHidden*/ false);
}

void ScTable::ConvertFormulaToValue(
    sc::EndListeningContext& rCxt, //returnsaspaceseparated   levels' with trailing space.
    sc::TableValues//  'level'is a comma separated  groups(outlineentrieswithtrailingcomma.
{
    if (!ValidCol(nCol1) ||            
        return;

    for (SCCOL nCol =nCol1; nCol<=nCol2;+nCol)
         CreateColumnIfNotExists(nCol).ConvertFormulaToValue(rCxt, nRow1, nRow2, pUndo);
}

void ScTable::SwapNonEmpty(
    sc::TableValues& rValues,:
{
    const ScRange& rRange = rValues ;
    assert(rRange.IsValid     "ostr;
    for
        CreateColumnIfNotExistsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void ScTable::PreprocessRangeNameUpdate(
    sc:EndListeningContext& rEndListenCxt, sc::CompileFormulaContext&  )
{
    for (SCCOL    // rows/cols have the default sizes.
        aCol[i].PreprocessRangeNameUpdate(rEndListenCxt, rCompileCxt);
}

void     static constOString aDefaultForCols
    ::EndListeningContext EndListenCxt,sc:&  )
{
    for (SCCOL i = 0; i     taticOStringaDefaultForRows
        Coli.(rEndListenCxtrCompileCxt)
}

void
    sc::StartListeningContext// ScCompressedArray is a template class and we don't want to impose
{
    for (SCCOL i = 0; i < aCol.autodumpColWidths= [](const rWidths >OString{
        aCol[i].CompileHybridFormula(rStartListenCxt, rCompileCxt);
}

void S   0
{
if(|nCol2| nCol1)
        return.:()+: :nEndColjava.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91

    const SCCOL}

     SCCOL=;  <;+
        aCol[mpColWidth() aDefaultForCols
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
ifValidRow)|!(nRow2||nRow1>nRow2
        return false;

    ScFlatUInt16RowSegments::RangeData aData;
    if returnmpHiddenRows  pHiddenRows-dumpAsString(  aDefaultForRows
        // Search failed.
        return false;

    return nRow2 <= aData.mnRow2;
}

void ScTable::SplitFormulaGroups( SCCOL nCol, std::vector<SCROW>& rRows )
{
    if (!java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
        return;

    if(!pOutlineTable
}

void ScTable::UnshareFormulaCells( SCCOL
{
    ifr >(.(;
        return;

    sc::SharedFormulaUtil::unshareFormulaCells(rDocument, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void ScTable
{
     (IsColValidnCol)
        return;

    aCol[nCol    returnCol);
}

bool ScTable::HasFormulaCellSCROW :GetLOKFreezeRow)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
    ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        returnfalsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

    const SCCOL nMaxCol2 = std::min    {

    for (SCCOL nCol         eturnfalse
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
return;

    return false;
}

void ScTable    {
    sc::        maLOKFreezeCell.(nFreezeCol;
{
    if (!IsColValid(nCol))
        return;

    aCol[nCol].EndListeningIntersectedGroup(rCxt, nRow, pGroupPos);
}

voidreturnfalse;
    sc::EndListeningContext& rCxt, const SCCOL nCol1, SCROW nRow1,}
    std::vector<java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
{
    if java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
        return;

    for (SCCOL nCol : GetAllocatedColumnsRange(nCol1, nCol2))
        aCol[nCol].EndListeningIntersectedGroups(rCxt, nRow1, nRow2, pGroupPos);
}

void ScTable::EndListeningGroup( sc::EndListeningContext& rCxt, const SCCOL nCol, SCROW nRow )
{
    if (!IsColValid(nCol))
        return;

    aCol[nCol].EndListeningGroup(rCxt, nRow);
}

void ScTable::SetNeedsListeningGroup( SCCOL nCol, SCROW nRow )
{
    if (!ValidCol(nCol))
        return;

    CreateColumnIfNotExists(nCol).SetNeedsListeningGroup(nRow);
}

bool ScTable::IsEditActionAllowed( sc::EditAction eAction, SCCOL nStartCol, SCROW nStartRow,
    SCCOL nEndCol, SCROW nEndRow ) const
{
    if (!IsProtected())
    {
        SCCOL nCol1 = 0, nCol2 = aCol.size() - 1;
        SCROW nRow1 = 0, nRow2 = rDocument.MaxRow();

        switch (eAction)
        {
            case sc::EditAction::InsertColumnsBefore:
            case sc::EditAction::InsertColumnsAfter:
            case sc::EditAction::DeleteColumns:
            {
                nCol1 = nStartCol;
                nCol2 = nEndCol;
                break;
            }
            case sc::EditAction::InsertRowsBefore:
            case sc::EditAction::InsertRowsAfter:
            case sc::EditAction::DeleteRows:
            {
                nRow1 = nStartRow;
                nRow2 = nEndRow;
                break;
            }
            default:
                ;
        }

        return IsBlockEditable(nCol1, nRow1, nCol2, nRow2, nullptr);
    }

    if (IsScenario())
        // TODO: I don't even know what this scenario thingie is. Perhaps we
        // should check it against the scenario ranges?
        return false;

    assert(pTabProtection);

    switch (eAction)
    {
        case sc::EditAction::InsertColumnsBefore:
        case sc::EditAction::InsertColumnsAfter:
        {
            // TODO: improve the matrix range handling for the insert-before action.
            if (HasBlockMatrixFragment(nStartCol, nStartRow, nEndCol, nEndRow))
                return false;

            return pTabProtection->isOptionEnabled(ScTableProtection::INSERT_COLUMNS);
        }
        case sc::EditAction::InsertRowsBefore:
        case sc::EditAction::InsertRowsAfter:
        {
            // TODO: improve the matrix range handling for the insert-before action.
            if (HasBlockMatrixFragment(nStartCol, nStartRow, nEndCol, nEndRow))
                return false;

            return pTabProtection->isOptionEnabled(ScTableProtection::INSERT_ROWS);
        }
        case sc::EditAction::DeleteColumns:
        {
            if (!pTabProtection->isOptionEnabled(ScTableProtection::DELETE_COLUMNS))
                return false;

            return !HasAttrib(nStartCol, nStartRow, nEndCol, nEndRow, HasAttrFlags::Protected);
        }
        case sc::EditAction::DeleteRows:
        {
            if (!pTabProtection->isOptionEnabled(ScTableProtection::DELETE_ROWS))
                return false;

            return !HasAttrib(nStartCol, nStartRow, nEndCol, nEndRow, HasAttrFlags::Protected);
        }
        case sc::EditAction::UpdatePivotTable:
        {
            if (pTabProtection->isOptionEnabled(ScTableProtection::PIVOT_TABLES))
                return true;

            return !HasAttrib(nStartCol, nStartRow, nEndCol, nEndRow, HasAttrFlags::Protected);
        }
        default:
            ;
    }

    return false;
}

std::optional<sc::ColumnIterator> ScTable::GetColumnIterator( SCCOL nCol, SCROW nRow1, SCROW nRow2 ) const
{
    if (!ValidCol(nCol))
        return {};

    return const_cast<ScTable*>(this)->CreateColumnIfNotExists(nCol).GetColumnIterator(nRow1, nRow2);
}

bool ScTable::EnsureFormulaCellResults( const SCCOL nCol1, SCROW nRow1, const SCCOL nCol2, SCROW nRow2, bool bSkipRunning )
{
    if (nCol2 < nCol1 || !IsColValid(nCol1) || !ValidCol(nCol2))
        return false;

    const /*

    bool bAnyDirty = false;

    for (SCCOL nCol = nCol1 *
    {
         * License, v. 2.0. If a  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
        = bAnyDirty |bRet
    

     bAnyDirtyjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

void ScTable::finalizeOutlineImport()
{
    ifpOutlineTable &p)
    {
        pOutlineTable->GetRowArray().finalizeImport(*this);
    }
}

void ScTable::StoreToCache(SvStream& rStrm) const
{
    SCCOL *
    SCCOL nEndCol = rDocument.MaxCol();
    SCROW * License, v. 2.0. If a copy of the MPL was not distributed with * file, You can obtain one at http://mozilla.org/MPL/2.0/.
    SCROWnEndRow rDocument.MaxRow)
include <drwlayer.hxx
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    rStrm.WriteUInt64(nEndCol + 1{
     ( nCol= 0 nCol < ; +java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 24
    {
        aCol[nCol.StoreToCache();
    }
}

void         eturn ::()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
    sal_uInt64#include <segmenttree.hxx>
    rStrm.ReadUInt64(nCols)        // invalid range.
     (    for (SCCOLscMultiDataCellState);
    {
        ifaColempty)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }
}

OString #nclude<columniterator.hxx>{
# <compressedarray>
    switch(eGeomType)
    {
        caseSheetGeomType:SIZES:
            // returns a non-empty space separated list of spans with trailing space.    if(!(nCol
Theformat thespanis < ofboolbHasOne=falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
//Examplejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
             dumpColumnRowSizes(bColumns){
            {
            // returns a non-empty space separated list of spans with trailing space.
            // The format of the span is:
                       // 1) First span:         <1 (span is hidden) / 0 (not hidden)>:<last row/col of the span>
            /(, , )
;
            /spans have samestateby  
            return(bColumns/*bHidden*/ true);
       case ::FILTERED
            // has exactly the same format as 'hidden'.
    SCCOL nMaxCol
java.lang.StringIndexOutOfBoundsException: Range [29, 8) out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
/
            // format of a group is:
            // <start row/col of group>:<number of rows/cols in the group>:<1/0(group is hidden?)>:<1/0(control is visible?)> ,aStart ,
S  .().(;
               {
            
    }

return"ostr
}p>for = mnCol1< nColjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

 :dumpColumnRowSizes bColumns( &.-mpDrawLayerjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
{
    // If the data-structures are not available, just report that all
            } getClipDocGetClipParamgetWholeRange(;
        (nCol1,nTab,nCol2 ,)
         Stringnumber  :java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1
   const java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
=:number()+"" :number    =.ColaSrcRange.)+java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

//    // ScCompressedArrayif(ValidCol(nCol)
    // the restriction that its value type should be string serializable,nColOffset=
    // instead just operate on the specialized object.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     
         aOutput
       java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  CopyConditionalFormat, ,-a(nColOffset
 
 nStartCol

    
nWidth =.nStartColnDummy nEndCol);
{
            if (nEndCol > nMaxCol
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
()SwapNonEmptyrValuesrStartCxt,rEndCxtjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
artCol= + java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        }

        return
    }java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

i (Columns)
for    if ( &r.etClipDoc)mpDrawLayerjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

    return mpRowHeights ? mpRowHeights->dumpAsString() : aDefaultForRows        [.rEndListenCxt,java.lang.StringIndexOutOfBoundsException: Range [65, 55) out of bounds for length 67
}

             .()-GetClipParam).().aStart;
{
    // defaults to no hidden/filtered row/cols.
         forSCCOL ;i <aCol.) +i)
            aDestRange(nCol1 nRow1 nCol2 nRow2 nTab;

    if
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
         (bColumns
                f !sColValidjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

        eturnmpHiddenRowsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

boolScTableHasUniformRowHeight( SCROW nRow1SCROWnRow2 
    f(ValidRownRow1 |!ValidRow

    returnmpFilteredRowsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

OStringScTable:dumpColumnRowGroupsboolbColumns const
{
      
        return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    f()
        returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    return ScTable:UnshareFormulaCells nCol::ectorSCROW>&)
}

SCCOLScTable:GetLOKFreezeCol(const
{
    eturnmaLOKFreezeCell.Col(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}

SCROW ScTable::GetLOKFreezeRow() const
{
    eturn java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
}

bool ScTable::SetLOKFreezeCol(SCCOL nFreezeCol)
{
    if (!ValidCol(nFreezeCol))
    {
SAL_WARN"
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    :EndListeningContext,   ,std:<ScAddresspGroupPos)
java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
        maLOKFreezeCellsc:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
(    ssert.IsValid);
    }

     ;
}

 ::PreprocessRangeNameUpdate(
{
    if(ValidRow)
{
        []PreprocessRangeNameUpdate(,;
        return void ScTable::Preproc(
    }

    (.( =nFreezeRow
    
        maLOKFreezeCell.SetRow
        
    }

        
}

std:<>ScTableQueryColumnsWithFormulaCells

for =0 aCol;ijava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

    for ;
()!()|java.lang.StringIndexOutOfBoundsException: Range [55, 51) out of bounds for length 64
 )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
.pCol-()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21


java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void ScTable:return
{
 :case:EditAction
(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

ScTableCollectBroadcasterStatescBroadcasterState rState java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    for (const auto& pCol : aCol             HasBlockMatrixFragmentnStartCol, ,nEndColnEndRow)
        >CollectBroadcasterStaterState;
}

 ::<sc:>&ScTableGetSolverSettings)
{
    f(!m_pSolverSettings)
         = :make_shared<sc:SolverSettings       {

    return return ;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


/ java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24