Queue/queue.c at master · codebyte/Queue · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include<malloc.h>
#include<pthread.h>
#include<string.h>
#include"queue.h"
#include"common.h"


voidqInit(queueObj_t*qObj)
{
qObj->qHead=qObj->qTail=NULL;
pthread_mutex_init(&qObj->qMutex, NULL);
}


voidqInsert(queueObj_t*qObj, void*data)
{
if (!qObj|| !data) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=allocate_node(data);

if (!qObj->qHead) {
qObj->qHead=qObj->qTail=node;
++qObj->qCount;

	} else {

qObj->qTail->next=node;
node->prev=qObj->qTail;
qObj->qTail=node;
++qObj->qCount;
	}

Q_UNLOCK(&qObj->qMutex);
}

voidqRemove(queueObj_t*qObj, void*data, size_tnSize)
{
Q_LOCK(&qObj->qMutex);

NODE*node=qObj->qHead;

if (!qObj->qHead|| !qObj->qTail) {
 goto end;
	}


if(qObj->qHead==qObj->qTail) {

node=qObj->qHead;
qObj->qHead=qObj->qTail=NULL;
--qObj->qCount;

	} else {

qObj->qHead=qObj->qHead->next;
node->next=NULL;
qObj->qHead->prev=NULL;
--qObj->qCount;
	}

if(data) {
memcpy(data, node->data, nSize);
	}


end:
FREE(node);
Q_UNLOCK(&qObj->qMutex);
}

NODE*allocate_node(void*data)
{
NODE*node= (NODE*)calloc(1,
sizeof (NODE));
node->next=node->prev=0;
node->data=data;

return (node);
}


voidqDestroy(queueObj_t*qObj) {

if(!qObj) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=NULL;

while(qObj->qHead!=NULL) {

node=qObj->qHead;
qObj->qHead=qObj->qHead->next;

FREE(node);
	}

qObj->qTail=qObj->qHead=0;

Q_UNLOCK(&qObj->qMutex);
pthread_mutex_destroy(&qObj->qMutex);
}


