PRUint32
nsAttrValue::HashValue() const
{
switch(BaseType()) {
case eStringBase:
{
nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
if (str) {
PRUint32 len = str->StorageSize()/sizeof(PRUnichar) - 1;
return nsCRT::HashCode(static_cast<PRUnichar*>(str->Data()), len);
}
return 0;
}
case eOtherBase:
{
break;
}
case eAtomBase:
case eIntegerBase:
{
// mBits and PRUint32 might have different size. This should silence
// any warnings or compile-errors. This is what the implementation of
// NS_PTR_TO_INT32 does to take care of the same problem.
return mBits - 0;
}
}
MiscContainer* cont = GetMiscContainer();
if (static_cast<ValueBaseType>(cont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK)
== eAtomBase) {
return cont->mStringBits - 0;
}
switch (cont->mType) {
case eInteger:
{
return cont->mInteger;
}
case eEnum:
{
return cont->mEnumValue;
}
case ePercent:
{
return cont->mPercent;
}
case eColor:
{
return cont->mColor;
}
case eCSSStyleRule:
{
return NS_PTR_TO_INT32(cont->mCSSStyleRule);
}
case eAtomArray:
{
PRUint32 retval = 0;
PRUint32 count = cont->mAtomArray->Length();
for (nsCOMPtr<nsIAtom> *cur = cont->mAtomArray->Elements(),
*end = cur + count;
cur != end; ++cur) {
retval ^= NS_PTR_TO_INT32(cur->get());
}
return retval;
}
case eSVGValue:
{
return NS_PTR_TO_INT32(cont->mSVGValue);
}
case eDoubleValue:
{
// XXX this is crappy, but oh well
return cont->mDoubleValue;
}
case eIntMarginValue:
{
return NS_PTR_TO_INT32(cont->mIntMargin);
}
default:
{
NS_NOTREACHED("unknown type stored in MiscContainer");
return 0;
}
}
}
PRBool
nsAttrValue::Equals(const nsAttrValue& aOther) const
{
if (BaseType() != aOther.BaseType()) {
return PR_FALSE;
}
switch(BaseType()) {
case eStringBase:
{
return GetStringValue().Equals(aOther.GetStringValue());
}
case eOtherBase:
{
break;
}
case eAtomBase:
case eIntegerBase:
{
return mBits == aOther.mBits;
}
}
MiscContainer* thisCont = GetMiscContainer();
MiscContainer* otherCont = aOther.GetMiscContainer();
if (thisCont->mType != otherCont->mType) {
return PR_FALSE;
}
PRBool needsStringComparison = PR_FALSE;
switch (thisCont->mType) {
case eInteger:
{
if (thisCont->mInteger == otherCont->mInteger) {
needsStringComparison = PR_TRUE;
}
break;
}
case eEnum:
{
if (thisCont->mEnumValue == otherCont->mEnumValue) {
needsStringComparison = PR_TRUE;
}
break;
}
case ePercent:
{
if (thisCont->mPercent == otherCont->mPercent) {
needsStringComparison = PR_TRUE;
}
break;
}
case eColor:
{
if (thisCont->mColor == otherCont->mColor) {
needsStringComparison = PR_TRUE;
}
break;
}
case eCSSStyleRule:
{
return thisCont->mCSSStyleRule == otherCont->mCSSStyleRule;
}
case eAtomArray:
{
// For classlists we could be insensitive to order, however
// classlists are never mapped attributes so they are never compared.
if (!(*thisCont->mAtomArray == *otherCont->mAtomArray)) {
return PR_FALSE;
}
needsStringComparison = PR_TRUE;
break;
}
case eSVGValue:
{
return thisCont->mSVGValue == otherCont->mSVGValue;
}
case eDoubleValue:
{
return thisCont->mDoubleValue == otherCont->mDoubleValue;
}
case eIntMarginValue:
{
return thisCont->mIntMargin == otherCont->mIntMargin;
}
default:
{
NS_NOTREACHED("unknown type stored in MiscContainer");
return PR_FALSE;
}
}
if (needsStringComparison) {
if (thisCont->mStringBits == otherCont->mStringBits) {
return PR_TRUE;
}
if ((static_cast<ValueBaseType>(thisCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
eStringBase) &&
(static_cast<ValueBaseType>(otherCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
eStringBase)) {
return nsCheapString(reinterpret_cast<nsStringBuffer*>(thisCont->mStringBits)).Equals(
nsCheapString(reinterpret_cast<nsStringBuffer*>(otherCont->mStringBits)));
}
}
return PR_FALSE;
}
void
nsAttrValue::ToString(nsAString& aResult) const
{
MiscContainer* cont = nsnull;
if (BaseType() == eOtherBase) {
cont = GetMiscContainer();
void* ptr = MISC_STR_PTR(cont);
if (ptr) {
if (static_cast<ValueBaseType>(cont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
eStringBase) {
nsStringBuffer* str = static_cast<nsStringBuffer*>(ptr);
if (str) {
str->ToString(str->StorageSize()/sizeof(PRUnichar) - 1, aResult);
return;
}
} else {
nsIAtom *atom = static_cast<nsIAtom*>(ptr);
atom->ToString(aResult);
return;
}
}
}
switch(Type()) {
case eString:
{
nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
if (str) {
str->ToString(str->StorageSize()/sizeof(PRUnichar) - 1, aResult);
}
else {
aResult.Truncate();
}
break;
}
case eAtom:
{
nsIAtom *atom = static_cast<nsIAtom*>(GetPtr());
atom->ToString(aResult);
break;
}
case eInteger:
{
nsAutoString intStr;
intStr.AppendInt(GetIntegerValue());
aResult = intStr;
break;
}
#ifdef DEBUG
case eColor:
{
NS_NOTREACHED("color attribute without string data");
aResult.Truncate();
break;
}
#endif
case eEnum:
{
GetEnumString(aResult, PR_FALSE);
break;
}
case ePercent:
{
nsAutoString intStr;
intStr.AppendInt(cont ? cont->mPercent : GetIntInternal());
aResult = intStr + NS_LITERAL_STRING("%");
break;
}
case eCSSStyleRule:
{
aResult.Truncate();
MiscContainer *container = GetMiscContainer();
css::Declaration *decl = container->mCSSStyleRule->GetDeclaration();
if (decl) {
decl->ToString(aResult);
}
const_cast<nsAttrValue*>(this)->SetMiscAtomOrString(&aResult);
break;
}
case eSVGValue:
{
GetMiscContainer()->mSVGValue->GetValueString(aResult);
break;
}
case eDoubleValue:
{
aResult.Truncate();
aResult.AppendFloat(GetDoubleValue());
break;
}
default:
{
aResult.Truncate();
break;
}
}
}
void
nsAttrValue::SetTo(const nsAttrValue& aOther)
{
switch (aOther.BaseType()) {
case eStringBase:
{
ResetIfSet();
nsStringBuffer* str = static_cast<nsStringBuffer*>(aOther.GetPtr());
if (str) {
str->AddRef();
SetPtrValueAndType(str, eStringBase);
}
return;
}
case eOtherBase:
{
break;
}
case eAtomBase:
{
ResetIfSet();
nsIAtom* atom = aOther.GetAtomValue();
NS_ADDREF(atom);
SetPtrValueAndType(atom, eAtomBase);
return;
}
case eIntegerBase:
{
ResetIfSet();
mBits = aOther.mBits;
return;
}
}
MiscContainer* otherCont = aOther.GetMiscContainer();
if (!EnsureEmptyMiscContainer()) {
return;
}
MiscContainer* cont = GetMiscContainer();
switch (otherCont->mType) {
case eInteger:
{
cont->mInteger = otherCont->mInteger;
break;
}
case eEnum:
{
cont->mEnumValue = otherCont->mEnumValue;
break;
}
case ePercent:
{
cont->mPercent = otherCont->mPercent;
break;
}
case eColor:
{
cont->mColor = otherCont->mColor;
break;
}
case eCSSStyleRule:
{
NS_ADDREF(cont->mCSSStyleRule = otherCont->mCSSStyleRule);
break;
}
case eAtomArray:
{
if (!EnsureEmptyAtomArray() ||
!GetAtomArrayValue()->AppendElements(*otherCont->mAtomArray)) {
Reset();
return;
}
break;
}
case eSVGValue:
{
NS_ADDREF(cont->mSVGValue = otherCont->mSVGValue);
break;
}
case eDoubleValue:
{
cont->mDoubleValue = otherCont->mDoubleValue;
break;
}
case eIntMarginValue:
{
if (otherCont->mIntMargin)
cont->mIntMargin = new nsIntMargin(*otherCont->mIntMargin);
break;
}
default:
{
NS_NOTREACHED("unknown type stored in MiscContainer");
break;
}
}
void* otherPtr = MISC_STR_PTR(otherCont);
if (otherPtr) {
if (static_cast<ValueBaseType>(otherCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
eStringBase) {
static_cast<nsStringBuffer*>(otherPtr)->AddRef();
} else {
static_cast<nsIAtom*>(otherPtr)->AddRef();
}
cont->mStringBits = otherCont->mStringBits;
}
// Note, set mType after switch-case, otherwise EnsureEmptyAtomArray doesn't
// work correctly.
cont->mType = otherCont->mType;
}
PRBool
nsAttrValue::Equals(const nsAttrValue& aOther) const
{
if (BaseType() != aOther.BaseType()) {
return PR_FALSE;
}
switch(BaseType()) {
case eStringBase:
{
return GetStringValue().Equals(aOther.GetStringValue());
}
case eOtherBase:
{
break;
}
case eAtomBase:
case eIntegerBase:
{
return mBits == aOther.mBits;
}
}
MiscContainer* thisCont = GetMiscContainer();
MiscContainer* otherCont = aOther.GetMiscContainer();
if (thisCont->mType != otherCont->mType) {
return PR_FALSE;
}
switch (thisCont->mType) {
case eColor:
{
return thisCont->mColor == otherCont->mColor;
}
case eCSSStyleRule:
{
return thisCont->mCSSStyleRule == otherCont->mCSSStyleRule;
}
case eAtomArray:
{
// For classlists we could be insensitive to order, however
// classlists are never mapped attributes so they are never compared.
PRInt32 count = thisCont->mAtomArray->Count();
if (count != otherCont->mAtomArray->Count()) {
return PR_FALSE;
}
PRInt32 i;
for (i = 0; i < count; ++i) {
if (thisCont->mAtomArray->ObjectAt(i) !=
otherCont->mAtomArray->ObjectAt(i)) {
return PR_FALSE;
}
}
return PR_TRUE;
}
#ifdef MOZ_SVG
case eSVGValue:
{
return thisCont->mSVGValue == otherCont->mSVGValue;
}
#endif
default:
{
NS_NOTREACHED("unknown type stored in MiscContainer");
return PR_FALSE;
}
}
}
void
nsAttrValue::ToString(nsAString& aResult) const
{
switch(Type()) {
case eString:
{
nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
if (str) {
str->ToString(str->StorageSize()/sizeof(PRUnichar) - 1, aResult);
}
else {
aResult.Truncate();
}
break;
}
case eAtom:
{
nsIAtom *atom = static_cast<nsIAtom*>(GetPtr());
atom->ToString(aResult);
break;
}
case eInteger:
{
nsAutoString intStr;
intStr.AppendInt(GetIntInternal());
aResult = intStr;
break;
}
case eColor:
{
nscolor v;
GetColorValue(v);
NS_RGBToHex(v, aResult);
break;
}
case eEnum:
{
PRInt16 val = GetEnumValue();
const EnumTable* table = sEnumTableArray->
ElementAt(GetIntInternal() & NS_ATTRVALUE_ENUMTABLEINDEX_MASK);
while (table->tag) {
if (table->value == val) {
aResult.AssignASCII(table->tag);
return;
}
table++;
}
NS_NOTREACHED("couldn't find value in EnumTable");
break;
}
case ePercent:
{
nsAutoString intStr;
intStr.AppendInt(GetIntInternal());
aResult = intStr + NS_LITERAL_STRING("%");
break;
}
case eCSSStyleRule:
{
aResult.Truncate();
MiscContainer *container = GetMiscContainer();
nsCSSDeclaration* decl = container->mCSSStyleRule->GetDeclaration();
if (decl) {
decl->ToString(aResult);
}
break;
}
case eAtomArray:
{
MiscContainer* cont = GetMiscContainer();
PRInt32 count = cont->mAtomArray->Count();
if (count) {
cont->mAtomArray->ObjectAt(0)->ToString(aResult);
nsAutoString tmp;
PRInt32 i;
for (i = 1; i < count; ++i) {
cont->mAtomArray->ObjectAt(i)->ToString(tmp);
aResult.Append(NS_LITERAL_STRING(" ") + tmp);
}
}
else {
aResult.Truncate();
}
break;
}
#ifdef MOZ_SVG
case eSVGValue:
{
GetMiscContainer()->mSVGValue->GetValueString(aResult);
}
#endif
}
}
void
nsAttrValue::SetTo(const nsAttrValue& aOther)
{
switch (aOther.BaseType()) {
case eStringBase:
{
ResetIfSet();
nsStringBuffer* str = static_cast<nsStringBuffer*>(aOther.GetPtr());
if (str) {
str->AddRef();
SetPtrValueAndType(str, eStringBase);
}
return;
}
case eOtherBase:
{
break;
}
case eAtomBase:
{
ResetIfSet();
nsIAtom* atom = aOther.GetAtomValue();
NS_ADDREF(atom);
SetPtrValueAndType(atom, eAtomBase);
return;
}
case eIntegerBase:
{
ResetIfSet();
mBits = aOther.mBits;
return;
}
}
MiscContainer* otherCont = aOther.GetMiscContainer();
switch (otherCont->mType) {
case eColor:
{
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
cont->mColor = otherCont->mColor;
cont->mType = eColor;
}
break;
}
case eCSSStyleRule:
{
SetTo(otherCont->mCSSStyleRule);
break;
}
case eAtomArray:
{
if (!EnsureEmptyAtomArray() ||
!GetAtomArrayValue()->AppendObjects(*otherCont->mAtomArray)) {
Reset();
}
break;
}
#ifdef MOZ_SVG
case eSVGValue:
{
SetTo(otherCont->mSVGValue);
}
#endif
default:
{
NS_NOTREACHED("unknown type stored in MiscContainer");
break;
}
}
}
