Back to index

lightning-sunbird  0.9+nobinonly
Classes | Public Member Functions | Private Member Functions | Private Attributes
nsAttrAndChildArray Class Reference

#include <nsAttrAndChildArray.h>

Collaboration diagram for nsAttrAndChildArray:
Collaboration graph
[legend]

List of all members.

Classes

struct  Impl
struct  InternalAttr

Public Member Functions

 nsAttrAndChildArray ()
 ~nsAttrAndChildArray ()
PRUint32 ChildCount () const
nsIContentChildAt (PRUint32 aPos) const
nsIContentGetSafeChildAt (PRUint32 aPos) const
nsresult AppendChild (nsIContent *aChild)
nsresult InsertChildAt (nsIContent *aChild, PRUint32 aPos)
void RemoveChildAt (PRUint32 aPos)
PRInt32 IndexOfChild (nsIContent *aPossibleChild) const
PRUint32 AttrCount () const
const nsAttrValueGetAttr (nsIAtom *aLocalName, PRInt32 aNamespaceID=kNameSpaceID_None) const
const nsAttrValueAttrAt (PRUint32 aPos) const
nsresult SetAttr (nsIAtom *aLocalName, const nsAString &aValue)
nsresult SetAndTakeAttr (nsIAtom *aLocalName, nsAttrValue &aValue)
nsresult SetAndTakeAttr (nsINodeInfo *aName, nsAttrValue &aValue)
nsresult RemoveAttrAt (PRUint32 aPos, nsAttrValue &aValue)
const nsAttrNameGetSafeAttrNameAt (PRUint32 aPos) const
const nsAttrNameGetExistingAttrNameFromQName (const nsACString &aName) const
PRInt32 IndexOfAttr (nsIAtom *aLocalName, PRInt32 aNamespaceID=kNameSpaceID_None) const
nsresult SetAndTakeMappedAttr (nsIAtom *aLocalName, nsAttrValue &aValue, nsGenericHTMLElement *aContent, nsHTMLStyleSheet *aSheet)
nsresult SetMappedAttrStyleSheet (nsHTMLStyleSheet *aSheet)
void WalkMappedAttributeStyleRules (nsRuleWalker *aRuleWalker)
void Compact ()

Private Member Functions

 nsAttrAndChildArray (const nsAttrAndChildArray &aOther)
nsAttrAndChildArrayoperator= (const nsAttrAndChildArray &aOther)
void Clear ()
PRUint32 NonMappedAttrCount () const
PRUint32 MappedAttrCount () const
nsresult GetModifiableMapped (nsGenericHTMLElement *aContent, nsHTMLStyleSheet *aSheet, PRBool aWillAddAttr, nsMappedAttributes **aModifiable)
nsresult MakeMappedUnique (nsMappedAttributes *aAttributes)
PRUint32 AttrSlotsSize () const
PRUint32 AttrSlotCount () const
void SetChildCount (PRUint32 aCount)
void SetAttrSlotCount (PRUint32 aCount)
void SetAttrSlotAndChildCount (PRUint32 aSlotCount, PRUint32 aChildCount)
PRBool GrowBy (PRUint32 aGrowSize)
PRBool AddAttrSlot ()

Private Attributes

ImplmImpl

Detailed Description

Definition at line 69 of file nsAttrAndChildArray.h.


Class Documentation

struct nsAttrAndChildArray::Impl

Definition at line 170 of file nsAttrAndChildArray.h.

Collaboration diagram for nsAttrAndChildArray::Impl:
Class Members
PRUint32 mAttrAndChildCount
void * mBuffer
PRUint32 mBufferSize
nsMappedAttributes * mMappedAttrs
struct nsAttrAndChildArray::InternalAttr

Definition at line 164 of file nsAttrAndChildArray.h.

Collaboration diagram for nsAttrAndChildArray::InternalAttr:
Class Members
nsAttrName mName
nsAttrValue mValue

