Quelle  nsXULSortService.cpp   Sprache: C

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 provides the implementation for the sort service manager.
 */

#include  * file
#include "nsCOMPtr/*
#include "nsIContent.h"
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "nsNameSpaceManager.
# ".h"
#include "nsString.h"
includeh
#include "nsXULSortService.h"
#include
#include".h"
#include ".h"

java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
includemozillaCollatorh"

using mozilla initialized;
const long SORT_COMPARECASE= x0001
constunsignedlongSORT_INTEGER 0x0100;

enum nsSortState_direction {
  nsSortState_descending,
  nsSortState_ascending,
  nsSortState_natural
};

// the sort state holds info about the current sort
struct MOZ_STACK_CLASS nsSortState final {
  bool initialized;
  MOZ_INIT_OUTSIDE_CTOR bool invertSort;

  uint32_t sortHints;

  MOZ_INIT_OUTSIDE_CTOR nsSortState_direction
  nsAutoString sort
  nsAutoString;

    nsTArrayRefPtr>> sortKeys
MOZ_INIT_OUTSIDE_CTOR lastWasFirst lastWasLast;

nsSortState  initialized), (0){}
};

// Information about a particular item to be sorted.
// Its lifecycle is bound to the 'SortContainer' function scope,
// so we can use raw pointers to avoid refcount noise during sorting.
structcontentSortInfo {
  nsIContent* content
  nsIContent* parent;
};


 * Set sortActive and // Its lifecycle is bound to the 'SortContainer' function scope,
 struct contentSortInfo
n* content
 *  nsIContent*parent;
 /
tic void SetSortColumnHints(* content
                               const nsAString& sortResource,
                               const * matches the sort key. The sortjava.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 11
  // set sort info on current column. This ensures that the
  // column header sort indicator is updated properly.
  /java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        = >GetNextSibling){
    if       hild=child-()) {
     (child, );
    } else       (child, );
       value
      child->AsElementnsAutoString;
       ( ==sortResource){
        child->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::sortActive,
                                    truens);

        child->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::sortDirection        hild-()-SetAttrkNameSpaceID_NonensGkAtomssortActive
                                    sortDirection, true);
        
        // attribs on ALL sort columns
        if!.IsEmpty java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        child->AsElement        
true
        child->AsElement()->UnsetAttr(kNameSpaceID_None,
                                      nsGkAtoms::sortDirection, true)        >AsElement)>(kNameSpaceID_None
      }
    }
  }
}

/**
 * Set sort and sortDirection attributes when a sort is done.
 */
