Lines Matching refs:node

35     CommandNode *node = (CommandNode *)calloc(1, size);

36     PARAM_CHECK(node != NULL, return -1, "Failed to alloc memory for command");

37     node->cmdKeyIndex = cmdKeyIndex;

38     node->next = NULL;

39     node->content[0] = '\0';

41         int ret = memcpy_s(node->content, size, content, strlen(content));

42         node->content[strlen(content)] = '\0';

43         PARAM_CHECK(ret == EOK, free(node);

46     node->cfgContext.type = INIT_CONTEXT_MAIN;

48         node->cfgContext.type = cfgContext->type;

51         trigger->firstCmd = node;

52         trigger->lastCmd = node;

54         PARAM_CHECK(trigger->lastCmd != NULL, free(node);

56         trigger->lastCmd->next = node;

57         trigger->lastCmd = node;

71 static int CopyCondition(TriggerNode *node, const char *condition)

80     node->condition = strdup(cond);

81     PARAM_CHECK(node->condition != NULL, return -1, "Failed to dup conditition");

88     TriggerNode *node = (TriggerNode *)calloc(1, dataSize);

89     PARAM_CHECK(node != NULL, return NULL, "Failed to alloc memory for trigger");

90     node->condition = NULL;

91     int ret = CopyCondition(node, condition);

92     PARAM_CHECK(ret == 0, free(node);

94     node->type = type;

95     node->flags = 0;

96     OH_ListInit(&node->node);

97     OH_ListAddTail(&triggerHead->triggerList, &node->node);

99     return node;

104     JobNode *node = (JobNode *)trigger;

105     int ret = strcpy_s(node->name, strlen(extInfo->info.name) + 1, extInfo->info.name);

107     node->firstCmd = NULL;

108     node->lastCmd = NULL;

109     ret = OH_HashMapAdd(GetTriggerWorkSpace()->hashMap, &node->hashNode);

110     PARAM_CHECK(ret == 0, return -1, "Failed to add hash node");

124     TriggerNode *node = (TriggerNode *)AddTriggerNode_(triggerHead, extInfo->type, condition, triggerNodeLen);

125     PARAM_CHECK(node != NULL, return NULL, "Failed to alloc jobnode");

126     int ret = extInfo->addNode(node, extInfo);

127     PARAM_CHECK(ret == 0, FreeTrigger(workSpace, node);

128         return NULL, "Failed to add hash node");

130         TRIGGER_SET_FLAG(node, TRIGGER_FLAGS_ONCE);

132             TRIGGER_SET_FLAG(node, TRIGGER_FLAGS_SUBTRIGGER);

135     return node;

158     OH_ListRemove(&trigger->node);

192     TriggerNode *node = AddTriggerNode_(triggerHead, extInfo->type, condition, size);

193     PARAM_CHECK(node != NULL, return NULL, "Failed to alloc memory for trigger");

194     int ret = extInfo->addNode(node, extInfo);

195     PARAM_CHECK(ret == 0, FreeTrigger(workSpace, node);

196         return NULL, "Failed to add node");

198         TRIGGER_SET_FLAG(node, TRIGGER_FLAGS_ONCE);

200     return node;

208     OH_ListRemove(&trigger->node);

210         WaitNode *node = (WaitNode *)trigger;

211         OH_ListRemove(&node->item);

213         WatchNode *node = (WatchNode *)trigger;

214         OH_ListRemove(&node->item);

228     ListNode *node = NULL;

230         node = curr->node.next;

232         node = triggerHead->triggerList.next;

234     if (node != &triggerHead->triggerList) {

235         return ListEntry(node, TriggerNode, node);

249     const JobNode *node = (const JobNode *)trigger;

250     return node->name;

257     const JobNode *node = (const JobNode *)trigger;

258     return node->name;

294     HashNode *node = OH_HashMapGet(workSpace->hashMap, triggerName);

295     if (node == NULL) {

298     JobNode *trigger = HASHMAP_ENTRY(node, JobNode, hashNode);

486     const JobNode *node = (const JobNode *)trigger;

488     PARAM_DUMP("trigger      name: %s \n", node->name);

489     PARAM_DUMP("trigger condition: %s \n", node->condition);

492     CommandNode *cmd = GetNextCmdNode(node, NULL);

497         cmd = GetNextCmdNode(node, cmd);

505     const WatchNode *node = (const WatchNode *)trigger;

508     PARAM_DUMP("trigger   watchId: %d \n", node->watchId);

514     const WaitNode *node = (const WaitNode *)trigger;

518     PARAM_DUMP("trigger    waitId: %d \n", node->waitId);

519     PARAM_DUMP("trigger   timeout: %d \n", node->timeout);

560             PARAM_DUMP("    queue node trigger name: %s \n", GetTriggerName(trigger));

569         WaitNode *node = (WaitNode *)trigger;

570         return node->waitId - *(uint32_t *)data;

572         WatchNode *node = (WatchNode *)trigger;

573         return node->watchId - *(uint32_t *)data;

609 static int JobNodeGetNodeHasCode(const HashNode *node)

611     JobNode *jobNode = HASHMAP_ENTRY(node, JobNode, hashNode);

631 static void JobNodeFree(const HashNode *node, void *context)

633     JobNode *jobNode = HASHMAP_ENTRY(node, JobNode, hashNode);

708     ListNode *node = watcher->triggerHead.next;

709     while (node != &watcher->triggerHead) {

712             trigger = (TriggerNode *)ListEntry(node, WaitNode, item);

714             trigger = (TriggerNode *)ListEntry(node, WatchNode, item);

721         ListNode *next = node->next;

723         node = next;

732     WaitNode *node = (WaitNode *)head->nextTrigger(head, NULL);

733     while (node != NULL) {

734         WaitNode *next = (WaitNode *)head->nextTrigger(head, (TriggerNode *)node);

735         if (node->timeout > 0) {

736             node->timeout--;

738             head->executeTrigger((TriggerNode*)node, NULL, 0);

739             FreeTrigger(GetTriggerWorkSpace(), (TriggerNode *)node);

742         node = next;