summaryrefslogtreecommitdiffstats
path: root/xpcom/ds/nsIAtom.idl
blob: ce4cff48564041ae09a9f49d4d2b99c622657c93 (plain)
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
167
168
169
170
171
172
173
174
175
176
177
/* -*- 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 these are NOT virtual so they won't muck with the vtable!  
  inline bool Equals(char16ptr_t aString, uint32_t aLength) const 
  {
    return mLength == aLength &&
           memcmp(mString, aString, mLength * sizeof(char16_t)) == 0;
  }

  inline bool Equals(const nsAString& aString) const {
    return Equals(aString.BeginReading(), aString.Length());
  }

  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);

/**
 * An optimized version of the method above for the main thread.
 */
extern already_AddRefed<nsIAtom> NS_AtomizeMainThread(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())
  {
  }
};

%}