headers/compatibility/bsd/sys/queue.h

595

struct quehead *element = (struct quehead *)a,

headers/compatibility/bsd/sys/queue.h

598

element->qh_link = head->qh_link;

headers/compatibility/bsd/sys/queue.h

599

element->qh_rlink = head;

headers/compatibility/bsd/sys/queue.h

600

head->qh_link = element;

headers/compatibility/bsd/sys/queue.h

601

element->qh_link->qh_rlink = element;

headers/compatibility/bsd/sys/queue.h

607

struct quehead *element = (struct quehead *)a;

headers/compatibility/bsd/sys/queue.h

609

element->qh_link->qh_rlink = element->qh_rlink;

headers/compatibility/bsd/sys/queue.h

610

element->qh_rlink->qh_link = element->qh_link;

headers/compatibility/bsd/sys/queue.h

611

element->qh_rlink = 0;

headers/libs/zydis/Zycore/Vector.h

448

ZYCORE_EXPORT ZyanStatus ZyanVectorPushBack(ZyanVector* vector, const void* element);

headers/libs/zydis/Zycore/Vector.h

460

const void* element);

headers/libs/zydis/Zycore/Vector.h

485

ZYCORE_EXPORT ZyanStatus ZyanVectorEmplace(ZyanVector* vector, void** element,

headers/libs/zydis/Zycore/Vector.h

500

void** element, ZyanMemberFunction constructor);

headers/libs/zydis/Zycore/Vector.h

582