voidprintQ(queueObj_t*qObj, workCBfunc)
{

NODE*node=qObj->qHead;

if(!node) {
return;
	}

while(node!=NULL) {
func(node->data);
node=node->next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include<malloc.h>
#include<pthread.h>
#include<string.h>
#include"queue.h"
#include"common.h"


voidqInit(queueObj_t*qObj)
{
qObj->qHead=qObj->qTail=NULL;
pthread_mutex_init(&qObj->qMutex, NULL);
}


voidqInsert(queueObj_t*qObj, void*data)
{
if (!qObj|| !data) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=allocate_node(data);

if (!qObj->qHead) {
qObj->qHead=qObj->qTail=node;
++qObj->qCount;

	} else {

qObj->qTail->next=node;
node->prev=qObj->qTail;
qObj->qTail=node;
++qObj->qCount;
	}

Q_UNLOCK(&qObj->qMutex);
}

voidqRemove(queueObj_t*qObj, void*data, size_tnSize)
{
Q_LOCK(&qObj->qMutex);

NODE*node=qObj->qHead;

if (!qObj->qHead|| !qObj->qTail) {
 goto end;
	}


if(qObj->qHead==qObj->qTail) {

node=qObj->qHead;
qObj->qHead=qObj->qTail=NULL;
--qObj->qCount;

	} else {

qObj->qHead=qObj->qHead->next;
node->next=NULL;
qObj->qHead->prev=NULL;
--qObj->qCount;
	}

if(data) {
memcpy(data, node->data, nSize);
	}


end:
FREE(node);
Q_UNLOCK(&qObj->qMutex);
}

NODE*allocate_node(void*data)
{
NODE*node= (NODE*)calloc(1,
sizeof (NODE));
node->next=node->prev=0;
node->data=data;

return (node);
}


voidqDestroy(queueObj_t*qObj) {

if(!qObj) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=NULL;

while(qObj->qHead!=NULL) {

node=qObj->qHead;
qObj->qHead=qObj->qHead->next;

FREE(node);
	}

qObj->qTail=qObj->qHead=0;

Q_UNLOCK(&qObj->qMutex);
pthread_mutex_destroy(&qObj->qMutex);
}


voidprintQ(queueObj_t*qObj, workCBfunc)
{

NODE*node=qObj->qHead;

if(!node) {
return;
	}

while(node!=NULL) {
func(node->data);
node=node->next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include<malloc.h>
#include<pthread.h>
#include<string.h>
#include"queue.h"
#include"common.h"


voidqInit(queueObj_t*qObj)
{
qObj->qHead=qObj->qTail=NULL;
pthread_mutex_init(&qObj->qMutex, NULL);
}


voidqInsert(queueObj_t*qObj, void*data)
{
if (!qObj|| !data) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=allocate_node(data);

if (!qObj->qHead) {
qObj->qHead=qObj->qTail=node;
++qObj->qCount;

	} else {

qObj->qTail->next=node;
node->prev=qObj->qTail;
qObj->qTail=node;
++qObj->qCount;
	}

Q_UNLOCK(&qObj->qMutex);
}

voidqRemove(queueObj_t*qObj, void*data, size_tnSize)
{
Q_LOCK(&qObj->qMutex);

NODE*node=qObj->qHead;

if (!qObj->qHead|| !qObj->qTail) {
 goto end;
	}


if(qObj->qHead==qObj->qTail) {

node=qObj->qHead;
qObj->qHead=qObj->qTail=NULL;
--qObj->qCount;

	} else {

qObj->qHead=qObj->qHead->next;
node->next=NULL;
qObj->qHead->prev=NULL;
--qObj->qCount;
	}

if(data) {
memcpy(data, node->data, nSize);
	}


end:
FREE(node);
Q_UNLOCK(&qObj->qMutex);
}

NODE*allocate_node(void*data)
{
NODE*node= (NODE*)calloc(1,
sizeof (NODE));
node->next=node->prev=0;
node->data=data;

return (node);
}


voidqDestroy(queueObj_t*qObj) {

if(!qObj) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=NULL;

while(qObj->qHead!=NULL) {

node=qObj->qHead;
qObj->qHead=qObj->qHead->next;

FREE(node);
	}

qObj->qTail=qObj->qHead=0;

Q_UNLOCK(&qObj->qMutex);
pthread_mutex_destroy(&qObj->qMutex);
}


voidprintQ(queueObj_t*qObj, workCBfunc)
{

NODE*node=qObj->qHead;

if(!node) {
return;
	}

while(node!=NULL) {
func(node->data);
node=node->next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include<malloc.h>
#include<pthread.h>
#include<string.h>
#include"queue.h"
#include"common.h"


voidqInit(queueObj_t*qObj)
{
qObj->qHead=qObj->qTail=NULL;
pthread_mutex_init(&qObj->qMutex, NULL);
}


voidqInsert(queueObj_t*qObj, void*data)
{
if (!qObj|| !data) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=allocate_node(data);

if (!qObj->qHead) {
qObj->qHead=qObj->qTail=node;
++qObj->qCount;

	} else {

qObj->qTail->next=node;
node->prev=qObj->qTail;
qObj->qTail=node;
++qObj->qCount;
	}

Q_UNLOCK(&qObj->qMutex);
}

voidqRemove(queueObj_t*qObj, void*data, size_tnSize)
{
Q_LOCK(&qObj->qMutex);

NODE*node=qObj->qHead;

if (!qObj->qHead|| !qObj->qTail) {
 goto end;
	}


if(qObj->qHead==qObj->qTail) {

node=qObj->qHead;
qObj->qHead=qObj->qTail=NULL;
--qObj->qCount;

	} else {

qObj->qHead=qObj->qHead->next;
node->next=NULL;
qObj->qHead->prev=NULL;
--qObj->qCount;
	}

if(data) {
memcpy(data, node->data, nSize);
	}


end:
FREE(node);
Q_UNLOCK(&qObj->qMutex);
}

NODE*allocate_node(void*data)
{
NODE*node= (NODE*)calloc(1,
sizeof (NODE));
node->next=node->prev=0;
node->data=data;

return (node);
}


voidqDestroy(queueObj_t*qObj) {

if(!qObj) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=NULL;

while(qObj->qHead!=NULL) {

node=qObj->qHead;
qObj->qHead=qObj->qHead->next;

FREE(node);
	}

qObj->qTail=qObj->qHead=0;

Q_UNLOCK(&qObj->qMutex);
pthread_mutex_destroy(&qObj->qMutex);
}


voidprintQ(queueObj_t*qObj, workCBfunc)
{

NODE*node=qObj->qHead;

if(!node) {
return;
	}

while(node!=NULL) {
func(node->data);
node=node->next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include<malloc.h>
#include<pthread.h>
#include<string.h>
#include"queue.h"
#include"common.h"


voidqInit(queueObj_t*qObj)
{
qObj->qHead=qObj->qTail=NULL;
pthread_mutex_init(&qObj->qMutex, NULL);
}


voidqInsert(queueObj_t*qObj, void*data)
{
if (!qObj|| !data) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=allocate_node(data);

if (!qObj->qHead) {
qObj->qHead=qObj->qTail=node;
++qObj->qCount;

	} else {

qObj->qTail->next=node;
node->prev=qObj->qTail;
qObj->qTail=node;
++qObj->qCount;
	}

Q_UNLOCK(&qObj->qMutex);
}

voidqRemove(queueObj_t*qObj, void*data, size_tnSize)
{
Q_LOCK(&qObj->qMutex);

NODE*node=qObj->qHead;

if (!qObj->qHead|| !qObj->qTail) {
 goto end;
	}


if(qObj->qHead==qObj->qTail) {

node=qObj->qHead;
qObj->qHead=qObj->qTail=NULL;
--qObj->qCount;

	} else {

qObj->qHead=qObj->qHead->next;
node->next=NULL;
qObj->qHead->prev=NULL;
--qObj->qCount;
	}

if(data) {
memcpy(data, node->data, nSize);
	}


end:
FREE(node);
Q_UNLOCK(&qObj->qMutex);
}

NODE*allocate_node(void*data)
{
NODE*node= (NODE*)calloc(1,
sizeof (NODE));
node->next=node->prev=0;
node->data=data;

return (node);
}


voidqDestroy(queueObj_t*qObj) {

if(!qObj) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=NULL;

while(qObj->qHead!=NULL) {

node=qObj->qHead;
qObj->qHead=qObj->qHead->next;

FREE(node);
	}

qObj->qTail=qObj->qHead=0;

Q_UNLOCK(&qObj->qMutex);
pthread_mutex_destroy(&qObj->qMutex);
}


voidprintQ(queueObj_t*qObj, workCBfunc)
{

NODE*node=qObj->qHead;

if(!node) {
return;
	}

while(node!=NULL) {
func(node->data);
node=node->next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include<malloc.h>
#include<pthread.h>
#include<string.h>
#include"queue.h"
#include"common.h"


voidqInit(queueObj_t*qObj)
{
qObj->qHead=qObj->qTail=NULL;
pthread_mutex_init(&qObj->qMutex, NULL);
}


voidqInsert(queueObj_t*qObj, void*data)
{
if (!qObj|| !data) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=allocate_node(data);

if (!qObj->qHead) {
qObj->qHead=qObj->qTail=node;
++qObj->qCount;

	} else {

qObj->qTail->next=node;
node->prev=qObj->qTail;
qObj->qTail=node;
++qObj->qCount;
	}

Q_UNLOCK(&qObj->qMutex);
}

voidqRemove(queueObj_t*qObj, void*data, size_tnSize)
{
Q_LOCK(&qObj->qMutex);

NODE*node=qObj->qHead;

if (!qObj->qHead|| !qObj->qTail) {
 goto end;
	}


if(qObj->qHead==qObj->qTail) {

node=qObj->qHead;
qObj->qHead=qObj->qTail=NULL;
--qObj->qCount;

	} else {

qObj->qHead=qObj->qHead->next;
node->next=NULL;
qObj->qHead->prev=NULL;
--qObj->qCount;
	}

if(data) {
memcpy(data, node->data, nSize);
	}


end:
FREE(node);
Q_UNLOCK(&qObj->qMutex);
}

NODE*allocate_node(void*data)
{
NODE*node= (NODE*)calloc(1,
sizeof (NODE));
node->next=node->prev=0;
node->data=data;

return (node);
}


voidqDestroy(queueObj_t*qObj) {

if(!qObj) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=NULL;

while(qObj->qHead!=NULL) {

node=qObj->qHead;
qObj->qHead=qObj->qHead->next;

FREE(node);
	}

qObj->qTail=qObj->qHead=0;

Q_UNLOCK(&qObj->qMutex);
pthread_mutex_destroy(&qObj->qMutex);
}


voidprintQ(queueObj_t*qObj, workCBfunc)
{

NODE*node=qObj->qHead;

if(!node) {
return;
	}

while(node!=NULL) {
func(node->data);
node=node->next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include<malloc.h>
#include<pthread.h>
#include<string.h>
#include"queue.h"
#include"common.h"


voidqInit(queueObj_t*qObj)
{
qObj->qHead=qObj->qTail=NULL;
pthread_mutex_init(&qObj->qMutex, NULL);
}


voidqInsert(queueObj_t*qObj, void*data)
{
if (!qObj|| !data) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=allocate_node(data);

if (!qObj->qHead) {
qObj->qHead=qObj->qTail=node;
++qObj->qCount;

	} else {

qObj->qTail->next=node;
node->prev=qObj->qTail;
qObj->qTail=node;
++qObj->qCount;
	}

Q_UNLOCK(&qObj->qMutex);
}

voidqRemove(queueObj_t*qObj, void*data, size_tnSize)
{
Q_LOCK(&qObj->qMutex);

NODE*node=qObj->qHead;

if (!qObj->qHead|| !qObj->qTail) {
 goto end;
	}


if(qObj->qHead==qObj->qTail) {

node=qObj->qHead;
qObj->qHead=qObj->qTail=NULL;
--qObj->qCount;

	} else {

qObj->qHead=qObj->qHead->next;
node->next=NULL;
qObj->qHead->prev=NULL;
--qObj->qCount;
	}

if(data) {
memcpy(data, node->data, nSize);
	}


end:
FREE(node);
Q_UNLOCK(&qObj->qMutex);
}

NODE*allocate_node(void*data)
{
NODE*node= (NODE*)calloc(1,
sizeof (NODE));
node->next=node->prev=0;
node->data=data;

return (node);
}


voidqDestroy(queueObj_t*qObj) {

if(!qObj) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=NULL;

while(qObj->qHead!=NULL) {

node=qObj->qHead;
qObj->qHead=qObj->qHead->next;

FREE(node);
	}

qObj->qTail=qObj->qHead=0;

Q_UNLOCK(&qObj->qMutex);
pthread_mutex_destroy(&qObj->qMutex);
}


voidprintQ(queueObj_t*qObj, workCBfunc)
{

NODE*node=qObj->qHead;

if(!node) {
return;
	}

while(node!=NULL) {
func(node->data);
node=node->next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include<malloc.h>
#include<pthread.h>
#include<string.h>
#include"queue.h"
#include"common.h"


voidqInit(queueObj_t*qObj)
{
qObj->qHead=qObj->qTail=NULL;
pthread_mutex_init(&qObj->qMutex, NULL);
}


voidqInsert(queueObj_t*qObj, void*data)
{
if (!qObj|| !data) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=allocate_node(data);

if (!qObj->qHead) {
qObj->qHead=qObj->qTail=node;
++qObj->qCount;

	} else {

qObj->qTail->next=node;
node->prev=qObj->qTail;
qObj->qTail=node;
++qObj->qCount;
	}

Q_UNLOCK(&qObj->qMutex);
}

voidqRemove(queueObj_t*qObj, void*data, size_tnSize)
{
Q_LOCK(&qObj->qMutex);

NODE*node=qObj->qHead;

if (!qObj->qHead|| !qObj->qTail) {
 goto end;
	}


if(qObj->qHead==qObj->qTail) {

node=qObj->qHead;
qObj->qHead=qObj->qTail=NULL;
--qObj->qCount;

	} else {

qObj->qHead=qObj->qHead->next;
node->next=NULL;
qObj->qHead->prev=NULL;
--qObj->qCount;
	}

if(data) {
memcpy(data, node->data, nSize);
	}


end:
FREE(node);
Q_UNLOCK(&qObj->qMutex);
}

NODE*allocate_node(void*data)
{
NODE*node= (NODE*)calloc(1,
sizeof (NODE));
node->next=node->prev=0;
node->data=data;

return (node);
}


voidqDestroy(queueObj_t*qObj) {

if(!qObj) {
return;
	}

Q_LOCK(&qObj->qMutex);

NODE*node=NULL;

while(qObj->qHead!=NULL) {

node=qObj->qHead;
qObj->qHead=qObj->qHead->next;

FREE(node);
	}

qObj->qTail=qObj->qHead=0;

Q_UNLOCK(&qObj->qMutex);
pthread_mutex_destroy(&qObj->qMutex);
}


voidprintQ(queueObj_t*qObj, workCBfunc)
{

NODE*node=qObj->qHead;

if(!node) {
return;
	}

while(node!=NULL) {
func(node->data);
node=node->next;
	}
}