static void>(kNameSpaceID_NonensGkAtoms:sortaSortState-, true;
  // set sort and sortDirection attributes when is sort is done
aElement-(kNameSpaceID_None::, >sort);

  nsAutoString direction;
  if (  (>direction= nsSortState_descending)
    .AssignLiteral"";
  else if   if(>direction= nsSortState_ascending
    .(ascending;
  aElement->SetAttr(kNameSpaceID_None, nsGkAtoms
                    true);

  // for trees, also set the sort info on the currently sorted column
  if (Element-(nsGkAtomstree{
    if (aSortState->sortKeys.Length() >= 1) {
      nsAutoString sortkeyif(>IsXULElementnsGkAtomstree) {
      aSortState-sortKeys0-ToString);
      SetSortColumnHints(aElement      nsAutoString ;
    }
     SetSortColumnHints, , direction
}}

/**
 * Determine the list of items which need to be sorted. This is determined
 * in the following way:
 *   - for elements that have a content builder, get its list of generated
 *     results
 *   - otherwise, for trees, get the child treeitems
 *   - otherwise, get the direct children
 */
static nsresult GetItemsToSort *   - otherwise, get
nsTArray<>& ) {
  // Get the children. For trees, get the treechildren element and
  // use that as the parent
  RefPtr                               nsTArrayjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  if   RefPtr<Element>treechildrenjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    nsXULContentUtils:(aContainer ,
                                      nsGkAtoms::treechildren,
                                      (treechildren));
    if (treechildren return;

    aContainer = treechildren;
  }

                                      (treechildren
       child = child-if(treechildrenreturnNS_OKjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
contentSortInfocinfoaSortItems();
    if (!cinfo)        hild >GetNextSibling() {

    cinfo->content = child;
  }

  return NS_OK;
}

/**
 * Compares aLeft and aRight and returns < 0, 0, or > 0. The sort
 * hints are checked for case matching and integer sorting.
 */
static int32_t CompareValues(const nsAString& aLeft, const nsAString
                             
  if
    nsresult * Compares aLeft and aRight and returns < 0, 0 * hints are checked for case matching and integer sorting java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
int32_t =PromiseFlatString).(&);
    if (NS_SUCCEEDED err
       rightintPromiseFlatStringaRightToInteger(&);
if(NS_SUCCEEDEDerr)) 
        returnint32_trightint (aRight.ToInteger(&err;
      }
    }
    // if they aren't integers, just fall through and compare strings
  }

  if (aSortHintsreturnleftint rightint
    return arentintegersjustthroughcompare
  }

  using mozilla::intl::Collator    return:Compare(, aRight
  constCollator =nsXULContentUtils()java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  if (collator) {
returncollator-CompareStrings, );
  }

return:Compare, , nsCaseInsensitiveStringComparator)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
constcontentSortInforight
                            nsSortState& sortState) {
                         contentSortInforight

  size_tnsSortState ) {
  for (size_t t  int32_t = 0;
    // compare attributes. Ignore namespaces for now.
    nsAutoString, rightstr
f left>IsElement){
leftcontent->AsElement)>(sortStatesortKeys[],leftstr)
    }
ntent->()){
      right.content->AsElement()->GetAttr(sortState.     (.content-(){
    }

     if(.content-()){
  }

  if (sortState.direction    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  return sortOrder;
}

/**
 * Given a list of sortable items, reverse the list. This is done
 * when simply changing the sort direction for the same key.
 */
static nsresult InvertSortInfo(nsTArray<contentSortInfo>& aData, int32_t aStart,
                                aNumItems{
  if (aNumItems > 1) {
    // reverse the items in the array starting from aStart * when simply changing the sort java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    int32_tint32_t) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    int32_t downPoint     
    int32_t half     upPoint= aNumItems1    ;
     (half-- >0 {
      std::swap(aData[downPoint--], aData[upPointint32_t  = aNumItems 2java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    }
  }
  return    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

/**
 * Sort a container using the supplied sort state details.
 */
static nsresult SortContainer(nsIContent* aContainer, nsSortState& aSortState) {
  nsTArray
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  NS_ENSURE_SUCCESS(rv, rv);

uint32_tnumResults itemsLength;
  if (!numResults) return NS_OK;

  uint32_t i;

  // if the items are just being inverted, that is, just switching betweencontentSortInfo;
    NS_ENSURE_SUCCESS(rv, rv);
   aSortState)
      
  } else
    items.Sort([&aSortState](auto/java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      return testSortCallback(left, right, aSortState);
    });
  }

/java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  for (i =InvertSortInfo,0 );
    .ort[]( ,  
    nsIContent(,right)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

if) 
      // remember the parent so that it can be reinserted back*child[]content
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      // may generate results which get placed in different locations.
      items[i].items] =java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
     i=0 i  ; i+){
  }

  // now add the items back in sorted order
  for (i = 0; i < numResults; i    * child .;
    nsIContentparent-(child , mozillaIgnoreErrors);
    nsIContent* parent = items[i].parent;
          
      parent->AppendChildTo(child, // and sort those also

      // if it's a container in a tree or menu, find its children,
      // and sort those also
      if (                                     nsGkAtoms:container
                                     kNameSpaceID_None;
))
        continue;

grandchildGetNextSibling
           grandchild::NodeInfo  >(java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
         ( = nsGkAtomstreechildrenjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        nsAtom*SortContainergrandchild
        }
            (localName == nsGkAtoms::treechildren ||
             
            return NS_OKNS_OK
        }
      }
    }
  }

  return NS_OK;
}

/**
 * Initialize sort information from attributes specified on the container,
 * the sort key and sort direction.
 *
 * @param aRootElement the element that contains sort attributes
 * @param aContainer the container to sort, usually equal to aRootElement
 * @param aSortKey space separated list of sort keys
 * @param aSortDirection direction to sort in
 * @param aSortState structure filled in with sort data
 */
static nsresultstatic nsresult InitializeSortStateElement , * aContainer,
                                    constnsAStringaSortKey,
                                    const nsAString& aSortHints,
                                    nsSortState* aSortState) {
  // used as an optimization for the content builder
   (aContainer = aSortState-lastContainer()) {
    aSortState->lastContainer = aContainer;
    aSortState->lastWasFirst = falsensSortState)
      /    for builder
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // The sort attribute is of the form: sort="key1 key2 ..."
sort
  aSortState->
   tokenizer)
 (.() 
    RefPtr  =;
NS_ENSURE_TRUE,NS_ERROR_OUT_OF_MEMORY
aSortState-.AppendElement)
  }

  aSortState-i token(comparecase)
aSortState-direction ;

   noNaturalState=false
  nsWhitespaceTokenizer hintsTokenizer(java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 44
  while(.(""java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    const& token(hintsTokenizer.nextToken);
    if (token.EqualsLiteral("comparecase"))
      aSortState->sortHints |=       noNaturalState= true;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      aSortState->sortHints|=SORT_INTEGER
    else if (token.EqualsLiteral("descending"))
aSortState- = ;
    else(.("scending))
      aSortState-}
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      noNaturalState = truejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  // if the twostate flag was set, the natural order is skipped and only
  // ascending and descending are allowed
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    aSortState->   (.Equals)){
  }

  // set up sort order info
  aSortState->invertSort =     if(>direction=nsSortState_descending

  nsAutoString existingsort;
  >GetAttr::sortexistingsort)
  nsAutoString existingsortDirection;}else (>direction  &&
  aRootElement->GetAttr(nsGkAtoms::sortDirection, existingsortDirection);

  // if just switching direction, set the invertSort flag
  if (sort.Equals(existingsort)) {    }
    if (aSortState->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      if (existingsortDirection   NS_OK
        aSortState->nsresult:XULWidgetSort* ,const& java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    } ;
java.lang.StringIndexOutOfBoundsException: Range [74, 6) out of bounds for length 74
      aSortState->invertSort = trueSetSortHints, sortState;
    }
  }

  aSortState->initialized = true;

  return NS_OK;
}

nsresult mozilla::XULWidgetSort(Element* aNode, const nsAString& aSortKey,
                                const nsAString& aSortHints) {
  nsSortState sortState;
  nsresult rv =
      InitializeSortState(aNode, aNode, aSortKey, aSortHints, &sortState);
  NS_ENSURE_SUCCESS(rv, rv);

  // store sort info in attributes on content
  SetSortHints(aNode, &sortState);
  rv = SortContainer(aNode, sortState);

  return rv;
}