ZYCORE_EXPORT ZyanStatus ZyanVectorFind(const ZyanVector* vector, const void* element,

headers/libs/zydis/Zycore/Vector.h

600

ZYCORE_EXPORT ZyanStatus ZyanVectorFindEx(const ZyanVector* vector, const void* element,

headers/libs/zydis/Zycore/Vector.h

620

ZYCORE_EXPORT ZyanStatus ZyanVectorBinarySearch(const ZyanVector* vector, const void* element,

headers/libs/zydis/Zycore/Vector.h

642

ZYCORE_EXPORT ZyanStatus ZyanVectorBinarySearchEx(const ZyanVector* vector, const void* element,

headers/libs/zydis/Zydis/Internal/SharedData.h

954

ZYDIS_NO_EXPORT void ZydisGetElementInfo(ZydisInternalElementType element, ZydisElementType* type,

headers/os/locale/NumberFormat.h

42

BString GetSeparator(BNumberElement element);

headers/os/package/solver/SolverProblemSolution.h

77

bool AppendElement(const Element& element);

headers/os/package/solver/SolverResult.h

54

const BSolverResultElement& element);

headers/posix/search.h

39

extern void insque(void *element, void *insertAfter);

headers/posix/search.h

44

extern void remque(void *element);

headers/private/firewire/queue.h

590

struct quehead *element = (struct quehead *)a,

headers/private/firewire/queue.h

593

element->qh_link = head->qh_link;

headers/private/firewire/queue.h

594

element->qh_rlink = head;

headers/private/firewire/queue.h

595

head->qh_link = element;

headers/private/firewire/queue.h

596

element->qh_link->qh_rlink = element;

headers/private/firewire/queue.h

602

struct quehead *element = (struct quehead *)a;

headers/private/firewire/queue.h

604

element->qh_link->qh_rlink = element->qh_rlink;

headers/private/firewire/queue.h

605

element->qh_rlink->qh_link = element->qh_link;

headers/private/firewire/queue.h

606

element->qh_rlink = 0;

headers/private/fs_shell/DoublyLinkedList.h

151

Element *element = fCurrent;

headers/private/fs_shell/DoublyLinkedList.h

156

return element;

headers/private/fs_shell/DoublyLinkedList.h

200

Element *element = fNext;

headers/private/fs_shell/DoublyLinkedList.h

203

return element;

headers/private/fs_shell/DoublyLinkedList.h

252

Element *element = fCurrent;

headers/private/fs_shell/DoublyLinkedList.h

257

return element;

headers/private/fs_shell/DoublyLinkedList.h

301

Element *element = fNext;

headers/private/fs_shell/DoublyLinkedList.h

304

return element;

headers/private/fs_shell/DoublyLinkedList.h

330

inline void InsertBefore(Element* insertBefore, Element* element);

headers/private/fs_shell/DoublyLinkedList.h

331

inline void InsertAfter(Element* insertAfter, Element* element);

headers/private/fs_shell/DoublyLinkedList.h

332

inline void Insert(Element* element, bool back = true);

headers/private/fs_shell/DoublyLinkedList.h

333

inline void Add(Element *element, bool back = true);

headers/private/fs_shell/DoublyLinkedList.h

334

inline void Remove(Element *element);

headers/private/fs_shell/DoublyLinkedList.h

351

inline Element *GetPrevious(Element *element) const;

headers/private/fs_shell/DoublyLinkedList.h

352

inline Element *GetNext(Element *element) const;

headers/private/fs_shell/DoublyLinkedList.h

366

inline void Insert(Element* before, Element* element);

headers/private/fs_shell/DoublyLinkedList.h

382

DOUBLY_LINKED_LIST_CLASS_NAME::Insert(Element *element, bool back)

headers/private/fs_shell/DoublyLinkedList.h

384

if (element) {

headers/private/fs_shell/DoublyLinkedList.h

387

Link *elLink = sGetLink(element);

headers/private/fs_shell/DoublyLinkedList.h

391

sGetLink(fLast)->next = element;

headers/private/fs_shell/DoublyLinkedList.h

393

fFirst = element;

headers/private/fs_shell/DoublyLinkedList.h

394

fLast = element;

headers/private/fs_shell/DoublyLinkedList.h

397

Link *elLink = sGetLink(element);

headers/private/fs_shell/DoublyLinkedList.h

401

sGetLink(fFirst)->previous = element;

headers/private/fs_shell/DoublyLinkedList.h

403

fLast = element;

headers/private/fs_shell/DoublyLinkedList.h

404

fFirst = element;

headers/private/fs_shell/DoublyLinkedList.h

412

DOUBLY_LINKED_LIST_CLASS_NAME::InsertBefore(Element* before, Element* element)

headers/private/fs_shell/DoublyLinkedList.h

415

Insert(element);

headers/private/fs_shell/DoublyLinkedList.h

418

if (element == NULL)

headers/private/fs_shell/DoublyLinkedList.h

422

Link *link = sGetLink(element);

headers/private/fs_shell/DoublyLinkedList.h

427

sGetLink(link->previous)->next = element;

headers/private/fs_shell/DoublyLinkedList.h

428

beforeLink->previous = element;

headers/private/fs_shell/DoublyLinkedList.h

431

fFirst = element;

headers/private/fs_shell/DoublyLinkedList.h

437

DOUBLY_LINKED_LIST_CLASS_NAME::InsertAfter(Element* after, Element* element)

headers/private/fs_shell/DoublyLinkedList.h

439

ASSERT(element != NULL);

headers/private/fs_shell/DoublyLinkedList.h

442

Insert(element, false);

headers/private/fs_shell/DoublyLinkedList.h

447

Link* link = sGetLink(element);

headers/private/fs_shell/DoublyLinkedList.h

451

afterLink->next = element;

headers/private/fs_shell/DoublyLinkedList.h

454

sGetLink(link->next)->previous = element;

headers/private/fs_shell/DoublyLinkedList.h

456

fLast = element;

headers/private/fs_shell/DoublyLinkedList.h

462

DOUBLY_LINKED_LIST_CLASS_NAME::Insert(Element* before, Element* element)

headers/private/fs_shell/DoublyLinkedList.h

464

InsertBefore(before, element);

headers/private/fs_shell/DoublyLinkedList.h

471

DOUBLY_LINKED_LIST_CLASS_NAME::Add(Element *element, bool back)

headers/private/fs_shell/DoublyLinkedList.h

473

Insert(element, back);

headers/private/fs_shell/DoublyLinkedList.h

479

DOUBLY_LINKED_LIST_CLASS_NAME::Remove(Element *element)

headers/private/fs_shell/DoublyLinkedList.h

481

if (element) {

headers/private/fs_shell/DoublyLinkedList.h

482

Link *elLink = sGetLink(element);

headers/private/fs_shell/DoublyLinkedList.h

543

Element *element = fFirst;

headers/private/fs_shell/DoublyLinkedList.h

544

while (element) {

headers/private/fs_shell/DoublyLinkedList.h

545

Link *elLink = sGetLink(element);

headers/private/fs_shell/DoublyLinkedList.h

546

element = elLink->next;

headers/private/fs_shell/DoublyLinkedList.h

55

inline Link *operator()(Element *element) const

headers/private/fs_shell/DoublyLinkedList.h

559

Element *element = Head();

headers/private/fs_shell/DoublyLinkedList.h

560

Remove(element);

headers/private/fs_shell/DoublyLinkedList.h

561

return element;

headers/private/fs_shell/DoublyLinkedList.h

567

DOUBLY_LINKED_LIST_CLASS_NAME::GetPrevious(Element *element) const

headers/private/fs_shell/DoublyLinkedList.h

57

return element->GetDoublyLinkedListLink();

headers/private/fs_shell/DoublyLinkedList.h

570

if (element)

headers/private/fs_shell/DoublyLinkedList.h

571

result = sGetLink(element)->previous;

headers/private/fs_shell/DoublyLinkedList.h

578

DOUBLY_LINKED_LIST_CLASS_NAME::GetNext(Element *element) const

headers/private/fs_shell/DoublyLinkedList.h

581

if (element)

headers/private/fs_shell/DoublyLinkedList.h

582

result = sGetLink(element)->next;

headers/private/fs_shell/DoublyLinkedList.h

592

for (Element* element = First(); element; element = GetNext(element))

headers/private/fs_shell/DoublyLinkedList.h

60

inline const Link *operator()(const Element *element) const

headers/private/fs_shell/DoublyLinkedList.h

62

return element->GetDoublyLinkedListLink();

headers/private/fs_shell/DoublyLinkedList.h

74

inline Link *operator()(Element *element) const

headers/private/fs_shell/DoublyLinkedList.h

76

return &(element->*LinkMember);

headers/private/fs_shell/DoublyLinkedList.h

79

inline const Link *operator()(const Element *element) const

headers/private/fs_shell/DoublyLinkedList.h

81

return &(element->*LinkMember);

headers/private/fs_shell/DoublyLinkedList.h

92

inline Link *operator()(Element *element) const

headers/private/fs_shell/DoublyLinkedList.h

94

return (Link *)&element->link;

headers/private/fs_shell/DoublyLinkedList.h

97

inline const Link *operator()(const Element *element) const

headers/private/fs_shell/DoublyLinkedList.h

99

return (const Link *)&element->link;

headers/private/fs_shell/SinglyLinkedList.h

121

Element* element = fNext;

headers/private/fs_shell/SinglyLinkedList.h

124

return element;

headers/private/fs_shell/SinglyLinkedList.h

150

inline void Add(Element* element);

headers/private/fs_shell/SinglyLinkedList.h

151

inline void Remove(Element* element);

headers/private/fs_shell/SinglyLinkedList.h

161

inline Element* GetNext(Element* element) const;

headers/private/fs_shell/SinglyLinkedList.h

180

SINGLY_LINKED_LIST_CLASS_NAME::Add(Element* element)

headers/private/fs_shell/SinglyLinkedList.h

182

if (element != NULL) {

headers/private/fs_shell/SinglyLinkedList.h

183

sGetLink(element)->next = fFirst;

headers/private/fs_shell/SinglyLinkedList.h

184

fFirst = element;

headers/private/fs_shell/SinglyLinkedList.h

191

SINGLY_LINKED_LIST_CLASS_NAME::Remove(Element* element)

headers/private/fs_shell/SinglyLinkedList.h

193

if (element == NULL)

headers/private/fs_shell/SinglyLinkedList.h

198

while (next != NULL && element != next) {

headers/private/fs_shell/SinglyLinkedList.h

203

Link* elementLink = sGetLink(element);

headers/private/fs_shell/SinglyLinkedList.h

217

Element* element = fFirst;

headers/private/fs_shell/SinglyLinkedList.h

218

while (element) {

headers/private/fs_shell/SinglyLinkedList.h

219

Link* elLink = sGetLink(element);

headers/private/fs_shell/SinglyLinkedList.h

220

element = elLink->next;

headers/private/fs_shell/SinglyLinkedList.h

231

Element* element = Head();

headers/private/fs_shell/SinglyLinkedList.h

232

Remove(element);

headers/private/fs_shell/SinglyLinkedList.h

233

return element;

headers/private/fs_shell/SinglyLinkedList.h

239

SINGLY_LINKED_LIST_CLASS_NAME::GetNext(Element* element) const

headers/private/fs_shell/SinglyLinkedList.h

242

if (element)

headers/private/fs_shell/SinglyLinkedList.h

243

result = sGetLink(element)->next;

headers/private/fs_shell/SinglyLinkedList.h

253

for (Element* element = First(); element; element = GetNext(element))

headers/private/fs_shell/SinglyLinkedList.h

55

inline Link* operator()(Element* element) const

headers/private/fs_shell/SinglyLinkedList.h

57

return element->GetSinglyLinkedListLink();

headers/private/fs_shell/SinglyLinkedList.h

60

inline const Link* operator()(const Element* element) const

headers/private/fs_shell/SinglyLinkedList.h

62

return element->GetSinglyLinkedListLink();

headers/private/fs_shell/SinglyLinkedList.h

74

inline Link* operator()(Element* element) const

headers/private/fs_shell/SinglyLinkedList.h

76

return &(element->*LinkMember);

headers/private/fs_shell/SinglyLinkedList.h

79

inline const Link* operator()(const Element* element) const

headers/private/fs_shell/SinglyLinkedList.h

81

return &(element->*LinkMember);

headers/private/kernel/smp.h

135

int32* element = (int32*)&fBitmap[cpu / kArrayBits];

headers/private/kernel/smp.h

136

*element |= 1u << (cpu % kArrayBits);

headers/private/kernel/smp.h

143

int32* element = (int32*)&fBitmap[cpu / kArrayBits];

headers/private/kernel/smp.h

144

*element &= ~uint32(1u << (cpu % kArrayBits));

headers/private/kernel/smp.h

151

int32* element = (int32*)&fBitmap[cpu / kArrayBits];

headers/private/kernel/smp.h

152

atomic_or(element, 1u << (cpu % kArrayBits));

headers/private/kernel/smp.h

159

int32* element = (int32*)&fBitmap[cpu / kArrayBits];

headers/private/kernel/smp.h

160

atomic_and(element, ~uint32(1u << (cpu % kArrayBits)));

headers/private/kernel/smp.h

167

int32* element = (int32*)&fBitmap[cpu / kArrayBits];

headers/private/kernel/smp.h

168

return ((uint32)*element & (1u << (cpu % kArrayBits))) != 0;

headers/private/kernel/smp.h

175

int32* element = (int32*)&fBitmap[cpu / kArrayBits];

headers/private/kernel/smp.h

176

return ((uint32)atomic_get(element) & (1u << (cpu % kArrayBits))) != 0;

headers/private/kernel/util/AVLTreeBase.h

63

status_t Insert(AVLTreeNode* element);

headers/private/kernel/util/AVLTreeBase.h

65

bool Remove(AVLTreeNode* element);

headers/private/kernel/util/Heap.h

130

HeapStandardGetLink<Element, Key>::operator()(Element* element) const

headers/private/kernel/util/Heap.h

132

return element->GetHeapLink();

headers/private/kernel/util/Heap.h

139

HeapMemberGetLink<Element, Key, LinkMember>::operator()(Element* element) const

headers/private/kernel/util/Heap.h

141

return &(element->*LinkMember);

headers/private/kernel/util/Heap.h

201

HEAP_CLASS_NAME::GetKey(Element* element)

headers/private/kernel/util/Heap.h

203

return sGetLink(element)->fKey;

headers/private/kernel/util/Heap.h

209

HEAP_CLASS_NAME::ModifyKey(Element* element, Key newKey)

headers/private/kernel/util/Heap.h

211

HeapLink<Element, Key>* link = sGetLink(element);

headers/private/kernel/util/Heap.h

231

Element* element = PeekRoot();

headers/private/kernel/util/Heap.h

232

HeapLink<Element, Key>* link = sGetLink(element);

headers/private/kernel/util/Heap.h

249

HEAP_CLASS_NAME::Insert(Element* element, Key key)

headers/private/kernel/util/Heap.h

259

HeapLink<Element, Key>* link = sGetLink(element);

headers/private/kernel/util/Heap.h

263

fElements[fLastElement] = element;

headers/private/kernel/util/Heap.h

302

Element* element = fElements[link->fIndex];

headers/private/kernel/util/Heap.h

304

fElements[parent] = element;

headers/private/kernel/util/Heap.h

340

Element* element = fElements[link->fIndex];

headers/private/kernel/util/Heap.h

342

fElements[current] = element;

headers/private/kernel/util/Heap.h

43

inline Link* operator()(Element* element) const;

headers/private/kernel/util/Heap.h

53

inline Link* operator()(Element* element) const;

headers/private/kernel/util/Heap.h

83

static const Key& GetKey(Element* element);

headers/private/kernel/util/Heap.h

85

inline void ModifyKey(Element* element, Key newKey);

headers/private/kernel/util/Heap.h

88

inline status_t Insert(Element* element, Key key);

headers/private/kernel/util/MinMaxHeap.h

135

MinMaxHeapStandardGetLink<Element, Key>::operator()(Element* element) const

headers/private/kernel/util/MinMaxHeap.h

137

return element->GetMinMaxHeapLink();

headers/private/kernel/util/MinMaxHeap.h

145

Element* element) const

headers/private/kernel/util/MinMaxHeap.h

147

return &(element->*LinkMember);

headers/private/kernel/util/MinMaxHeap.h

221

MIN_MAX_HEAP_CLASS_NAME::GetKey(Element* element)

headers/private/kernel/util/MinMaxHeap.h

223

return sGetLink(element)->fKey;

headers/private/kernel/util/MinMaxHeap.h

229

MIN_MAX_HEAP_CLASS_NAME::ModifyKey(Element* element, Key newKey)

headers/private/kernel/util/MinMaxHeap.h

231

MinMaxHeapLink<Element, Key>* link = sGetLink(element);

headers/private/kernel/util/MinMaxHeap.h

257

Element* element = PeekMinimum();

headers/private/kernel/util/MinMaxHeap.h

258

MinMaxHeapLink<Element, Key>* link = sGetLink(element);

headers/private/kernel/util/MinMaxHeap.h

278

Element* element = PeekMaximum();

headers/private/kernel/util/MinMaxHeap.h

279

MinMaxHeapLink<Element, Key>* link = sGetLink(element);

headers/private/kernel/util/MinMaxHeap.h

290

MIN_MAX_HEAP_CLASS_NAME::Insert(Element* element, Key key)

headers/private/kernel/util/MinMaxHeap.h

301

MinMaxHeapLink<Element, Key>* link = sGetLink(element);

headers/private/kernel/util/MinMaxHeap.h

310

tree[lastElement] = element;

headers/private/kernel/util/MinMaxHeap.h

360

Element* element = tree[link->fIndex];

headers/private/kernel/util/MinMaxHeap.h

362

tree[parent] = element;

headers/private/kernel/util/MinMaxHeap.h

403

Element* element = tree[link->fIndex];

headers/private/kernel/util/MinMaxHeap.h

405

tree[current] = element;

headers/private/kernel/util/MinMaxHeap.h

44

inline Link* operator()(Element* element) const;

headers/private/kernel/util/MinMaxHeap.h

446

Element* element = currentTree[link->fIndex];

headers/private/kernel/util/MinMaxHeap.h

448

otherTree[predecessorLink->fIndex] = element;

headers/private/kernel/util/MinMaxHeap.h

479

Element* element = tree[lastElement];

headers/private/kernel/util/MinMaxHeap.h

482

fMinElements[0] = element;

headers/private/kernel/util/MinMaxHeap.h

484

fMaxElements[0] = element;

headers/private/kernel/util/MinMaxHeap.h

486

MinMaxHeapLink<Element, Key>* link = sGetLink(element);

headers/private/kernel/util/MinMaxHeap.h

54

inline Link* operator()(Element* element) const;

headers/private/kernel/util/MinMaxHeap.h

79

static const Key& GetKey(Element* element);

headers/private/kernel/util/MinMaxHeap.h

81

inline void ModifyKey(Element* element, Key newKey);

headers/private/kernel/util/MinMaxHeap.h

86

inline status_t Insert(Element* element, Key key);

headers/private/kernel/util/Vector.h

176

inline VectorIterator(Value *element)

headers/private/kernel/util/Vector.h

177

: fElement(element)

headers/private/kernel/vm/vm_types.h

74

inline vm_page_mapping_link *operator()(vm_page_mapping *element) const

headers/private/kernel/vm/vm_types.h

76

return &element->page_link;

headers/private/kernel/vm/vm_types.h

80

const vm_page_mapping *element) const

headers/private/kernel/vm/vm_types.h

82

return &element->page_link;

headers/private/kernel/vm/vm_types.h

88

inline vm_page_mapping_link *operator()(vm_page_mapping *element) const

headers/private/kernel/vm/vm_types.h

90

return &element->area_link;

headers/private/kernel/vm/vm_types.h

94

const vm_page_mapping *element) const

headers/private/kernel/vm/vm_types.h

96

return &element->area_link;

headers/private/netservices/HttpForm.h

158

BString _GetMultipartHeader(const BHttpFormData* element) const;

headers/private/package/hpkg/Stacker.h

19

Stacker(Type*& location, Type* element)

headers/private/package/hpkg/Stacker.h

24

*fLocation = element;

headers/private/package/hpkg/Stacker.h

27

Stacker(Type** location, Type* element)

headers/private/package/hpkg/Stacker.h

32

*fLocation = element;

headers/private/shared/Array.h

115

Array<Element>::Insert(const Element& element, int32 index)

headers/private/shared/Array.h

123

fElements[index] = element;

headers/private/shared/Array.h

35

inline bool Add(const Element& element);

headers/private/shared/Array.h

37

inline bool Insert(const Element& element, int32 index);

headers/private/shared/Array.h

94

Array<Element>::Add(const Element& element)

headers/private/shared/Array.h

99

fElements[fSize] = element;

headers/private/shared/HashMap.h

378

Element* element = fTable.Lookup(key);

headers/private/shared/HashMap.h

379

if (element) {

headers/private/shared/HashMap.h

381

element->fValue = value;

headers/private/shared/HashMap.h

386

element = new(std::nothrow) Element(key, value);

headers/private/shared/HashMap.h

387

if (!element)

headers/private/shared/HashMap.h

390

status_t error = fTable.Insert(element);

headers/private/shared/HashMap.h

392

delete element;

headers/private/shared/HashMap.h

403

Element* element = fTable.Lookup(key);

headers/private/shared/HashMap.h

404

if (element == NULL)

headers/private/shared/HashMap.h

407

fTable.Remove(element);

headers/private/shared/HashMap.h

408

Value value = element->fValue;

headers/private/shared/HashMap.h

409

delete element;

headers/private/shared/HashMap.h

420

Element* element = it.fElement;

headers/private/shared/HashMap.h

421

if (element == NULL)

headers/private/shared/HashMap.h

424

Value value = element->fValue;

headers/private/shared/HashMap.h

426

fTable.RemoveUnchecked(element);

headers/private/shared/HashMap.h

427

delete element;

headers/private/shared/HashMap.h

440

Element* element = fTable.Clear(true);

headers/private/shared/HashMap.h

441

while (element != NULL) {

headers/private/shared/HashMap.h

442

Element* next = element->fNext;

headers/private/shared/HashMap.h

443

delete element;

headers/private/shared/HashMap.h

444

element = next;

headers/private/shared/HashMap.h

454

if (Element* element = fTable.Lookup(key))

headers/private/shared/HashMap.h

455

return element->fValue;

headers/private/shared/HashMap.h

465

if (Element* element = fTable.Lookup(key)) {

headers/private/shared/HashMap.h

466

_value = &element->fValue;

headers/private/shared/HashSet.h

246

Element* element = fTable.Lookup(key);

headers/private/shared/HashSet.h

247

if (element) {

headers/private/shared/HashSet.h

253

element = new(std::nothrow) Element(key);

headers/private/shared/HashSet.h

254

if (!element)

headers/private/shared/HashSet.h

257

status_t error = fTable.Insert(element);

headers/private/shared/HashSet.h

259

delete element;

headers/private/shared/HashSet.h

270

Element* element = fTable.Lookup(key);

headers/private/shared/HashSet.h

271

if (element == NULL)

headers/private/shared/HashSet.h

274

fTable.Remove(element);

headers/private/shared/HashSet.h

275

delete element;

headers/private/shared/HashSet.h

286

Element* element = it.fElement;

headers/private/shared/HashSet.h

287

if (element == NULL)

headers/private/shared/HashSet.h

290

fTable.RemoveUnchecked(element);

headers/private/shared/HashSet.h

291

delete element;

headers/private/shared/HashSet.h

304

Element* element = fTable.Clear(true);

headers/private/shared/HashSet.h

305

while (element != NULL) {

headers/private/shared/HashSet.h

306

Element* next = element->fNext;

headers/private/shared/HashSet.h

307

delete element;

headers/private/shared/HashSet.h

308

element = next;

headers/private/userlandfs/shared/Vector.h

172

inline VectorIterator<Value>(Value *element)

headers/private/userlandfs/shared/Vector.h

173

: fElement(element)

headers/private/util/DoublyLinkedList.h

101

return (Link*)&(element->*LinkMember);

headers/private/util/DoublyLinkedList.h

157

Element* element = fCurrent;

headers/private/util/DoublyLinkedList.h

162

return element;

headers/private/util/DoublyLinkedList.h

206

Element* element = fNext;

headers/private/util/DoublyLinkedList.h

209

return element;

headers/private/util/DoublyLinkedList.h

258

Element* element = fCurrent;

headers/private/util/DoublyLinkedList.h

263

return element;

headers/private/util/DoublyLinkedList.h

307

Element* element = fNext;

headers/private/util/DoublyLinkedList.h

310

return element;

headers/private/util/DoublyLinkedList.h

336

inline void InsertBefore(Element* insertBefore, Element* element);

headers/private/util/DoublyLinkedList.h

337

inline void InsertAfter(Element* insertAfter, Element* element);

headers/private/util/DoublyLinkedList.h

338

inline void Insert(Element* element, bool back = true);

headers/private/util/DoublyLinkedList.h

339

inline void Add(Element* element, bool back = true);

headers/private/util/DoublyLinkedList.h

340

inline void Remove(Element* element);

headers/private/util/DoublyLinkedList.h

358

static inline Element* GetPrevious(Element* element);

headers/private/util/DoublyLinkedList.h

359

static inline Element* GetNext(Element* element);

headers/private/util/DoublyLinkedList.h

361

inline bool Contains(Element* element) const;

headers/private/util/DoublyLinkedList.h

380

inline void Insert(Element* before, Element* element);

headers/private/util/DoublyLinkedList.h

396

DOUBLY_LINKED_LIST_CLASS_NAME::Insert(Element* element, bool back)

headers/private/util/DoublyLinkedList.h

398

if (element) {

headers/private/util/DoublyLinkedList.h

404

Link* elLink = sGetLink(element);

headers/private/util/DoublyLinkedList.h

410

sGetLink(fLast)->next = element;

headers/private/util/DoublyLinkedList.h

412

fFirst = element;

headers/private/util/DoublyLinkedList.h

413

fLast = element;

headers/private/util/DoublyLinkedList.h

419

sGetLink(fFirst)->previous = element;

headers/private/util/DoublyLinkedList.h

421

fLast = element;

headers/private/util/DoublyLinkedList.h

422

fFirst = element;

headers/private/util/DoublyLinkedList.h

430

DOUBLY_LINKED_LIST_CLASS_NAME::InsertBefore(Element* before, Element* element)

headers/private/util/DoublyLinkedList.h

432

ASSERT(element != NULL);

headers/private/util/DoublyLinkedList.h

435

Insert(element);

headers/private/util/DoublyLinkedList.h

445

Link* link = sGetLink(element);

headers/private/util/DoublyLinkedList.h

449

beforeLink->previous = element;

headers/private/util/DoublyLinkedList.h

452

sGetLink(link->previous)->next = element;

headers/private/util/DoublyLinkedList.h

454

fFirst = element;

headers/private/util/DoublyLinkedList.h

460

DOUBLY_LINKED_LIST_CLASS_NAME::InsertAfter(Element* after, Element* element)

headers/private/util/DoublyLinkedList.h

462

ASSERT(element != NULL);

headers/private/util/DoublyLinkedList.h

465

Insert(element, false);

headers/private/util/DoublyLinkedList.h

475

Link* link = sGetLink(element);

headers/private/util/DoublyLinkedList.h

479

afterLink->next = element;

headers/private/util/DoublyLinkedList.h

482

sGetLink(link->next)->previous = element;

headers/private/util/DoublyLinkedList.h

484

fLast = element;

headers/private/util/DoublyLinkedList.h

490

DOUBLY_LINKED_LIST_CLASS_NAME::Insert(Element* before, Element* element)

headers/private/util/DoublyLinkedList.h

492

InsertBefore(before, element);

headers/private/util/DoublyLinkedList.h

499

DOUBLY_LINKED_LIST_CLASS_NAME::Add(Element* element, bool back)

headers/private/util/DoublyLinkedList.h

501

Insert(element, back);

headers/private/util/DoublyLinkedList.h

507

DOUBLY_LINKED_LIST_CLASS_NAME::Remove(Element* element)

headers/private/util/DoublyLinkedList.h

509

if (element == NULL)

headers/private/util/DoublyLinkedList.h

514

&& (fFirst != fLast || element == fFirst),

headers/private/util/DoublyLinkedList.h

515

"list: %p, element: %p\n", this, element);

headers/private/util/DoublyLinkedList.h

518

Link* elLink = sGetLink(element);

headers/private/util/DoublyLinkedList.h

520

if (element == fFirst)

headers/private/util/DoublyLinkedList.h

525

if (element == fLast)

headers/private/util/DoublyLinkedList.h

56

inline Link* operator()(Element* element) const

headers/private/util/DoublyLinkedList.h

58

return element->GetDoublyLinkedListLink();

headers/private/util/DoublyLinkedList.h

589

Element* element = Head();

headers/private/util/DoublyLinkedList.h

590

Remove(element);

headers/private/util/DoublyLinkedList.h

591

return element;

headers/private/util/DoublyLinkedList.h

599

Element* element = Tail();

headers/private/util/DoublyLinkedList.h

600

Remove(element);

headers/private/util/DoublyLinkedList.h

601

return element;

headers/private/util/DoublyLinkedList.h

607

DOUBLY_LINKED_LIST_CLASS_NAME::GetPrevious(Element* element)

headers/private/util/DoublyLinkedList.h

61

inline const Link* operator()(const Element* element) const

headers/private/util/DoublyLinkedList.h

610

if (element)

headers/private/util/DoublyLinkedList.h

611

result = sGetLink(element)->previous;

headers/private/util/DoublyLinkedList.h

618

DOUBLY_LINKED_LIST_CLASS_NAME::GetNext(Element* element)

headers/private/util/DoublyLinkedList.h

621

if (element)

headers/private/util/DoublyLinkedList.h

622

result = sGetLink(element)->next;

headers/private/util/DoublyLinkedList.h

63

return element->GetDoublyLinkedListLink();

headers/private/util/DoublyLinkedList.h

631

for (Element* element = First(); element; element = GetNext(element)) {

headers/private/util/DoublyLinkedList.h

632

if (element == _element)

headers/private/util/DoublyLinkedList.h

646

for (Element* element = First(); element; element = GetNext(element))

headers/private/util/DoublyLinkedList.h

661

Element* element = tail;

headers/private/util/DoublyLinkedList.h

662

while ((element = GetNext(element)) != NULL) {

headers/private/util/DoublyLinkedList.h

663

if (less(element, leastElement))

headers/private/util/DoublyLinkedList.h

664

leastElement = element;

headers/private/util/DoublyLinkedList.h

75

inline Link* operator()(Element* element) const

headers/private/util/DoublyLinkedList.h

77

return &(element->*LinkMember);

headers/private/util/DoublyLinkedList.h

80

inline const Link* operator()(const Element* element) const

headers/private/util/DoublyLinkedList.h

82

return &(element->*LinkMember);

headers/private/util/DoublyLinkedList.h

94

inline Link* operator()(Element* element) const

headers/private/util/DoublyLinkedList.h

96

return (Link*)&(element->*LinkMember);

headers/private/util/DoublyLinkedList.h

99

inline const Link* operator()(const Element* element) const

headers/private/util/DoublyLinkedQueue.h

112

Element *element = fNext;

headers/private/util/DoublyLinkedQueue.h

115

return element;

headers/private/util/DoublyLinkedQueue.h

141

inline void Insert(Element *element);

headers/private/util/DoublyLinkedQueue.h

142

inline void InsertBefore(Element *before, Element *element);

headers/private/util/DoublyLinkedQueue.h

143

inline void Add(Element *element);

headers/private/util/DoublyLinkedQueue.h

144

inline void Remove(Element *element);

headers/private/util/DoublyLinkedQueue.h

158

inline Element *GetPrevious(Element *element) const;

headers/private/util/DoublyLinkedQueue.h

159

inline Element *GetNext(Element *element) const;

headers/private/util/DoublyLinkedQueue.h

179

DOUBLY_LINKED_QUEUE_CLASS_NAME::Insert(Element *element)

headers/private/util/DoublyLinkedQueue.h

181

if (element) {

headers/private/util/DoublyLinkedQueue.h

182

Link *elLink = sGetLink(element);

headers/private/util/DoublyLinkedQueue.h

186

sGetLink(fFirst)->previous = element;

headers/private/util/DoublyLinkedQueue.h

187

fFirst = element;

headers/private/util/DoublyLinkedQueue.h

194

DOUBLY_LINKED_QUEUE_CLASS_NAME::InsertBefore(Element *before, Element *element)

headers/private/util/DoublyLinkedQueue.h

197

Insert(element);

headers/private/util/DoublyLinkedQueue.h

200

if (element == NULL)

headers/private/util/DoublyLinkedQueue.h

204

Link *link = sGetLink(element);

headers/private/util/DoublyLinkedQueue.h

209

sGetLink(link->previous)->next = element;

headers/private/util/DoublyLinkedQueue.h

210

beforeLink->previous = element;

headers/private/util/DoublyLinkedQueue.h

213

fFirst = element;

headers/private/util/DoublyLinkedQueue.h

219

DOUBLY_LINKED_QUEUE_CLASS_NAME::Add(Element *element)

headers/private/util/DoublyLinkedQueue.h

221

Insert(element);

headers/private/util/DoublyLinkedQueue.h

227

DOUBLY_LINKED_QUEUE_CLASS_NAME::Remove(Element *element)

headers/private/util/DoublyLinkedQueue.h

229

if (element == NULL)

headers/private/util/DoublyLinkedQueue.h

234

"queue: %p, element: %p\n", this, element);

headers/private/util/DoublyLinkedQueue.h

237

Link *elLink = sGetLink(element);

headers/private/util/DoublyLinkedQueue.h

238

if (element == fFirst)

headers/private/util/DoublyLinkedQueue.h

291

Element *element = fFirst;

headers/private/util/DoublyLinkedQueue.h

293

while ((elLink = sGetLink(element))->next) {

headers/private/util/DoublyLinkedQueue.h

294

element = elLink->next;

headers/private/util/DoublyLinkedQueue.h

309

Element *element = fFirst;

headers/private/util/DoublyLinkedQueue.h

310

while (element) {

headers/private/util/DoublyLinkedQueue.h

311

Link *elLink = sGetLink(element);

headers/private/util/DoublyLinkedQueue.h

312

element = elLink->next;

headers/private/util/DoublyLinkedQueue.h

324

Element *element = Head();

headers/private/util/DoublyLinkedQueue.h

325

Remove(element);

headers/private/util/DoublyLinkedQueue.h

326

return element;

headers/private/util/DoublyLinkedQueue.h

332

DOUBLY_LINKED_QUEUE_CLASS_NAME::GetPrevious(Element *element) const

headers/private/util/DoublyLinkedQueue.h

335

if (element)

headers/private/util/DoublyLinkedQueue.h

336

result = sGetLink(element)->previous;

headers/private/util/DoublyLinkedQueue.h

343

DOUBLY_LINKED_QUEUE_CLASS_NAME::GetNext(Element *element) const

headers/private/util/DoublyLinkedQueue.h

346

if (element)

headers/private/util/DoublyLinkedQueue.h

347

result = sGetLink(element)->next;

headers/private/util/DoublyLinkedQueue.h

357

for (Element* element = First(); element; element = GetNext(element))

headers/private/util/DoublyLinkedQueue.h

63

Element *element = fCurrent;

headers/private/util/DoublyLinkedQueue.h

68

return element;

headers/private/util/OpenHashTable.h

278

ValueType* element = fTable[i];

headers/private/util/OpenHashTable.h

279

if (element != NULL) {

headers/private/util/OpenHashTable.h

281

*nextPointer = element;

headers/private/util/OpenHashTable.h

285

while (element != NULL) {

headers/private/util/OpenHashTable.h

286

nextPointer = &_Link(element);

headers/private/util/OpenHashTable.h

287

element = *nextPointer;

headers/private/util/SinglyLinkedList.h

118

Element* element = fNext;

headers/private/util/SinglyLinkedList.h

121

return element;

headers/private/util/SinglyLinkedList.h

147

inline void Add(Element* element);

headers/private/util/SinglyLinkedList.h

148

inline bool Remove(Element* element);

headers/private/util/SinglyLinkedList.h

149

inline void Remove(Element* previous, Element* element);

headers/private/util/SinglyLinkedList.h

162

inline Element* GetNext(Element* element) const;

headers/private/util/SinglyLinkedList.h

181

SINGLY_LINKED_LIST_CLASS_NAME::Add(Element* element)

headers/private/util/SinglyLinkedList.h

183

if (element != NULL) {

headers/private/util/SinglyLinkedList.h

184

sGetLink(element)->next = fFirst;

headers/private/util/SinglyLinkedList.h

185

fFirst = element;

headers/private/util/SinglyLinkedList.h

199

SINGLY_LINKED_LIST_CLASS_NAME::Remove(Element* element)

headers/private/util/SinglyLinkedList.h

201

if (element == NULL)

headers/private/util/SinglyLinkedList.h

206

while (element != next) {

headers/private/util/SinglyLinkedList.h

213

Link* elementLink = sGetLink(element);

headers/private/util/SinglyLinkedList.h

226

SINGLY_LINKED_LIST_CLASS_NAME::Remove(Element* previous, Element* element)

headers/private/util/SinglyLinkedList.h

231

Link* elementLink = sGetLink(element);

headers/private/util/SinglyLinkedList.h

270

Element* element = fFirst;

headers/private/util/SinglyLinkedList.h

271

while (element) {

headers/private/util/SinglyLinkedList.h

272

Link* elLink = sGetLink(element);

headers/private/util/SinglyLinkedList.h

273

element = elLink->next;

headers/private/util/SinglyLinkedList.h

284

Element* element = Head();

headers/private/util/SinglyLinkedList.h

285

Remove(element);

headers/private/util/SinglyLinkedList.h

286

return element;

headers/private/util/SinglyLinkedList.h

292

SINGLY_LINKED_LIST_CLASS_NAME::GetNext(Element* element) const

headers/private/util/SinglyLinkedList.h

295

if (element)

headers/private/util/SinglyLinkedList.h

296

result = sGetLink(element)->next;

headers/private/util/SinglyLinkedList.h

306

for (Element* element = First(); element; element = GetNext(element))

headers/private/util/SinglyLinkedList.h

52

inline Link* operator()(Element* element) const

headers/private/util/SinglyLinkedList.h

54

return element->GetSinglyLinkedListLink();

headers/private/util/SinglyLinkedList.h

57

inline const Link* operator()(const Element* element) const

headers/private/util/SinglyLinkedList.h

59

return element->GetSinglyLinkedListLink();

headers/private/util/SinglyLinkedList.h

71

inline Link* operator()(Element* element) const

headers/private/util/SinglyLinkedList.h

73

return &(element->*LinkMember);

headers/private/util/SinglyLinkedList.h

76

inline const Link* operator()(const Element* element) const

headers/private/util/SinglyLinkedList.h

78

return &(element->*LinkMember);

headers/private/util/SplayTree.h

407

Node* element = fCurrent;

headers/private/util/SplayTree.h

412

return element;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

496

#define CHECK_DMA_MODE(element, mode) \

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

497

if (fInfoBlock.element) { \

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

1875

struct firewire_child_info *element = fc->childList;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

1914

while(element){

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

1916

fdc = (struct firewire_dev_comm *)element->cookie;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

1919

element = element->link;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

361

struct firewire_child_info *element, *info;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

365

element = sc->fc->childList;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

366

while (element) {

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

367

if (strcmp(element->child_name, childname) == 0) {

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

372

element = element->link;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

386

element = sc->fc->childList;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

387

if (element) {

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

388

while (element->link)

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

389

element = element->link;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

390

element->link = info;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

402

struct firewire_child_info *element = sc->fc->childList;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

403

struct firewire_child_info *temp = element;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

404

while (element) {

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

405

if (strcmp(element->child_name, childname) == 0) {

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

407

element->notify_hooks.device_detach(sc, element->cookie);

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

411

temp->link = element->link;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

413

free(element);

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

417

temp = element;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

418

element = element->link;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

513

struct firewire_child_info *element, *temp;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

534

element = sc->fc->childList;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

535

while(element){

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

536

element->notify_hooks.device_detach(sc, element->cookie);

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

537

temp = element;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

538

element = element->link;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

743

struct firewire_child_info *element = fc->childList;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

768

while(element){

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

770

fdc = (struct firewire_dev_comm *)element->cookie;

src/add-ons/kernel/bus_managers/firewire/firewire.cpp

773

element = element->link;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

352

usb_driver_info *element = fDriverList;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

353

while (element) {

src/add-ons/kernel/bus_managers/usb/Stack.cpp

354

status_t result = device->ReportDevice(element->support_descriptors,

src/add-ons/kernel/bus_managers/usb/Stack.cpp

355

element->support_descriptor_count, &element->notify_hooks,

src/add-ons/kernel/bus_managers/usb/Stack.cpp

356

&element->cookies, added, false);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

359

const char *driverName = element->driver_name;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

360

if (element->republish_driver_name)

src/add-ons/kernel/bus_managers/usb/Stack.cpp

361

driverName = element->republish_driver_name;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

385

element = element->link;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

422

usb_driver_info *element = fDriverList;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

423

while (element) {

src/add-ons/kernel/bus_managers/usb/Stack.cpp

424

if (strcmp(element->driver_name, driverName) == 0) {

src/add-ons/kernel/bus_managers/usb/Stack.cpp

426

free((char *)element->republish_driver_name);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

427

element->republish_driver_name = strdup(republishDriverName);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

429

free(element->support_descriptors);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

431

element->support_descriptors = (usb_support_descriptor *)malloc(descriptorsSize);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

432

memcpy(element->support_descriptors, descriptors, descriptorsSize);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

433

element->support_descriptor_count = descriptorCount;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

439

element = element->link;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

463

usb_driver_info *element = fDriverList;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

464

while (element->link)

src/add-ons/kernel/bus_managers/usb/Stack.cpp

465

element = element->link;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

467

element->link = info;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

481

usb_driver_info *element = fDriverList;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

482

while (element) {

src/add-ons/kernel/bus_managers/usb/Stack.cpp

483

if (strcmp(element->driver_name, driverName) == 0) {

src/add-ons/kernel/bus_managers/usb/Stack.cpp

492

rootHub->ReportDevice(element->support_descriptors,

src/add-ons/kernel/bus_managers/usb/Stack.cpp

493

element->support_descriptor_count, hooks,

src/add-ons/kernel/bus_managers/usb/Stack.cpp

494

&element->cookies, true, true);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

498

element->notify_hooks.device_added = hooks->device_added;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

499

element->notify_hooks.device_removed = hooks->device_removed;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

504

element = element->link;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

516

usb_driver_info *element = fDriverList;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

517

while (element) {

src/add-ons/kernel/bus_managers/usb/Stack.cpp

518

if (strcmp(element->driver_name, driverName) == 0) {

src/add-ons/kernel/bus_managers/usb/Stack.cpp

526

rootHub->ReportDevice(element->support_descriptors,

src/add-ons/kernel/bus_managers/usb/Stack.cpp

527

element->support_descriptor_count,

src/add-ons/kernel/bus_managers/usb/Stack.cpp

528

&element->notify_hooks, &element->cookies, false, true);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

531

element->notify_hooks.device_added = NULL;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

532

element->notify_hooks.device_removed = NULL;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

537

element = element->link;

src/add-ons/kernel/bus_managers/virtio/VirtioQueue.cpp

260

struct vring_used_elem *element = &fRing.used->ring[usedIndex];

src/add-ons/kernel/bus_managers/virtio/VirtioQueue.cpp

261

uint16 descriptorIndex = element->id;

src/add-ons/kernel/bus_managers/virtio/VirtioQueue.cpp

263

*_usedLength = element->len;

src/add-ons/kernel/busses/usb/uhci.cpp

419

uhci_qh *element = fQueueTop;

src/add-ons/kernel/busses/usb/uhci.cpp

420

while (element->link_log != NULL)

src/add-ons/kernel/busses/usb/uhci.cpp

421

element = (uhci_qh *)element->link_log;

src/add-ons/kernel/busses/usb/uhci.cpp

423

element->link_log = transfer;

src/add-ons/kernel/busses/usb/uhci.cpp

424

element->link_phy = transfer->this_phy | QH_NEXT_IS_QH;

src/add-ons/kernel/busses/usb/uhci.cpp

454

uhci_qh *element = fQueueTop;

src/add-ons/kernel/busses/usb/uhci.cpp

455

while (element) {

src/add-ons/kernel/busses/usb/uhci.cpp

456

if (element->link_log == transfer) {

src/add-ons/kernel/busses/usb/uhci.cpp

457

element->link_log = transfer->link_log;

src/add-ons/kernel/busses/usb/uhci.cpp

458

element->link_phy = transfer->link_phy;

src/add-ons/kernel/busses/usb/uhci.cpp

464

element = (uhci_qh *)element->link_log;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

1006

raw_device *element = gDeviceList;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

1007

while (element) {

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

1008

gDeviceNames[index++] = strdup(element->name);

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

1009

element = (raw_device *)element->link;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

115

raw_device *element = gDeviceList;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

116

while (element) {

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

117

if (element->link == device) {

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

118

element->link = device->link;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

122

element = (raw_device *)element->link;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

202

raw_device *element = gDeviceList;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

203

while (element) {

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

204

if (strcmp(name, element->name) == 0) {

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

205

element->reference_count++;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

206

*cookie = element;

src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp

211

element = (raw_device *)element->link;

src/add-ons/kernel/drivers/common/usb_modeswitch.cpp

563

my_device *element = gDeviceList;

src/add-ons/kernel/drivers/common/usb_modeswitch.cpp

564

while (element) {

src/add-ons/kernel/drivers/common/usb_modeswitch.cpp

565

if (element->link == device) {

src/add-ons/kernel/drivers/common/usb_modeswitch.cpp

566

element->link = device->link;

src/add-ons/kernel/drivers/common/usb_modeswitch.cpp

570

element = element->link;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

106

RevokeElement* element = fHash->Lookup(block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

108

if (element == NULL)

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

111

return element->commitID >= commitID;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

146

RevokeElement* element = new(std::nothrow) RevokeElement;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

148

if (element == NULL)

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

151

element->block = block;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

152

element->commitID = commitID;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

154

status_t retValue = fHash->Insert(element);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

36

RevokeElement *element = fHash->Clear(true);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

38

while (element != NULL) {

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

39

RevokeElement* next = element->next;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

40

delete element;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

41

element = next;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

65

RevokeElement* element = fHash->Lookup(block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

67

if (element != NULL) {

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

69

if (element->commitID < commitID) {

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

71

bool retValue = fHash->Remove(element);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

76

delete element;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

90

RevokeElement* element = fHash->Lookup(block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

92

if (element == NULL)

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

95

fHash->Remove(element);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

98

delete element;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

63

static int Compare(void* element, const void* key);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

64

static uint32 Hash(void* element, const void* key, uint32 range);

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

297

write_buffer *element = fWriteBuffers;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

298

while (element) {

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

299

write_buffer *next = element->next;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

300

free(element);

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

301

element = next;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

689

write_buffer *element = fWriteBuffers;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

699

if (element != NULL) {

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

700

gapSize = (size_t)MIN((off_t)bytesLeft, element->position > position ?

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

701

element->position - position : 0);

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

766

if (bytesLeft == 0 || element == NULL)

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

769

off_t elementEnd = element->position + element->length;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

774

const void *source = element->buffer + (position

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

775

- element->position);

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

787

element = element->next;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

865

write_buffer *element = (write_buffer *)malloc(sizeof(write_buffer) - 1

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

867

if (element == NULL)

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

870

element->next = *link;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

871

element->position = newPosition;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

872

element->length = newLength;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

873

*link = element;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

888

memcpy(element->buffer + (swallow->position - newPosition),

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

891

element->next = swallow->next;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

893

swallow = element->next;

src/add-ons/kernel/file_systems/layers/write_overlay/write_overlay.cpp

897

void *target = element->buffer + (position - newPosition);

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

105

BlockingQueue<Element>::Pop(Element** element, bigtime_t timeout)

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

117

*element = fElements.ElementAt(0);

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

125

BlockingQueue<Element>::Peek(Element** element)

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

133

*element = fElements.ElementAt(0);

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

140

BlockingQueue<Element>::Remove(Element* element)

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

149

int32 count = fElements.Remove(element);

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

26

status_t Push(Element* element);

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

27

status_t Pop(Element** element,

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

29

status_t Peek(Element** element);

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

30

status_t Remove(Element* element);

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

88

BlockingQueue<Element>::Push(Element* element)

src/add-ons/kernel/file_systems/netfs/headers/shared/BlockingQueue.h

93

status_t error = fElements.PushBack(element);

src/add-ons/kernel/file_systems/netfs/headers/shared/RequestMemberArray.h

66

Member* element = new(fElements + i) Member;

src/add-ons/kernel/file_systems/netfs/headers/shared/RequestMemberArray.h

68

unflattener->Visit(this, *element);

src/add-ons/kernel/file_systems/netfs/headers/shared/RequestMemberArray.h

74

status_t Append(const Member& element)

src/add-ons/kernel/file_systems/netfs/headers/shared/RequestMemberArray.h

79

new(fElements + fSize) Member(element);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

102

Element *element = fCurrent;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

107

return element;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

146

Element *element = fNext;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

149

return element;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

172

inline void Insert(Element *element, bool back = true);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

173

inline void InsertAfter(Element *previous, Element *element);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

174

inline void Remove(Element *element);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

187

inline Element *GetNext(Element *element) const;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

198

inline void _Remove(Element *previous, Element *element);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

218

SL_LIST_CLASS_NAME::Insert(Element *element, bool back)

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

220

InsertAfter((back ? fLast : NULL), element);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

226

SL_LIST_CLASS_NAME::InsertAfter(Element *previous, Element *element)

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

228

if (element) {

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

229

Link *elLink = fGetLink(element);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

234

prevLink->next = element;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

238

fFirst = element;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

243

fLast = element;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

250

SL_LIST_CLASS_NAME::Remove(Element *element)

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

252

if (!element)

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

256

if (element == it.Next()) {

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

286

Element *element = fFirst;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

287

while (element) {

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

288

Link *elLink = fGetLink(element);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

289

element = elLink->next;

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

299

SL_LIST_CLASS_NAME::GetNext(Element *element) const

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

301

return (element ? fGetLink(element)->next : NULL);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

307

SL_LIST_CLASS_NAME::_Remove(Element *previous, Element *element)

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

309

Link *elLink = fGetLink(element);

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

315

if (element == fLast)

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

327

for (Element* element = GetFirst(); element; element = GetNext(element))

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

44

inline Link *operator()(Element *element) const

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

46

return element->GetSLListLink();

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

49

inline const Link *operator()(const Element *element) const

src/add-ons/kernel/file_systems/netfs/headers/shared/SLList.h

51

return element->GetSLListLink();

src/add-ons/kernel/file_systems/ramfs/NodeTable.cpp

55

if (Node *element = fNodes.Lookup(id))

src/add-ons/kernel/file_systems/ramfs/NodeTable.cpp

56

fNodes.Remove(element);

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

478

const TreePath::Element *element = fPath->GetTopElement();

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

480

error = fTree->GetNode(element->GetBlockNumber(), &node);

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

485

fIndex = element->GetIndex();

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

90

Element *element = NULL;

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

92

element = fElements + index;

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

93

return element;

src/add-ons/translators/rtf/RTF.cpp

104

dump(Element &element, int32 level = 0)

src/add-ons/translators/rtf/RTF.cpp

106

printf("%03" B_PRId32 " (%p):", level, &element);

src/add-ons/translators/rtf/RTF.cpp

110

if (RTF::Header *header = dynamic_cast<RTF::Header *>(&element)) {

src/add-ons/translators/rtf/RTF.cpp

112

} else if (RTF::Command *command = dynamic_cast<RTF::Command *>(&element)) {

src/add-ons/translators/rtf/RTF.cpp

117

} else if (RTF::Text *text = dynamic_cast<RTF::Text *>(&element)) {

src/add-ons/translators/rtf/RTF.cpp

120

} else if (RTF::Group *group = dynamic_cast<RTF::Group *>(&element))

src/add-ons/translators/rtf/RTF.cpp

123

if (RTF::Group *group = dynamic_cast<RTF::Group *>(&element)) {

src/add-ons/translators/rtf/RTF.cpp

174

Element *element = NULL;

src/add-ons/translators/rtf/RTF.cpp

183

parent->AddElement(element = new Group());

src/add-ons/translators/rtf/RTF.cpp

184

parent = static_cast<Group *>(element);

src/add-ons/translators/rtf/RTF.cpp

188

parent->AddElement(element = new Command());

src/add-ons/translators/rtf/RTF.cpp

213

parent->AddElement(element = new Text());

src/add-ons/translators/rtf/RTF.cpp

217

if (element == NULL)

src/add-ons/translators/rtf/RTF.cpp

220

element->Parse(c, fStream, last);

src/add-ons/translators/rtf/RTF.cpp

286

Element *element;

src/add-ons/translators/rtf/RTF.cpp

287

while ((element = (Element *)fElements.RemoveItem((int32)0)) != NULL) {

src/add-ons/translators/rtf/RTF.cpp

288

delete element;

src/add-ons/translators/rtf/RTF.cpp

307

Group::AddElement(Element *element)

src/add-ons/translators/rtf/RTF.cpp

309

if (element == NULL)

src/add-ons/translators/rtf/RTF.cpp

312

if (fElements.AddItem(element)) {

src/add-ons/translators/rtf/RTF.cpp

313

element->SetParent(this);

src/add-ons/translators/rtf/RTF.cpp

341

Element *element;

src/add-ons/translators/rtf/RTF.cpp

343

for (uint32 i = 0; (element = ElementAt(i)) != NULL; i++) {

src/add-ons/translators/rtf/RTF.cpp

347

return element;

src/add-ons/translators/rtf/RTF.cpp

350

if (element->IsDefinitionDelimiter())

src/add-ons/translators/rtf/RTF.cpp

362

Element *element = FindDefinitionStart(index, &startIndex);

src/add-ons/translators/rtf/RTF.cpp

363

if (element == NULL)

src/add-ons/translators/rtf/RTF.cpp

366

for (uint32 i = startIndex; (element = ElementAt(i)) != NULL; i++) {

src/add-ons/translators/rtf/RTF.cpp

367

if (element->IsDefinitionDelimiter())

src/add-ons/translators/rtf/RTF.cpp

370

if (Command *command = dynamic_cast<Command *>(element)) {

src/add-ons/translators/rtf/RTF.cpp

383

Element *element;

src/add-ons/translators/rtf/RTF.cpp

384

for (uint32 i = 0; (element = ElementAt(i)) != NULL; i++) {

src/add-ons/translators/rtf/RTF.cpp

385

Group *group = dynamic_cast<Group *>(element);

src/add-ons/translators/rtf/RTF.cpp

759

Element *element;

src/add-ons/translators/rtf/RTF.cpp

761

if (!fStack.Pop(&element))

src/add-ons/translators/rtf/RTF.cpp

764

Group *group = dynamic_cast<Group *>(element);

src/add-ons/translators/rtf/RTF.cpp

777

return element;

src/add-ons/translators/rtf/RTF.cpp

797

Worker::Dispatch(Element *element)

src/add-ons/translators/rtf/RTF.cpp

799

if (RTF::Group *group = dynamic_cast<RTF::Group *>(element)) {

src/add-ons/translators/rtf/RTF.cpp

806

for (int32 i = 0; (element = group->ElementAt(i)) != NULL; i++)

src/add-ons/translators/rtf/RTF.cpp

807

Dispatch(element);

src/add-ons/translators/rtf/RTF.cpp

810

} else if (RTF::Command *command = dynamic_cast<RTF::Command *>(element)) {

src/add-ons/translators/rtf/RTF.cpp

812

} else if (RTF::Text *text = dynamic_cast<RTF::Text *>(element)) {

src/add-ons/translators/rtf/RTF.h

178

void Dispatch(RTF::Element *element);

src/add-ons/translators/rtf/RTF.h

68

status_t AddElement(RTF::Element *element);

src/apps/cortex/Persistence/ExportContext.cpp

251

if(!entry.element)

src/apps/cortex/Persistence/ExportContext.cpp

97

m_objectStack.back().element = m_elementStack.back().name.String();

src/apps/cortex/Persistence/ExportContext.h

248

object_entry() : element(0), object(0) {}

src/apps/cortex/Persistence/ExportContext.h

250

const char* element;

src/apps/cortex/Persistence/ImportContext.cpp

115

(element() ? element() : "(none)") << "')\n";

src/apps/cortex/Persistence/ImportContext.cpp

96

(element() ? element() : "(none)") << "')\n";

src/apps/cortex/Persistence/ImportContext.h

71

const char* element() const;

src/apps/cortex/Persistence/Importer.cpp

321

make_pair(m_context->element(), target));

src/apps/cortex/Persistence/Importer.cpp

395

if(m_context->m_objectStack.back().first == m_context->element()) {

src/apps/cortex/Persistence/Importer.cpp

468

if(m_context->m_objectStack.back().first == m_context->element()) {

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1216

if(!strcmp(context.element(), s_raw_audio_tag)) {

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1220

else if(!strcmp(context.element(), s_raw_video_tag)) {

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1224

else if(!strcmp(context.element(), s_multistream_tag)) {

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1228

else if(!strcmp(context.element(), s_encoded_audio_tag)) {

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1232

else if(!strcmp(context.element(), s_encoded_video_tag)) {

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1355

if(!strcmp(context.element(), s_video_display_info_tag))

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1359

else if(!strcmp(context.element(), s_multistream_flags_tag ))

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1363

else if(!strcmp(context.element(), s_multistream_vid_info_tag ))

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1367

else if(!strcmp(context.element(), s_multistream_avi_info_tag ))

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1380

if(!strcmp(context.element(), s_media_type_tag)) {

src/apps/cortex/Persistence/Wrappers/MediaFormatIO.cpp

1389

if(!strcmp(context.element(), s_media_type_tag)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

254

if(strcmp(context.element(), s_element) != 0) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

283

if(!_isValidMessageElement(context.element())) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

331

const char* element) const {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

333

if(!strcmp(element, _boolEl)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

334

if(!strcmp(element, _int8El)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

335

if(!strcmp(element, _int16El)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

336

if(!strcmp(element, _int32El)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

337

if(!strcmp(element, _int64El)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

338

if(!strcmp(element, _floatEl)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

339

if(!strcmp(element, _doubleEl)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

340

if(!strcmp(element, _stringEl)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

341

if(!strcmp(element, _pointEl)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

342

if(!strcmp(element, _rectEl)) return true;

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

349

const char* element,

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

356

if(!strcmp(element, _boolEl)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

367

if(!strcmp(element, _int8El)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

371

if(!strcmp(element, _int16El)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

375

if(!strcmp(element, _int32El)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

379

if(!strcmp(element, _int64El)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

384

if(!strcmp(element, _floatEl)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

388

if(!strcmp(element, _doubleEl)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

393

if(!strcmp(element, _stringEl)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

399

if(!strcmp(element, _pointEl)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.cpp

413

if(!strcmp(element, _rectEl)) {

src/apps/cortex/Persistence/Wrappers/MessageIO.h

158

const char* element) const;

src/apps/cortex/Persistence/Wrappers/MessageIO.h

162

const char* element,

src/apps/cortex/Persistence/XML.cpp

305

const char* element) {

src/apps/cortex/Persistence/XML.cpp

307

_NullMapping m(element);

src/apps/cortex/Persistence/XML.h

194

const char* element);

src/apps/cortex/Persistence/XMLElementMapping.h

56

const BString element;

src/apps/cortex/Persistence/XMLElementMapping.h

62

element(_element) {}

src/apps/cortex/Persistence/XMLElementMapping.h

75

const char* element) :

src/apps/cortex/Persistence/XMLElementMapping.h

76

XMLElementMapping(element) {}

src/apps/cortex/Persistence/XMLElementMapping.h

87

return a->element < b->element;

src/apps/cortex/RouteApp/ConnectionIO.cpp

417

if(!strcmp(context.element(), _LIVE_NODE_ELEMENT)) {

src/apps/cortex/RouteApp/ConnectionIO.cpp

441

else if(!strcmp(context.element(), _NAME_ELEMENT)) {

src/apps/cortex/RouteApp/DormantNodeIO.cpp

534

context.element() << "'\n";

src/apps/cortex/RouteApp/DormantNodeIO.cpp

539

if(!strcmp(context.element(), _NAME_ELEMENT))

src/apps/cortex/RouteApp/DormantNodeIO.cpp

541

else if(!strcmp(context.element(), _KIND_ELEMENT))

src/apps/cortex/RouteApp/DormantNodeIO.cpp

543

else if(!strcmp(context.element(), _FLAVOR_ID_ELEMENT))

src/apps/cortex/RouteApp/DormantNodeIO.cpp

545

else if(!strcmp(context.element(), _FLAG_ELEMENT))

src/apps/cortex/RouteApp/DormantNodeIO.cpp

547

else if(!strcmp(context.element(), _RUN_MODE_ELEMENT))

src/apps/cortex/RouteApp/DormantNodeIO.cpp

549

else if(!strcmp(context.element(), _RECORDING_DELAY_ELEMENT))

src/apps/cortex/RouteApp/DormantNodeIO.cpp

551

else if(!strcmp(context.element(), _CYCLE_ELEMENT))

src/apps/cortex/RouteApp/DormantNodeIO.cpp

553

else if(!strcmp(context.element(), _REF_ELEMENT))

src/apps/cortex/RouteApp/DormantNodeIO.cpp

558

context.element() << "'\n";

src/apps/cortex/RouteApp/LiveNodeIO.cpp

224

context.element() << "'\n";

src/apps/cortex/RouteApp/LiveNodeIO.cpp

229

if(!strcmp(context.element(), _NAME_ELEMENT))

src/apps/cortex/RouteApp/LiveNodeIO.cpp

231

else if(!strcmp(context.element(), _KIND_ELEMENT))

src/apps/cortex/RouteApp/LiveNodeIO.cpp

236

context.element() << "'\n";

src/apps/cortex/RouteApp/RouteAppNodeManager.cpp

603

if(!strcmp(context.element(), _DORMANT_NODE_ELEMENT)) {

src/apps/cortex/RouteApp/RouteAppNodeManager.cpp

628

else if(!strcmp(context.element(), _CONNECTION_ELEMENT)) {

src/apps/cortex/RouteApp/RouteAppNodeManager.cpp

647

else if(!strcmp(context.element(), _NODE_GROUP_ELEMENT)) {

src/apps/cortex/RouteApp/RouteAppNodeManager.cpp

660

context.element() << "'\n";

src/apps/cortex/RouteApp/route_app_io.cpp

80

const char* element,

src/apps/cortex/RouteApp/route_app_io.cpp

84

context.beginElement(element);

src/apps/cortex/RouteApp/route_app_io.h

90

const char* element,

src/apps/glteapot/util.h

207

inline void rem_del (contents* element)

src/apps/glteapot/util.h

211

if ((*pp)->car == element) {

src/apps/glteapot/util.h

260

inline contents *get(contents *element)

src/apps/glteapot/util.h

265

if (node->car == element)

src/apps/glteapot/util.h

66

inline int is_present(contents* element)

src/apps/glteapot/util.h

69

if (node->car == element)

src/apps/haikudepot/server/LocalPkgDataLoadProcess.cpp

630

for (int32 i = 0; const BSolverResultElement* element = solverResult.ElementAt(i); i++) {

src/apps/haikudepot/server/LocalPkgDataLoadProcess.cpp

631

BSolverPackage* package = element->Package();

src/apps/haikudepot/server/LocalPkgDataLoadProcess.cpp

633

if (element->Type() == BSolverResultElement::B_TYPE_INSTALL) {

src/apps/installer/BlockingQueue.h

110

BlockingQueue<Element>::Pop(Element** element, bigtime_t timeout)

src/apps/installer/BlockingQueue.h

122

*element = fElements[0];

src/apps/installer/BlockingQueue.h

130

BlockingQueue<Element>::Peek(Element** element)

src/apps/installer/BlockingQueue.h

138

*element = fElements[0];

src/apps/installer/BlockingQueue.h

145

BlockingQueue<Element>::Remove(Element* element)

src/apps/installer/BlockingQueue.h

157

if (fElements[i] == element) {

src/apps/installer/BlockingQueue.h

29

status_t Push(Element* element);

src/apps/installer/BlockingQueue.h

30

status_t Pop(Element** element,

src/apps/installer/BlockingQueue.h

32

status_t Peek(Element** element);

src/apps/installer/BlockingQueue.h

33

status_t Remove(Element* element);

src/apps/installer/BlockingQueue.h

91

BlockingQueue<Element>::Push(Element* element)

src/apps/installer/BlockingQueue.h

97

fElements.push_back(element);

src/apps/packageinstaller/PackageInfo.cpp

1027

} else if (element == P_SCRIPT) {

src/apps/packageinstaller/PackageInfo.cpp

1062

element = P_NONE;

src/apps/packageinstaller/PackageInfo.cpp

649

uint8 element = P_NONE;

src/apps/packageinstaller/PackageInfo.cpp

667

element = type; \

src/apps/packageinstaller/PackageInfo.cpp

691

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

707

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

716

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

725

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

734

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

743

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

752

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

761

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

770

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

779

if (element != P_FILE) {

src/apps/packageinstaller/PackageInfo.cpp

795

if (element == P_NONE) {

src/apps/packageinstaller/PackageInfo.cpp

804

if (element != P_FILE && element != P_LINK && element != P_SCRIPT) {

src/apps/packageinstaller/PackageInfo.cpp

813

if (element != P_FILE) {

src/apps/packageinstaller/PackageInfo.cpp

822

if (element != P_FILE && element != P_LINK) {

src/apps/packageinstaller/PackageInfo.cpp

831

if (element != P_DIRECTORY) {

src/apps/packageinstaller/PackageInfo.cpp

837

if (element != P_FILE) {

src/apps/packageinstaller/PackageInfo.cpp

853

if (element != P_LINK) {

src/apps/packageinstaller/PackageInfo.cpp

877

} else if (element == P_FILE) {

src/apps/packageinstaller/PackageInfo.cpp

919

} else if (element == P_DIRECTORY) {

src/apps/packageinstaller/PackageInfo.cpp

984

} else if (element == P_LINK) {

src/bin/pkgman/PackageManager.cpp

92

const BSolverProblemSolutionElement* element

src/bin/pkgman/PackageManager.cpp

94

printf(" - %s\n", element->ToString().String());

src/bin/pkgman/command_resolve_dependencies.cpp

100

for (int32 i = 0; const BSolverResultElement* element = result.ElementAt(i);

src/bin/pkgman/command_resolve_dependencies.cpp

102

BSolverPackage* package = element->Package();

src/bin/pkgman/command_resolve_dependencies.cpp

240

for (int32 i = 0; const BSolverResultElement* element = result.ElementAt(i);

src/bin/pkgman/command_resolve_dependencies.cpp

243

BSolverPackage* package = element->Package();

src/kits/interface/TwoDimensionalLayout.cpp

1285

for (int element = 0; element < elementCount; element++) {

src/kits/interface/TwoDimensionalLayout.cpp

1286

fLayout->GetColumnRowConstraints(orientation, element,

src/kits/interface/TwoDimensionalLayout.cpp

1288

layouter->SetWeight(element, constraints.weight);

src/kits/interface/TwoDimensionalLayout.cpp

1289

layouter->AddConstraints(element, 1, constraints.min,

src/kits/interface/layouter/CollapsingLayouter.cpp

134

CollapsingLayouter::AddConstraints(int32 element, int32 length, float min,

src/kits/interface/layouter/CollapsingLayouter.cpp

139

if (element < 0 || length <= 0 || element + length > fElementCount)

src/kits/interface/layouter/CollapsingLayouter.cpp

153

for (int32 i = element; i < element + length; i++) {

src/kits/interface/layouter/CollapsingLayouter.cpp

160

fElements[element].constraints.AddItem(constraint);

src/kits/interface/layouter/CollapsingLayouter.cpp

167

_AddConstraints(element, constraint);

src/kits/interface/layouter/CollapsingLayouter.cpp

173

CollapsingLayouter::SetWeight(int32 element, float weight)

src/kits/interface/layouter/CollapsingLayouter.cpp

175

if (element < 0 || element >= fElementCount)

src/kits/interface/layouter/CollapsingLayouter.cpp

178

ElementInfo& elementInfo = fElements[element];

src/kits/interface/layouter/CollapsingLayouter.cpp

287

ElementInfo& element = fElements[i];

src/kits/interface/layouter/CollapsingLayouter.cpp

288

if (!element.valid) {

src/kits/interface/layouter/CollapsingLayouter.cpp

290

element.position = -1;

src/kits/interface/layouter/CollapsingLayouter.cpp

293

element.position = i - shift;

src/kits/interface/layouter/CollapsingLayouter.cpp

306

ElementInfo& element = fElements[i];

src/kits/interface/layouter/CollapsingLayouter.cpp

307

for (int32 i = element.constraints.CountItems() - 1; i >= 0; i--)

src/kits/interface/layouter/CollapsingLayouter.cpp

308

_AddConstraints(element.position, element.constraints.ItemAt(i));

src/kits/interface/layouter/CollapsingLayouter.cpp

40

SetElementPosition(int32 element, int32 position)

src/kits/interface/layouter/CollapsingLayouter.cpp

42

fElements[element] = position;

src/kits/interface/layouter/CollapsingLayouter.cpp

46

ElementLocation(int32 element)

src/kits/interface/layouter/CollapsingLayouter.cpp

48

if (element < 0 || element >= fElementCount || fElements[element] < 0)

src/kits/interface/layouter/CollapsingLayouter.cpp

50

return fTarget->ElementLocation(fElements[element]);

src/kits/interface/layouter/CollapsingLayouter.cpp

54

ElementSize(int32 element)

src/kits/interface/layouter/CollapsingLayouter.cpp

56

if (element < 0 || element >= fElementCount || fElements[element] < 0)

src/kits/interface/layouter/CollapsingLayouter.cpp

58

return fTarget->ElementSize(fElements[element]);

src/kits/interface/layouter/CollapsingLayouter.cpp

62

ElementRangeSize(int32 element, int32 length)

src/kits/interface/layouter/CollapsingLayouter.cpp

64

if (element < 0 || element >= fElementCount || fElements[element] < 0)

src/kits/interface/layouter/CollapsingLayouter.cpp

66

return fTarget->ElementRangeSize(fElements[element], length);

src/kits/interface/layouter/CollapsingLayouter.h

27

virtual void AddConstraints(int32 element, int32 length,

src/kits/interface/layouter/CollapsingLayouter.h

29

virtual void SetWeight(int32 element, float weight);

src/kits/interface/layouter/ComplexLayouter.cpp

218

ComplexLayouter::AddConstraints(int32 element, int32 length,

src/kits/interface/layouter/ComplexLayouter.cpp

221

if (element < 0 || length <= 0 || element + length > fElementCount)

src/kits/interface/layouter/ComplexLayouter.cpp

225

this, element, length, (int32)_min, (int32)_max, (int32)_preferred);

src/kits/interface/layouter/ComplexLayouter.cpp

236

int32 end = element + length - 1;

src/kits/interface/layouter/ComplexLayouter.cpp

238

while (*slot != NULL && (*slot)->start > element)

src/kits/interface/layouter/ComplexLayouter.cpp

241

if (*slot != NULL && (*slot)->start == element) {

src/kits/interface/layouter/ComplexLayouter.cpp

246

Constraint* constraint = new(nothrow) Constraint(element, end, min,

src/kits/interface/layouter/ComplexLayouter.cpp

260

ComplexLayouter::SetWeight(int32 element, float weight)

src/kits/interface/layouter/ComplexLayouter.cpp

262

if (element < 0 || element >= fElementCount)

src/kits/interface/layouter/ComplexLayouter.cpp

265

fWeights[element] = max_c(weight, 0);

src/kits/interface/layouter/ComplexLayouter.cpp

60

virtual float ElementLocation(int32 element)

src/kits/interface/layouter/ComplexLayouter.cpp

62

if (element < 0 || element >= fCount)

src/kits/interface/layouter/ComplexLayouter.cpp

65

return fLocations[element];

src/kits/interface/layouter/ComplexLayouter.cpp

68

virtual float ElementSize(int32 element)

src/kits/interface/layouter/ComplexLayouter.cpp

70

if (element < 0 || element >= fCount)

src/kits/interface/layouter/ComplexLayouter.cpp

73

return fLocations[element + 1] - fLocations[element] - 1

src/kits/interface/layouter/ComplexLayouter.h

28

virtual void AddConstraints(int32 element, int32 length,

src/kits/interface/layouter/ComplexLayouter.h

30

virtual void SetWeight(int32 element, float weight);

src/kits/interface/layouter/Layouter.h

18

virtual float ElementLocation(int32 element) = 0;

src/kits/interface/layouter/Layouter.h

19

virtual float ElementSize(int32 element) = 0;

src/kits/interface/layouter/Layouter.h

30

virtual void AddConstraints(int32 element, int32 length,

src/kits/interface/layouter/Layouter.h

32

virtual void SetWeight(int32 element, float weight) = 0;

src/kits/interface/layouter/OneElementLayouter.cpp

20

virtual float ElementLocation(int32 element)

src/kits/interface/layouter/OneElementLayouter.cpp

25

virtual float ElementSize(int32 element)

src/kits/interface/layouter/OneElementLayouter.cpp

47

OneElementLayouter::AddConstraints(int32 element, int32 length,

src/kits/interface/layouter/OneElementLayouter.cpp

60

OneElementLayouter::SetWeight(int32 element, float weight)

src/kits/interface/layouter/OneElementLayouter.h

18

virtual void AddConstraints(int32 element, int32 length,

src/kits/interface/layouter/OneElementLayouter.h

20

virtual void SetWeight(int32 element, float weight);

src/kits/interface/layouter/SimpleLayouter.cpp

100

return fElements[element].location;

src/kits/interface/layouter/SimpleLayouter.cpp

103

virtual float ElementSize(int32 element)

src/kits/interface/layouter/SimpleLayouter.cpp

105

if (element < 0 || element >= fElementCount) {

src/kits/interface/layouter/SimpleLayouter.cpp

110

return fElements[element].size - 1;

src/kits/interface/layouter/SimpleLayouter.cpp

138

SimpleLayouter::AddConstraints(int32 element, int32 length,

src/kits/interface/layouter/SimpleLayouter.cpp

141

if (element < 0 || element >= fElementCount) {

src/kits/interface/layouter/SimpleLayouter.cpp

154

ElementInfo& info = fElements[element];

src/kits/interface/layouter/SimpleLayouter.cpp

164

SimpleLayouter::SetWeight(int32 element, float weight)

src/kits/interface/layouter/SimpleLayouter.cpp

166

if (element < 0 || element >= fElementCount) {

src/kits/interface/layouter/SimpleLayouter.cpp

171

fElements[element].weight = weight;

src/kits/interface/layouter/SimpleLayouter.cpp

93

virtual float ElementLocation(int32 element)

src/kits/interface/layouter/SimpleLayouter.cpp

95

if (element < 0 || element >= fElementCount) {

src/kits/interface/layouter/SimpleLayouter.h

25

virtual void AddConstraints(int32 element, int32 length,

src/kits/interface/layouter/SimpleLayouter.h

27

virtual void SetWeight(int32 element, float weight);

src/kits/locale/NumberFormat.cpp

360

BNumberFormat::GetSeparator(BNumberElement element)

src/kits/locale/NumberFormat.cpp

365

switch(element) {

src/kits/network/libnetservices/HttpForm.cpp

667

BHttpForm::_GetMultipartHeader(const BHttpFormData* element) const

src/kits/network/libnetservices/HttpForm.cpp

671

result << "Content-Disposition: form-data; name=\"" << element->Name()

src/kits/network/libnetservices/HttpForm.cpp

674

switch (element->Type()) {

src/kits/network/libnetservices/HttpForm.cpp

680

result << "; filename=\"" << element->File().Leaf() << '"';

src/kits/network/libnetservices/HttpForm.cpp

682

BNode fileNode(element->File().Path());

src/kits/network/libnetservices/HttpForm.cpp

697

if (element->IsFile()) {

src/kits/network/libnetservices/HttpForm.cpp

698

result << "; filename=\"" << element->Filename() << '"';

src/kits/network/libnetservices/HttpForm.cpp

700

if (element->MimeType().Length() > 0)

src/kits/network/libnetservices/HttpForm.cpp

701

result << "\r\nContent-Type: " << element->MimeType();

src/kits/network/libnetservices/HttpForm.cpp

743

BHttpFormData* element = fElement;

src/kits/network/libnetservices/HttpForm.cpp

745

return element;

src/kits/package/PackageInfoParser.cpp

614

BString element(token.text);

src/kits/package/PackageInfoParser.cpp

616

element.ToLower();

src/kits/package/PackageInfoParser.cpp

619

stringValidator->Validate(element, token.pos);

src/kits/package/PackageInfoParser.cpp

621

value->Add(element);

src/kits/package/manager/PackageManager.cpp

451

for (int32 i = 0; const BSolverResultElement* element = result.ElementAt(i);

src/kits/package/manager/PackageManager.cpp

453

BSolverPackage* package = element->Package();

src/kits/package/manager/PackageManager.cpp

455

switch (element->Type()) {

src/kits/package/solver/SolverProblemSolution.cpp

152

BSolverProblemSolution::AppendElement(const Element& element)

src/kits/package/solver/SolverProblemSolution.cpp

154

Element* newElement = new(std::nothrow) Element(element);

src/kits/package/solver/SolverResult.cpp

107

BSolverResult::AppendElement(const BSolverResultElement& element)

src/kits/package/solver/SolverResult.cpp

110

= new(std::nothrow) BSolverResultElement(element);

src/kits/support/StringList.cpp

123

BString element(StringAt(i));

src/kits/support/StringList.cpp

124

if (length == element.Length() && string.ICompare(element) == 0) {

src/kits/support/StringList.cpp

259

BString element(StringAt(i));

src/kits/support/StringList.cpp

260

if (length == element.Length() && string.ICompare(element) == 0)

src/kits/tracker/OpenWithWindow.cpp

218

SetDefaultAppForOneType(const BString& element, void* castToEntryRef)

src/kits/tracker/OpenWithWindow.cpp

223

BMimeType mime(element.String());

src/kits/tracker/OpenWithWindow.cpp

252

debugPath.Path(), appSignature, element->String(), strerror(result)));

src/libs/libsolv/ext/testcase.c

1449

int problem, solution, element;

src/libs/libsolv/ext/testcase.c

1468

element = 0;

src/libs/libsolv/ext/testcase.c

1469

while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &op)) != 0)

src/libs/libsolv/solv/problems.c

802

solver_next_solutionelement(Solver *solv, Id problem, Id solution, Id element, Id *p, Id *rp)

src/libs/libsolv/solv/problems.c

808

solidx += 1 + element * 2;

src/libs/libsolv/solv/problems.c

813

return element + 1;

src/libs/libsolv/solv/problems.c

851

Id p, rp, element = 0;

src/libs/libsolv/solv/problems.c

853

while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &rp)) != 0)

src/libs/libsolv/solv/problems.h

40

Id solver_next_solutionelement(struct _Solver *solv, Id problem, Id solution, Id element, Id *p, Id *rp);

src/libs/libsolv/solv/solverdebug.c

653

Id p, rp, element, how, what, select;

src/libs/libsolv/solv/solverdebug.c

656

element = 0;

src/libs/libsolv/solv/solverdebug.c

657

while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &rp)) != 0)

src/libs/zydis/Zycore/Vector.c

422

ZyanStatus ZyanVectorPushBack(ZyanVector* vector, const void* element)

src/libs/zydis/Zycore/Vector.c

424

if (!vector || !element)

src/libs/zydis/Zycore/Vector.c

439

ZYAN_MEMCPY(offset, element, vector->element_size);

src/libs/zydis/Zycore/Vector.c

446

ZyanStatus ZyanVectorInsert(ZyanVector* vector, ZyanUSize index, const void* element)

src/libs/zydis/Zycore/Vector.c

448

return ZyanVectorInsertRange(vector, index, element, 1);

src/libs/zydis/Zycore/Vector.c

484

ZyanStatus ZyanVectorEmplace(ZyanVector* vector, void** element, ZyanMemberFunction constructor)

src/libs/zydis/Zycore/Vector.c

491

return ZyanVectorEmplaceEx(vector, vector->size, element, constructor);

src/libs/zydis/Zycore/Vector.c

494

ZyanStatus ZyanVectorEmplaceEx(ZyanVector* vector, ZyanUSize index, void** element,

src/libs/zydis/Zycore/Vector.c

520

*element = ZYCORE_VECTOR_OFFSET(vector, index);

src/libs/zydis/Zycore/Vector.c

523

ZYAN_CHECK(constructor(*element));

src/libs/zydis/Zycore/Vector.c

642

ZyanStatus ZyanVectorFind(const ZyanVector* vector, const void* element, ZyanISize* found_index,

src/libs/zydis/Zycore/Vector.c

650

return ZyanVectorFindEx(vector, element, found_index, comparison, 0, vector->size);

src/libs/zydis/Zycore/Vector.c

653

ZyanStatus ZyanVectorFindEx(const ZyanVector* vector, const void* element, ZyanISize* found_index,

src/libs/zydis/Zycore/Vector.c

676

if (comparison(ZYCORE_VECTOR_OFFSET(vector, i), element))

src/libs/zydis/Zycore/Vector.c

687

ZyanStatus ZyanVectorBinarySearch(const ZyanVector* vector, const void* element,

src/libs/zydis/Zycore/Vector.c

695

return ZyanVectorBinarySearchEx(vector, element, found_index, comparison, 0, vector->size);

src/libs/zydis/Zycore/Vector.c

698

ZyanStatus ZyanVectorBinarySearchEx(const ZyanVector* vector, const void* element,

src/libs/zydis/Zycore/Vector.c

725

const ZyanI32 cmp = comparison(ZYCORE_VECTOR_OFFSET(vector, mid), element);

src/libs/zydis/Zydis/SharedData.c

128

void ZydisGetElementInfo(ZydisInternalElementType element, ZydisElementType* type,

src/libs/zydis/Zydis/SharedData.c

168

ZYAN_ASSERT((ZyanUSize)element < ZYAN_ARRAY_LENGTH(lookup));

src/libs/zydis/Zydis/SharedData.c

170

*type = lookup[element].type;

src/libs/zydis/Zydis/SharedData.c

171

*size = lookup[element].size;

src/preferences/screen/ScreenMode.cpp

385

const pnp_id* element = std::find(kPNPIDs, lastElement, key);

src/preferences/screen/ScreenMode.cpp

386

if (element == lastElement) {

src/preferences/screen/ScreenMode.cpp

391

return element->manufacturer;

src/servers/app/drawing/AlphaMaskCache.cpp

117

ShapeMaskElement element(&shape, NULL, previousMask, inverse);

src/servers/app/drawing/AlphaMaskCache.cpp

118

ShapeMaskSet::iterator it = fShapeMasks.find(element);

src/servers/app/drawing/AlphaMaskCache.cpp

95

ShapeMaskElement element(mask->fShape, mask, mask->fPreviousMask.Get(),

src/servers/app/drawing/AlphaMaskCache.cpp

97

fShapeMasks.insert(element);

src/servers/package/ProblemWindow.cpp

264

const BSolverProblemSolutionElement* element = solution->ElementAt(l);

src/servers/package/ProblemWindow.cpp

266

BString().SetToFormat("- %s", _SolutionElementText(element).String()));

src/servers/package/ProblemWindow.cpp

283

const BSolverProblemSolutionElement* element) const

src/servers/package/ProblemWindow.cpp

287

BSolverPackage* package = element->SourcePackage();

src/servers/package/ProblemWindow.cpp

288

if (element->Type() == BSolverProblemSolutionElement::B_ALLOW_DEINSTALLATION

src/servers/package/ProblemWindow.cpp

296

return element->ToString();

src/servers/package/ProblemWindow.h

62

element) const;

src/servers/package/Volume.cpp

508

const BSolverProblemSolutionElement* element

src/servers/package/Volume.cpp

510

INFORM(" - %s\n", element->ToString().String());

src/system/kernel/TeamThreadTables.h

137

Element* element = static_cast<Element*>(nextEntry);

src/system/kernel/TeamThreadTables.h

140

return element;

src/system/kernel/TeamThreadTables.h

78

void Insert(Element* element)

src/system/kernel/TeamThreadTables.h

80

element->serial_number = fNextSerialNumber++;

src/system/kernel/TeamThreadTables.h

81

fTable.InsertUnchecked(element);

src/system/kernel/TeamThreadTables.h

82

fList.Add(element);

src/system/kernel/TeamThreadTables.h

85

void Remove(Element* element)

src/system/kernel/TeamThreadTables.h

87

fTable.RemoveUnchecked(element);

src/system/kernel/TeamThreadTables.h

88

fList.Remove(element);

src/system/kernel/TeamThreadTables.h

93

Element* element = fTable.Lookup(id);

src/system/kernel/TeamThreadTables.h

94

return element != NULL && (!visibleOnly || element->visible)

src/system/kernel/TeamThreadTables.h

95

? element : NULL;

src/system/kernel/arch/arm/paging/32bit/ARMPagingStructures32Bit.cpp

26

inline Link* operator()(ARMPagingStructures32Bit* element) const

src/system/kernel/arch/arm/paging/32bit/ARMPagingStructures32Bit.cpp

28

return (Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/arm/paging/32bit/ARMPagingStructures32Bit.cpp

32

const ARMPagingStructures32Bit* element) const

src/system/kernel/arch/arm/paging/32bit/ARMPagingStructures32Bit.cpp

34

return (const Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/m68k/paging/040/M68KPagingStructures040.cpp

26

inline Link* operator()(M68KPagingStructures040* element) const

src/system/kernel/arch/m68k/paging/040/M68KPagingStructures040.cpp

28

return (Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/m68k/paging/040/M68KPagingStructures040.cpp

32

const M68KPagingStructures040* element) const

src/system/kernel/arch/m68k/paging/040/M68KPagingStructures040.cpp

34

return (const Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/ppc/paging/460/PPCPagingStructures460.cpp

26

inline Link* operator()(PPCPagingStructures460* element) const

src/system/kernel/arch/ppc/paging/460/PPCPagingStructures460.cpp

28

return (Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/ppc/paging/460/PPCPagingStructures460.cpp

32

const PPCPagingStructures460* element) const

src/system/kernel/arch/ppc/paging/460/PPCPagingStructures460.cpp

34

return (const Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/ppc/paging/classic/PPCPagingStructuresClassic.cpp

26

inline Link* operator()(PPCPagingStructuresClassic* element) const

src/system/kernel/arch/ppc/paging/classic/PPCPagingStructuresClassic.cpp

28

return (Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/ppc/paging/classic/PPCPagingStructuresClassic.cpp

32

const PPCPagingStructuresClassic* element) const

src/system/kernel/arch/ppc/paging/classic/PPCPagingStructuresClassic.cpp

34

return (const Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/x86/paging/32bit/X86PagingStructures32Bit.cpp

26

inline Link* operator()(X86PagingStructures32Bit* element) const

src/system/kernel/arch/x86/paging/32bit/X86PagingStructures32Bit.cpp

28

return (Link*)element->GetSinglyLinkedListLink();

src/system/kernel/arch/x86/paging/32bit/X86PagingStructures32Bit.cpp

32

const X86PagingStructures32Bit* element) const

src/system/kernel/arch/x86/paging/32bit/X86PagingStructures32Bit.cpp

34

return (const Link*)element->GetSinglyLinkedListLink();

src/system/kernel/debug/heap.cpp

983

addr_t *element = page->free_list;

src/system/kernel/debug/heap.cpp

985

while (element) {

src/system/kernel/debug/heap.cpp

986

if ((addr_t)element < pageBase

src/system/kernel/debug/heap.cpp

987

|| (addr_t)element >= pageBase + heap->page_size)

src/system/kernel/debug/heap.cpp

990

if (((addr_t)element - pageBase) % bin->element_size != 0)

src/system/kernel/debug/heap.cpp

993

element = (addr_t *)*element;

src/system/kernel/messaging/KMessage.cpp

415

const void* element = field.ElementAt(0);

src/system/kernel/messaging/KMessage.cpp

416

memcpy(const_cast<void*>(element), data, numBytes);

src/system/kernel/scheduler/RunQueue.h

138

RunQueueStandardGetLink<Element>::operator()(Element* element) const

src/system/kernel/scheduler/RunQueue.h

140

return element->GetRunQueueLink();

src/system/kernel/scheduler/RunQueue.h

146

RunQueueMemberGetLink<Element, LinkMember>::operator()(Element* element) const

src/system/kernel/scheduler/RunQueue.h

148

return &(element->*LinkMember);

src/system/kernel/scheduler/RunQueue.h

267

Element* element = fHeads[priority];

src/system/kernel/scheduler/RunQueue.h

269

ASSERT(sGetLink(element)->fPriority == priority);

src/system/kernel/scheduler/RunQueue.h

271

ASSERT(sGetLink(element)->fPrevious == NULL);

src/system/kernel/scheduler/RunQueue.h

273

return element;

src/system/kernel/scheduler/RunQueue.h

279

RUN_QUEUE_CLASS_NAME::PushFront(Element* element,

src/system/kernel/scheduler/RunQueue.h

286

RunQueueLink<Element>* elementLink = sGetLink(element);

src/system/kernel/scheduler/RunQueue.h

297

sGetLink(fHeads[priority])->fPrevious = element;

src/system/kernel/scheduler/RunQueue.h

299

fTails[priority] = element;

src/system/kernel/scheduler/RunQueue.h

302

fHeads[priority] = element;

src/system/kernel/scheduler/RunQueue.h

308

RUN_QUEUE_CLASS_NAME::PushBack(Element* element,

src/system/kernel/scheduler/RunQueue.h

315

RunQueueLink<Element>* elementLink = sGetLink(element);

src/system/kernel/scheduler/RunQueue.h

326

sGetLink(fTails[priority])->fNext = element;

src/system/kernel/scheduler/RunQueue.h

328

fHeads[priority] = element;

src/system/kernel/scheduler/RunQueue.h

331

fTails[priority] = element;

src/system/kernel/scheduler/RunQueue.h

337

RUN_QUEUE_CLASS_NAME::Remove(Element* element)

src/system/kernel/scheduler/RunQueue.h

341

RunQueueLink<Element>* elementLink = sGetLink(element);

src/system/kernel/scheduler/RunQueue.h

344

ASSERT(elementLink->fPrevious != NULL || fHeads[priority] == element);

src/system/kernel/scheduler/RunQueue.h

345

ASSERT(elementLink->fNext != NULL || fTails[priority] == element);

src/system/kernel/scheduler/RunQueue.h

41

inline Link* operator()(Element* element) const;

src/system/kernel/scheduler/RunQueue.h

50

inline Link* operator()(Element* element) const;

src/system/kernel/scheduler/RunQueue.h

90

inline void PushFront(Element* element, unsigned int priority);

src/system/kernel/scheduler/RunQueue.h

93

inline void Remove(Element* element);

src/system/kernel/scheduler/scheduler_cpu.h

548

CoreEntry* element = fIdleCores.Last();

src/system/kernel/scheduler/scheduler_cpu.h

549

for (int32 i = 0; element != NULL && i < index; i++)

src/system/kernel/scheduler/scheduler_cpu.h

550

element = fIdleCores.GetPrevious(element);

src/system/kernel/scheduler/scheduler_cpu.h

552

return element;

src/system/libroot/os/parsedate.cpp

1004

if (element->value > 12)

src/system/libroot/os/parsedate.cpp

1011

if (element->value > 24)

src/system/libroot/os/parsedate.cpp

1017

if (element->value > 59)

src/system/libroot/os/parsedate.cpp

1023

if (element->value > 59)

src/system/libroot/os/parsedate.cpp

1036

if ((element->modifier != MODIFY_MINUS

src/system/libroot/os/parsedate.cpp

1037

&& element->modifier != MODIFY_PLUS)

src/system/libroot/os/parsedate.cpp

1038

|| element->value > 2399)

src/system/libroot/os/parsedate.cpp

1045

if ((element->flags & FLAG_HAS_DASH) != 0) {

src/system/libroot/os/parsedate.cpp

1046

element--; // consider this element again

src/system/libroot/os/parsedate.cpp

1059

if (element->type != TYPE_WEEKDAY)

src/system/libroot/os/parsedate.cpp

1064

if (element->type != TYPE_MONTH)

src/system/libroot/os/parsedate.cpp

1070

if (element->type != TYPE_MERIDIAN)

src/system/libroot/os/parsedate.cpp

1075

if (element->type != TYPE_TIME_ZONE)

src/system/libroot/os/parsedate.cpp

1079

if (element->type != TYPE_UNIT)

src/system/libroot/os/parsedate.cpp

1095

element++;

src/system/libroot/os/parsedate.cpp

703

computeRelativeUnit(parsed_element& element, struct tm& tm, int* _flags)

src/system/libroot/os/parsedate.cpp

707

switch (element.unit) {

src/system/libroot/os/parsedate.cpp

721

if ((element.flags & FLAG_RELATIVE) != 0) {

src/system/libroot/os/parsedate.cpp

722

bigtime_t value = element.value;

src/system/libroot/os/parsedate.cpp

723

if (element.modifier == MODIFY_MINUS)

src/system/libroot/os/parsedate.cpp

724

value = -element.value;

src/system/libroot/os/parsedate.cpp

726

if (element.unit == UNIT_MONTH)

src/system/libroot/os/parsedate.cpp

728

else if (element.unit == UNIT_DAY)

src/system/libroot/os/parsedate.cpp

730

else if (element.unit == UNIT_SECOND) {

src/system/libroot/os/parsedate.cpp

733

} else if (element.unit == UNIT_YEAR)

src/system/libroot/os/parsedate.cpp

735

} else if (element.base_type == TYPE_WEEKDAY) {

src/system/libroot/os/parsedate.cpp

736

tm.tm_mday += element.value - tm.tm_wday;

src/system/libroot/os/parsedate.cpp

738

if (element.modifier == MODIFY_NEXT)

src/system/libroot/os/parsedate.cpp

740

else if (element.modifier == MODIFY_LAST)

src/system/libroot/os/parsedate.cpp

742

} else if (element.base_type == TYPE_MONTH) {

src/system/libroot/os/parsedate.cpp

743

tm.tm_mon = element.value - 1;

src/system/libroot/os/parsedate.cpp

745

if (element.modifier == MODIFY_NEXT)

src/system/libroot/os/parsedate.cpp

747

else if (element.modifier == MODIFY_LAST)

src/system/libroot/os/parsedate.cpp

763

parsed_element* element = elements;

src/system/libroot/os/parsedate.cpp

784

while (element->type != TYPE_END) {

src/system/libroot/os/parsedate.cpp

800

switch (element->value_type) {

src/system/libroot/os/parsedate.cpp

808

tm.tm_mday = element->value;

src/system/libroot/os/parsedate.cpp

811

tm.tm_mon = element->value - 1;

src/system/libroot/os/parsedate.cpp

815

tm.tm_hour = element->value;

src/system/libroot/os/parsedate.cpp

818

tm.tm_min = element->value;

src/system/libroot/os/parsedate.cpp

821

tm.tm_sec = element->value;

src/system/libroot/os/parsedate.cpp

834

tm.tm_year = element->value;

src/system/libroot/os/parsedate.cpp

854

= (element->value - element->value % 100) * 36

src/system/libroot/os/parsedate.cpp

855

+ (element->value % 100) * 60;

src/system/libroot/os/parsedate.cpp

856

if (element->modifier == MODIFY_MINUS)

src/system/libroot/os/parsedate.cpp

862

computeRelativeUnit(*element, tm, _flags);

src/system/libroot/os/parsedate.cpp

877

computeRelativeUnit(*element, tm, _flags);

src/system/libroot/os/parsedate.cpp

881

tm.tm_mon = element->value - 1;

src/system/libroot/os/parsedate.cpp

884

tm.tm_sec += element->value;

src/system/libroot/os/parsedate.cpp

888

tm.tm_sec -= element->value + timezone;

src/system/libroot/os/parsedate.cpp

891

if ((element->flags & FLAG_NOW) != 0) {

src/system/libroot/os/parsedate.cpp

897

computeRelativeUnit(*element, tm, _flags);

src/system/libroot/os/parsedate.cpp

909

element++;

src/system/libroot/os/parsedate.cpp

953

parsed_element* element = elements;

src/system/libroot/os/parsedate.cpp

954

while (element->type != TYPE_END) {

src/system/libroot/os/parsedate.cpp

965

switch (element->value_type) {

src/system/libroot/os/parsedate.cpp

969

switch (element->type) {

src/system/libroot/os/parsedate.cpp

993

if (element->type == TYPE_UNIT && format[0] != 'T')

src/system/libroot/os/parsedate.cpp

998

if (element->value > 31)

src/system/libroot/posix/malloc/debug/heap.cpp

617

addr_t *element = page->free_list;

src/system/libroot/posix/malloc/debug/heap.cpp

619

while (element) {

src/system/libroot/posix/malloc/debug/heap.cpp

620

if ((addr_t)element < pageBase

src/system/libroot/posix/malloc/debug/heap.cpp

621

|| (addr_t)element >= pageBase + heap->page_size)

src/system/libroot/posix/malloc/debug/heap.cpp

622

panic("free list entry out of page range %p\n", element);

src/system/libroot/posix/malloc/debug/heap.cpp

624

if (((addr_t)element - pageBase) % bin->element_size != 0)

src/system/libroot/posix/malloc/debug/heap.cpp

627

element = (addr_t *)*element;

src/system/libroot/posix/musl/search/insque.c

10

struct node *e = element;

src/system/libroot/posix/musl/search/insque.c

24

void remque(void *element)

src/system/libroot/posix/musl/search/insque.c

26

struct node *e = element;

src/system/libroot/posix/musl/search/insque.c

8

void insque(void *element, void *pred)

src/tests/system/kernel/util/SinglyLinkedListTest.cpp

95

Link* element = iterator.Next();

src/tests/system/kernel/util/SinglyLinkedListTest.cpp

96

CPPUNIT_ASSERT(*element == fValues[preIndex]);

src/tools/cppunit/cppunit/XmlOutputter.cpp

73

string element = "<";

src/tools/cppunit/cppunit/XmlOutputter.cpp

74

element += m_name;

src/tools/cppunit/cppunit/XmlOutputter.cpp

75

element += " ";

src/tools/cppunit/cppunit/XmlOutputter.cpp

76

element += attributesAsString();

src/tools/cppunit/cppunit/XmlOutputter.cpp

77

element += " >\n";

src/tools/cppunit/cppunit/XmlOutputter.cpp

83

element += node->toString();

src/tools/cppunit/cppunit/XmlOutputter.cpp

86

element += m_content;

src/tools/cppunit/cppunit/XmlOutputter.cpp

88

element += "</";

src/tools/cppunit/cppunit/XmlOutputter.cpp

89

element += m_name;

src/tools/cppunit/cppunit/XmlOutputter.cpp

90

element += ">\n";

src/tools/cppunit/cppunit/XmlOutputter.cpp

92

return element;

src/tools/fs_shell/OpenHashTable.h

278

ValueType* element = fTable[i];

src/tools/fs_shell/OpenHashTable.h

279

if (element != NULL) {

src/tools/fs_shell/OpenHashTable.h

281

*nextPointer = element;

src/tools/fs_shell/OpenHashTable.h

285

while (element != NULL) {

src/tools/fs_shell/OpenHashTable.h

286

nextPointer = &_Link(element);

src/tools/fs_shell/OpenHashTable.h

287

element = *nextPointer;

src/tools/fs_shell/hash.cpp

111

hash_insert(struct hash_table *table, void *element)

src/tools/fs_shell/hash.cpp

115

ASSERT(table != NULL && element != NULL);

src/tools/fs_shell/hash.cpp

116

TRACE(("hash_insert: table 0x%x, element 0x%x\n", table, element));

src/tools/fs_shell/hash.cpp

118

hash = table->hash_func(element, NULL, table->table_size);

src/tools/fs_shell/hash.cpp

119

PUT_IN_NEXT(table, element, table->table[hash]);

src/tools/fs_shell/hash.cpp

120

table->table[hash] = (struct hash_element *)element;

src/tools/fs_shell/hash.cpp

133

void *element, *lastElement = NULL;

src/tools/fs_shell/hash.cpp

135

for (element = table->table[hash]; element != NULL;

src/tools/fs_shell/hash.cpp

136

lastElement = element, element = NEXT(table, element)) {

src/tools/fs_shell/hash.cpp

137

if (element == _element) {

src/tools/fs_shell/hash.cpp

140

PUT_IN_NEXT(table, lastElement, NEXT(table, element));

src/tools/fs_shell/hash.cpp

142

table->table[hash] = (struct hash_element *)NEXT(table, element);

src/tools/fs_shell/hash.cpp

157

void *element;

src/tools/fs_shell/hash.cpp

162

for (element = table->table[index]; index < table->table_size; index++) {

src/tools/fs_shell/hash.cpp

165

while (element != NULL) {

src/tools/fs_shell/hash.cpp

166

if (element == iterator->current) {

src/tools/fs_shell/hash.cpp

171

PUT_IN_NEXT(table, lastElement, NEXT(table, element));

src/tools/fs_shell/hash.cpp

174

element);

src/tools/fs_shell/hash.cpp

181

element = NEXT(table, element);

src/tools/fs_shell/hash.cpp

193

void *element = table->table[index];

src/tools/fs_shell/hash.cpp

194

if (element != NULL) {

src/tools/fs_shell/hash.cpp

196

table->table[index] = (struct hash_element *)NEXT(table, element);

src/tools/fs_shell/hash.cpp

200

return element;

src/tools/fs_shell/hash.cpp

212

void *element;

src/tools/fs_shell/hash.cpp

214

for (element = table->table[hash]; element != NULL; element = NEXT(table, element)) {

src/tools/fs_shell/hash.cpp

215

if (element == searchedElement)

src/tools/fs_shell/hash.cpp

216

return element;

src/tools/fs_shell/hash.cpp

227

void *element;

src/tools/fs_shell/hash.cpp

229

for (element = table->table[hash]; element != NULL; element = NEXT(table, element)) {

src/tools/fs_shell/hash.cpp

230

if (table->compare_func(element, key) == 0)

src/tools/fs_shell/hash.cpp

231

return element;

src/tools/fs_shell/hash.cpp

51

next_element(hash_table *table, void *element)

src/tools/fs_shell/hash.cpp

54

return (void *)(*(unsigned long *)NEXT_ADDR(table, element));

src/tools/fs_shell/hash.h

22

int compare_func(void *element, const void *key),

src/tools/fs_shell/hash.h

23

uint32_t hash_func(void *element, const void *key, uint32_t range));

src/tools/get_package_dependencies/get_package_dependencies.cpp

136

const BSolverProblemSolutionElement* element

src/tools/get_package_dependencies/get_package_dependencies.cpp

138

fprintf(stderr, " - %s\n", element->ToString().String());

src/tools/get_package_dependencies/get_package_dependencies.cpp

153

for (int32 i = 0; const BSolverResultElement* element = result.ElementAt(i);

src/tools/get_package_dependencies/get_package_dependencies.cpp

155

BSolverPackage* package = element->Package();

src/tools/get_package_dependencies/get_package_dependencies.cpp

157

switch (element->Type()) {