Constructor & Destructor Documentation

Definition at line 113 of file nsAttrAndChildArray.cpp.

  : mImpl(nsnull)
{
}

Definition at line 118 of file nsAttrAndChildArray.cpp.

{
  if (!mImpl) {
    return;
  }

  Clear();

  PR_Free(mImpl);
}

Here is the call graph for this function:


Member Function Documentation

Definition at line 753 of file nsAttrAndChildArray.cpp.

{
  PRUint32 slotCount = AttrSlotCount();
  PRUint32 childCount = ChildCount();

  // Grow buffer if needed
  if (!(mImpl && mImpl->mBufferSize >= (slotCount + 1) * ATTRSIZE + childCount) &&
      !GrowBy(ATTRSIZE)) {
    return PR_FALSE;
  }
  void** offset = mImpl->mBuffer + slotCount * ATTRSIZE;

  if (childCount > 0) {
    memmove(&ATTRS(mImpl)[slotCount + 1], &ATTRS(mImpl)[slotCount],
            childCount * sizeof(nsIContent*));
  }

  SetAttrSlotCount(slotCount + 1);
  offset[0] = nsnull;
  offset[1] = nsnull;

  return PR_TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 85 of file nsAttrAndChildArray.h.

  {
    return InsertChildAt(aChild, ChildCount());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 320 of file nsAttrAndChildArray.cpp.

{
  NS_ASSERTION(aPos < AttrCount(),
               "out-of-bounds access in nsAttrAndChildArray");

  PRUint32 mapped = MappedAttrCount();
  if (aPos < mapped) {
    return mImpl->mMappedAttrs->AttrAt(aPos);
  }

  return &ATTRS(mImpl)[aPos - mapped].mValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 287 of file nsAttrAndChildArray.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

PRUint32 nsAttrAndChildArray::AttrSlotCount ( ) const [inline, private]

Definition at line 136 of file nsAttrAndChildArray.h.

Here is the caller graph for this function:

PRUint32 nsAttrAndChildArray::AttrSlotsSize ( ) const [inline, private]

Definition at line 131 of file nsAttrAndChildArray.h.

  {
    return AttrSlotCount() * ATTRSIZE;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 79 of file nsAttrAndChildArray.h.

  {
    NS_ASSERTION(aPos < ChildCount(), "out-of-bounds access in nsAttrAndChildArray");
    return NS_REINTERPRET_CAST(nsIContent*, mImpl->mBuffer[AttrSlotsSize() + aPos]);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 75 of file nsAttrAndChildArray.h.

Here is the caller graph for this function:

Definition at line 605 of file nsAttrAndChildArray.cpp.

{
  if (!mImpl) {
    return;
  }

  if (mImpl->mMappedAttrs) {
    NS_RELEASE(mImpl->mMappedAttrs);
  }

  PRUint32 i, slotCount = AttrSlotCount();
  for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
    ATTRS(mImpl)[i].~InternalAttr();
  }

  PRUint32 end = slotCount * ATTRSIZE + ChildCount();
  for (i = slotCount * ATTRSIZE; i < end; ++i) {
    nsIContent* child = NS_STATIC_CAST(nsIContent*, mImpl->mBuffer[i]);
    // making this PR_FALSE so tree teardown doesn't end up being
    // O(N*D) (number of nodes times average depth of tree).
    child->UnbindFromTree(PR_FALSE); // XXX is it better to let the owner do this?
    NS_RELEASE(child);
  }

  SetAttrSlotAndChildCount(0, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 572 of file nsAttrAndChildArray.cpp.

{
  if (!mImpl) {
    return;
  }

  // First compress away empty attrslots
  PRUint32 slotCount = AttrSlotCount();
  PRUint32 attrCount = NonMappedAttrCount();
  PRUint32 childCount = ChildCount();

  if (attrCount < slotCount) {
    memmove(mImpl->mBuffer + attrCount * ATTRSIZE,
            mImpl->mBuffer + slotCount * ATTRSIZE,
            childCount * sizeof(nsIContent*));
    SetAttrSlotCount(attrCount);
  }

  // Then resize or free buffer
  PRUint32 newSize = attrCount * ATTRSIZE + childCount;
  if (!newSize && !mImpl->mMappedAttrs) {
    PR_Free(mImpl);
    mImpl = nsnull;
  }
  else if (newSize < mImpl->mBufferSize) {
    mImpl = NS_STATIC_CAST(Impl*, PR_Realloc(mImpl, (newSize + NS_IMPL_EXTRA_SIZE) * sizeof(nsIContent*)));
    NS_ASSERTION(mImpl, "failed to reallocate to smaller buffer");

    mImpl->mBufferSize = newSize;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const nsAttrValue * nsAttrAndChildArray::GetAttr ( nsIAtom aLocalName,
PRInt32  aNamespaceID = kNameSpaceID_None 
) const

Definition at line 293 of file nsAttrAndChildArray.cpp.

{
  PRUint32 i, slotCount = AttrSlotCount();
  if (aNamespaceID == kNameSpaceID_None) {
    // This should be the common case so lets make an optimized loop
    for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
      if (ATTRS(mImpl)[i].mName.Equals(aLocalName)) {
        return &ATTRS(mImpl)[i].mValue;
      }
    }

    if (mImpl && mImpl->mMappedAttrs) {
      return mImpl->mMappedAttrs->GetAttr(aLocalName);
    }
  }
  else {
    for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
      if (ATTRS(mImpl)[i].mName.Equals(aLocalName, aNamespaceID)) {
        return &ATTRS(mImpl)[i].mValue;
      }
    }
  }

  return nsnull;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 479 of file nsAttrAndChildArray.cpp.

{
  PRUint32 i, slotCount = AttrSlotCount();
  for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
    if (ATTRS(mImpl)[i].mName.QualifiedNameEquals(aName)) {
      return &ATTRS(mImpl)[i].mName;
    }
  }

  if (mImpl && mImpl->mMappedAttrs) {
    return mImpl->mMappedAttrs->GetExistingAttrNameFromQName(aName);
  }

  return nsnull;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsAttrAndChildArray::GetModifiableMapped ( nsGenericHTMLElement aContent,
nsHTMLStyleSheet aSheet,
PRBool  aWillAddAttr,
nsMappedAttributes **  aModifiable 
) [private]

Definition at line 654 of file nsAttrAndChildArray.cpp.

{
  *aModifiable = nsnull;

  if (mImpl && mImpl->mMappedAttrs) {
    *aModifiable = mImpl->mMappedAttrs->Clone(aWillAddAttr);
    NS_ENSURE_TRUE(*aModifiable, NS_ERROR_OUT_OF_MEMORY);

    NS_ADDREF(*aModifiable);
    
    return NS_OK;
  }

  NS_ASSERTION(aContent, "Trying to create modifiable without content");

  nsMapRuleToAttributesFunc mapRuleFunc =
    aContent->GetAttributeMappingFunction();
  *aModifiable = new nsMappedAttributes(aSheet, mapRuleFunc);
  NS_ENSURE_TRUE(*aModifiable, NS_ERROR_OUT_OF_MEMORY);

  NS_ADDREF(*aModifiable);

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 460 of file nsAttrAndChildArray.cpp.

{
  PRUint32 mapped = MappedAttrCount();
  if (aPos < mapped) {
    return mImpl->mMappedAttrs->NameAt(aPos);
  }

  // Warn here since we should make this non-bounds safe
  aPos -= mapped;
  PRUint32 slotCount = AttrSlotCount();
  NS_ENSURE_TRUE(aPos < slotCount, nsnull);

  void** pos = mImpl->mBuffer + aPos * ATTRSIZE;
  NS_ENSURE_TRUE(*pos, nsnull);

  return &NS_REINTERPRET_CAST(InternalAttr*, pos)->mName;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 130 of file nsAttrAndChildArray.cpp.

{
  if (aPos < ChildCount()) {
    return ChildAt(aPos);
  }
  
  return nsnull;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRBool nsAttrAndChildArray::GrowBy ( PRUint32  aGrowSize) [private]

Definition at line 719 of file nsAttrAndChildArray.cpp.

{
  PRUint32 size = mImpl ? mImpl->mBufferSize + NS_IMPL_EXTRA_SIZE : 0;
  PRUint32 minSize = size + aGrowSize;

  if (minSize <= ATTRCHILD_ARRAY_LINEAR_THRESHOLD) {
    do {
      size += ATTRCHILD_ARRAY_GROWSIZE;
    } while (size < minSize);
  }
  else {
    size = PR_BIT(PR_CeilingLog2(minSize));
  }

  Impl* newImpl = NS_STATIC_CAST(Impl*,
      mImpl ? PR_Realloc(mImpl, size * sizeof(void*)) :
              PR_Malloc(size * sizeof(void*)));
  NS_ENSURE_TRUE(newImpl, PR_FALSE);

  Impl* oldImpl = mImpl;
  mImpl = newImpl;

  // Set initial counts if we didn't have a buffer before
  if (!oldImpl) {
    mImpl->mMappedAttrs = nsnull;
    SetAttrSlotAndChildCount(0, 0);
  }

  mImpl->mBufferSize = size - NS_IMPL_EXTRA_SIZE;

  return PR_TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRInt32 nsAttrAndChildArray::IndexOfAttr ( nsIAtom aLocalName,
PRInt32  aNamespaceID = kNameSpaceID_None 
) const

Definition at line 496 of file nsAttrAndChildArray.cpp.

{
  PRInt32 idx;
  if (mImpl && mImpl->mMappedAttrs) {
    idx = mImpl->mMappedAttrs->IndexOfAttr(aLocalName, aNamespaceID);
    if (idx >= 0) {
      return idx;
    }
  }

  PRUint32 i;
  PRUint32 mapped = MappedAttrCount();
  PRUint32 slotCount = AttrSlotCount();
  if (aNamespaceID == kNameSpaceID_None) {
    // This should be the common case so lets make an optimized loop
    for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
      if (ATTRS(mImpl)[i].mName.Equals(aLocalName)) {
        return i + mapped;
      }
    }
  }
  else {
    for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
      if (ATTRS(mImpl)[i].mName.Equals(aLocalName, aNamespaceID)) {
        return i + mapped;
      }
    }
  }

  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 214 of file nsAttrAndChildArray.cpp.

{
  if (!mImpl) {
    return -1;
  }
  void** children = mImpl->mBuffer + AttrSlotsSize();
  // Use signed here since we compare count to cursor which has to be signed
  PRInt32 i, count = ChildCount();

  if (count >= INDEX_CACHE_CHILD_LIMIT) {
    PRInt32 cursor = GetIndexFromCache(this);
    // Need to compare to count here since we may have removed children since
    // the index was added to the cache.
    // We're also relying on that GetIndexFromCache returns -1 if no cached
    // index was found.
    if (cursor >= count) {
      cursor = -1;
    }

    // Seek outward from the last found index. |inc| will change sign every
    // run through the loop. |sign| just exists to make sure the absolute
    // value of |inc| increases each time through.
    PRInt32 inc = 1, sign = 1;
    while (cursor >= 0 && cursor < count) {
      if (children[cursor] == aPossibleChild) {
        AddIndexToCache(this, cursor);

        return cursor;
      }

      cursor += inc;
      inc = -inc - sign;
      sign = -sign;
    }

    // We ran into one 'edge'. Add inc to cursor once more to get back to
    // the 'side' where we still need to search, then step in the |sign|
    // direction.
    cursor += inc;

    if (sign > 0) {
      for (; cursor < count; ++cursor) {
        if (children[cursor] == aPossibleChild) {
          AddIndexToCache(this, cursor);

          return NS_STATIC_CAST(PRInt32, cursor);
        }
      }
    }
    else {
      for (; cursor >= 0; --cursor) {
        if (children[cursor] == aPossibleChild) {
          AddIndexToCache(this, cursor);

          return NS_STATIC_CAST(PRInt32, cursor);
        }
      }
    }

    // The child wasn't even in the remaining children
    return -1;
  }

  for (i = 0; i < count; ++i) {
    if (children[i] == aPossibleChild) {
      return NS_STATIC_CAST(PRInt32, i);
    }
  }

  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 140 of file nsAttrAndChildArray.cpp.

{
  NS_ASSERTION(aChild, "nullchild");
  NS_ASSERTION(aPos <= ChildCount(), "out-of-bounds");

  PRUint32 offset = AttrSlotsSize();
  PRUint32 childCount = ChildCount();

  NS_ENSURE_TRUE(childCount < ATTRCHILD_ARRAY_MAX_CHILD_COUNT,
                 NS_ERROR_FAILURE);

  // First try to fit new child in existing childlist
  if (mImpl && offset + childCount < mImpl->mBufferSize) {
    void** pos = mImpl->mBuffer + offset + aPos;
    if (childCount != aPos) {
      memmove(pos + 1, pos, (childCount - aPos) * sizeof(nsIContent*));
    }
    *pos = aChild;
    NS_ADDREF(aChild);

    SetChildCount(childCount + 1);

    return NS_OK;
  }

  // Try to fit new child in existing buffer by compressing attrslots
  if (offset && !mImpl->mBuffer[offset - ATTRSIZE]) {
    // Compress away all empty slots while we're at it. This might not be the
    // optimal thing to do.
    PRUint32 attrCount = NonMappedAttrCount();
    void** newStart = mImpl->mBuffer + attrCount * ATTRSIZE;
    void** oldStart = mImpl->mBuffer + offset;
    memmove(newStart, oldStart, aPos * sizeof(nsIContent*));
    newStart[aPos] = aChild;
    memmove(&newStart[aPos + 1], &oldStart[aPos],
            (childCount - aPos) * sizeof(nsIContent*));
    NS_ADDREF(aChild);

    SetAttrSlotAndChildCount(attrCount, childCount + 1);

    return NS_OK;
  }

  // We can't fit in current buffer, Realloc time!
  if (!GrowBy(1)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  void** pos = mImpl->mBuffer + offset + aPos;
  if (childCount != aPos) {
    memmove(pos + 1, pos, (childCount - aPos) * sizeof(nsIContent*));
  }
  *pos = aChild;
  NS_ADDREF(aChild);

  SetChildCount(childCount + 1);
  
  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 683 of file nsAttrAndChildArray.cpp.

{
  NS_ASSERTION(aAttributes, "missing attributes");

  if (!mImpl && !GrowBy(1)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  if (!aAttributes->GetStyleSheet()) {
    // This doesn't currently happen, but it could if we do loading right

    nsRefPtr<nsMappedAttributes> mapped(aAttributes);
    mapped.swap(mImpl->mMappedAttrs);

    return NS_OK;
  }

  nsRefPtr<nsMappedAttributes> mapped =
    aAttributes->GetStyleSheet()->UniqueMappedAttributes(aAttributes);
  NS_ENSURE_TRUE(mapped, NS_ERROR_OUT_OF_MEMORY);

  if (mapped != aAttributes) {
    // Reset the stylesheet of aAttributes so that it doesn't spend time
    // trying to remove itself from the hash. There is no risk that aAttributes
    // is in the hash since it will always have come from GetModifiableMapped,
    // which never returns maps that are in the hash (such hashes are by
    // nature not modifiable).
    aAttributes->DropStyleSheetReference();
  }
  mapped.swap(mImpl->mMappedAttrs);

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 648 of file nsAttrAndChildArray.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 633 of file nsAttrAndChildArray.cpp.

{
  if (!mImpl) {
    return 0;
  }

  PRUint32 count = AttrSlotCount();
  while (count > 0 && !mImpl->mBuffer[(count - 1) * ATTRSIZE]) {
    --count;
  }

  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsAttrAndChildArray& nsAttrAndChildArray::operator= ( const nsAttrAndChildArray aOther) [private]

Definition at line 421 of file nsAttrAndChildArray.cpp.

{
  NS_ASSERTION(aPos < AttrCount(), "out-of-bounds");

  PRUint32 mapped = MappedAttrCount();
  if (aPos < mapped) {
    if (mapped == 1) {
      // We're removing the last mapped attribute.  Can't swap in this
      // case; have to copy.
      aValue.SetTo(*mImpl->mMappedAttrs->AttrAt(0));
      NS_RELEASE(mImpl->mMappedAttrs);

      return NS_OK;
    }

    nsRefPtr<nsMappedAttributes> mapped;
    nsresult rv = GetModifiableMapped(nsnull, nsnull, PR_FALSE,
                                      getter_AddRefs(mapped));
    NS_ENSURE_SUCCESS(rv, rv);

    mapped->RemoveAttrAt(aPos, aValue);

    return MakeMappedUnique(mapped);
  }

  aPos -= mapped;
  ATTRS(mImpl)[aPos].mValue.SwapValueWith(aValue);
  ATTRS(mImpl)[aPos].~InternalAttr();

  PRUint32 slotCount = AttrSlotCount();
  memmove(&ATTRS(mImpl)[aPos],
          &ATTRS(mImpl)[aPos + 1],
          (slotCount - aPos - 1) * sizeof(InternalAttr));
  memset(&ATTRS(mImpl)[slotCount - 1], nsnull, sizeof(InternalAttr));

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 201 of file nsAttrAndChildArray.cpp.

{
  NS_ASSERTION(aPos < ChildCount(), "out-of-bounds");

  PRUint32 childCount = ChildCount();
  void** pos = mImpl->mBuffer + AttrSlotsSize() + aPos;
  nsIContent* child = NS_STATIC_CAST(nsIContent*, *pos);
  NS_RELEASE(child);
  memmove(pos, pos + 1, (childCount - aPos - 1) * sizeof(nsIContent*));
  SetChildCount(childCount - 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 359 of file nsAttrAndChildArray.cpp.

{
  PRUint32 i, slotCount = AttrSlotCount();
  for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
    if (ATTRS(mImpl)[i].mName.Equals(aLocalName)) {
      ATTRS(mImpl)[i].mValue.Reset();
      ATTRS(mImpl)[i].mValue.SwapValueWith(aValue);

      return NS_OK;
    }
  }

  NS_ENSURE_TRUE(i < ATTRCHILD_ARRAY_MAX_ATTR_COUNT,
                 NS_ERROR_FAILURE);

  if (i == slotCount && !AddAttrSlot()) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  new (&ATTRS(mImpl)[i].mName) nsAttrName(aLocalName);
  new (&ATTRS(mImpl)[i].mValue) nsAttrValue();
  ATTRS(mImpl)[i].mValue.SwapValueWith(aValue);

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 386 of file nsAttrAndChildArray.cpp.

{
  PRInt32 namespaceID = aName->NamespaceID();
  nsIAtom* localName = aName->NameAtom();
  if (namespaceID == kNameSpaceID_None) {
    return SetAndTakeAttr(localName, aValue);
  }

  PRUint32 i, slotCount = AttrSlotCount();
  for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
    if (ATTRS(mImpl)[i].mName.Equals(localName, namespaceID)) {
      ATTRS(mImpl)[i].mName.SetTo(aName);
      ATTRS(mImpl)[i].mValue.Reset();
      ATTRS(mImpl)[i].mValue.SwapValueWith(aValue);

      return NS_OK;
    }
  }

  NS_ENSURE_TRUE(i < ATTRCHILD_ARRAY_MAX_ATTR_COUNT,
                 NS_ERROR_FAILURE);

  if (i == slotCount && !AddAttrSlot()) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  new (&ATTRS(mImpl)[i].mName) nsAttrName(aName);
  new (&ATTRS(mImpl)[i].mValue) nsAttrValue();
  ATTRS(mImpl)[i].mValue.SwapValueWith(aValue);

  return NS_OK;
}

Here is the call graph for this function:

Definition at line 529 of file nsAttrAndChildArray.cpp.

{
  nsRefPtr<nsMappedAttributes> mapped;
  nsresult rv = GetModifiableMapped(aContent, aSheet, PR_TRUE,
                                    getter_AddRefs(mapped));
  NS_ENSURE_SUCCESS(rv, rv);

  rv = mapped->SetAndTakeAttr(aLocalName, aValue);
  NS_ENSURE_SUCCESS(rv, rv);

  return MakeMappedUnique(mapped);
}

Here is the call graph for this function:

nsresult nsAttrAndChildArray::SetAttr ( nsIAtom aLocalName,
const nsAString &  aValue 
)

Definition at line 334 of file nsAttrAndChildArray.cpp.

{
  PRUint32 i, slotCount = AttrSlotCount();
  for (i = 0; i < slotCount && mImpl->mBuffer[i * ATTRSIZE]; ++i) {
    if (ATTRS(mImpl)[i].mName.Equals(aLocalName)) {
      ATTRS(mImpl)[i].mValue.SetTo(aValue);

      return NS_OK;
    }
  }

  NS_ENSURE_TRUE(slotCount < ATTRCHILD_ARRAY_MAX_ATTR_COUNT,
                 NS_ERROR_FAILURE);

  if (i == slotCount && !AddAttrSlot()) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  new (&ATTRS(mImpl)[i].mName) nsAttrName(aLocalName);
  new (&ATTRS(mImpl)[i].mValue) nsAttrValue(aValue);

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsAttrAndChildArray::SetAttrSlotAndChildCount ( PRUint32  aSlotCount,
PRUint32  aChildCount 
) [inline, private]

Definition at line 155 of file nsAttrAndChildArray.h.

  {
    mImpl->mAttrAndChildCount = aSlotCount |
      (aChildCount << ATTRCHILD_ARRAY_ATTR_SLOTS_BITS);
  }

Here is the caller graph for this function:

void nsAttrAndChildArray::SetAttrSlotCount ( PRUint32  aCount) [inline, private]

Definition at line 148 of file nsAttrAndChildArray.h.

Here is the caller graph for this function:

void nsAttrAndChildArray::SetChildCount ( PRUint32  aCount) [inline, private]

Definition at line 141 of file nsAttrAndChildArray.h.

Here is the caller graph for this function:

Definition at line 546 of file nsAttrAndChildArray.cpp.

{
  if (!mImpl || !mImpl->mMappedAttrs ||
      aSheet == mImpl->mMappedAttrs->GetStyleSheet()) {
    return NS_OK;
  }

  nsRefPtr<nsMappedAttributes> mapped;
  nsresult rv = GetModifiableMapped(nsnull, nsnull, PR_FALSE, 
                                    getter_AddRefs(mapped));
  NS_ENSURE_SUCCESS(rv, rv);

  mapped->SetStyleSheet(aSheet);

  return MakeMappedUnique(mapped);
}

Here is the call graph for this function:

Definition at line 564 of file nsAttrAndChildArray.cpp.

{
  if (mImpl && mImpl->mMappedAttrs && aRuleWalker) {
    aRuleWalker->Forward(mImpl->mMappedAttrs);
  }
}

Here is the call graph for this function:


Member Data Documentation

Definition at line 177 of file nsAttrAndChildArray.h.


The documentation for this class was generated from the following files: