/usr/share/idl/thunderbird/nsIAtom.idl is in thunderbird-dev 1:52.7.0+build1-0ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | /* -*- 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/. */
#include "nsISupports.idl"
%{C++
#include "nsStringGlue.h"
#include "nsCOMPtr.h"
#include "nsStringBuffer.h"
%}
native MallocSizeOf(mozilla::MallocSizeOf);
/*
* Should this really be scriptable? Using atoms from script or proxies
* could be dangerous since double-wrapping could lead to loss of
* pointer identity.
*/
[scriptable, builtinclass, uuid(8b8c11d4-3ed5-4079-8974-73c7576cdb34)]
interface nsIAtom : nsISupports
{
/**
* Get the Unicode or UTF8 value for the string
*/
[binaryname(ScriptableToString)] AString toString();
[noscript] AUTF8String toUTF8String();
/**
* Compare the atom to a specific string value
* Note that this will NEVER return/throw an error condition.
*/
[binaryname(ScriptableEquals)] boolean equals(in AString aString);
[noscript, notxpcom]
size_t SizeOfIncludingThis(in MallocSizeOf aMallocSizeOf);
%{C++
// note this is NOT virtual so this won't muck with the vtable!
inline bool Equals(const nsAString& aString) const {
return aString.Equals(nsDependentString(mString, mLength));
}
inline bool IsStaticAtom() const {
return mIsStatic;
}
inline char16ptr_t GetUTF16String() const {
return mString;
}
inline uint32_t GetLength() const {
return mLength;
}
inline void ToString(nsAString& aBuf) {
// See the comment on |mString|'s declaration.
nsStringBuffer::FromData(mString)->ToString(mLength, aBuf);
}
inline nsStringBuffer* GetStringBuffer() const {
// See the comment on |mString|'s declaration.
return nsStringBuffer::FromData(mString);
}
/**
* A hashcode that is better distributed than the actual atom
* pointer, for use in situations that need a well-distributed
* hashcode.
*/
inline uint32_t hash() const {
return mHash;
}
protected:
uint32_t mLength:31;
uint32_t mIsStatic:1;
uint32_t mHash;
/**
* WARNING! There is an invisible constraint on |mString|: the chars it
* points to must belong to an nsStringBuffer. This is so that the
* nsStringBuffer::FromData() calls above are valid.
*/
char16_t* mString;
%}
};
%{C++
/*
* The four forms of NS_Atomize (for use with |nsCOMPtr<nsIAtom>|) return the
* atom for the string given. At any given time there will always be one atom
* representing a given string. Atoms are intended to make string comparison
* cheaper by simplifying it to pointer equality. A pointer to the atom that
* does not own a reference is not guaranteed to be valid.
*/
/**
* Find an atom that matches the given UTF-8 string.
* The string is assumed to be zero terminated. Never returns null.
*/
extern already_AddRefed<nsIAtom> NS_Atomize(const char* aUTF8String);
/**
* Find an atom that matches the given UTF-8 string. Never returns null.
*/
extern already_AddRefed<nsIAtom> NS_Atomize(const nsACString& aUTF8String);
/**
* Find an atom that matches the given UTF-16 string.
* The string is assumed to be zero terminated. Never returns null.
*/
extern already_AddRefed<nsIAtom> NS_Atomize(const char16_t* aUTF16String);
/**
* Find an atom that matches the given UTF-16 string. Never returns null.
*/
extern already_AddRefed<nsIAtom> NS_Atomize(const nsAString& aUTF16String);
/**
* Return a count of the total number of atoms currently
* alive in the system.
*/
extern nsrefcnt NS_GetNumberOfAtoms(void);
/**
* Return a pointer for a static atom for the string or null if there's
* no static atom for this string.
*/
extern nsIAtom* NS_GetStaticAtom(const nsAString& aUTF16String);
/**
* Seal the static atom table
*/
extern void NS_SealStaticAtomTable();
class nsAtomString : public nsString
{
public:
explicit nsAtomString(nsIAtom* aAtom)
{
aAtom->ToString(*this);
}
};
class nsAtomCString : public nsCString
{
public:
explicit nsAtomCString(nsIAtom* aAtom)
{
aAtom->ToUTF8String(*this);
}
};
class nsDependentAtomString : public nsDependentString
{
public:
explicit nsDependentAtomString(nsIAtom* aAtom)
: nsDependentString(aAtom->GetUTF16String(), aAtom->GetLength())
{
}
};
%}
|