user32/tests: Remove unreachable break after return (Smatch).
[wine] / dlls / qmgr / enum_jobs.c
1 /*
2  * Queue Manager (BITS) Job Enumerator
3  *
4  * Copyright 2007 Google (Roy Shea)
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "qmgr.h"
22 #include "wine/debug.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
25
26 static void EnumBackgroundCopyJobsDestructor(EnumBackgroundCopyJobsImpl *This)
27 {
28     ULONG i;
29
30     for(i = 0; i < This->numJobs; i++)
31         IBackgroundCopyJob_Release(This->jobs[i]);
32
33     HeapFree(GetProcessHeap(), 0, This->jobs);
34     HeapFree(GetProcessHeap(), 0, This);
35 }
36
37 static ULONG WINAPI BITS_IEnumBackgroundCopyJobs_AddRef(
38     IEnumBackgroundCopyJobs* iface)
39 {
40     EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
41     return InterlockedIncrement(&This->ref);
42 }
43
44 static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_QueryInterface(
45     IEnumBackgroundCopyJobs* iface,
46     REFIID riid,
47     void **ppvObject)
48 {
49     EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
50     TRACE("IID: %s\n", debugstr_guid(riid));
51
52     if (IsEqualGUID(riid, &IID_IUnknown)
53         || IsEqualGUID(riid, &IID_IEnumBackgroundCopyJobs))
54     {
55         *ppvObject = &This->lpVtbl;
56         BITS_IEnumBackgroundCopyJobs_AddRef(iface);
57         return S_OK;
58     }
59
60     *ppvObject = NULL;
61     return E_NOINTERFACE;
62 }
63
64 static ULONG WINAPI BITS_IEnumBackgroundCopyJobs_Release(
65     IEnumBackgroundCopyJobs* iface)
66 {
67     EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
68     ULONG ref = InterlockedDecrement(&This->ref);
69
70     if (ref == 0)
71         EnumBackgroundCopyJobsDestructor(This);
72
73     return ref;
74 }
75
76 static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_Next(
77     IEnumBackgroundCopyJobs* iface,
78     ULONG celt,
79     IBackgroundCopyJob **rgelt,
80     ULONG *pceltFetched)
81 {
82     EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
83     ULONG fetched;
84     ULONG i;
85     IBackgroundCopyJob *job;
86
87     fetched = min(celt, This->numJobs - This->indexJobs);
88     if (pceltFetched)
89         *pceltFetched = fetched;
90     else
91     {
92         /* We need to initialize this array if the caller doesn't request
93            the length because length_is will default to celt.  */
94         for (i = 0; i < celt; ++i)
95             rgelt[i] = NULL;
96
97         /* pceltFetched can only be NULL if celt is 1 */
98         if (celt != 1)
99             return E_INVALIDARG;
100     }
101
102     /* Fill in the array of objects */
103     for (i = 0; i < fetched; ++i)
104     {
105         job = This->jobs[This->indexJobs++];
106         IBackgroundCopyJob_AddRef(job);
107         rgelt[i] = job;
108     }
109
110     return fetched == celt ? S_OK : S_FALSE;
111 }
112
113 static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_Skip(
114     IEnumBackgroundCopyJobs* iface,
115     ULONG celt)
116 {
117     EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
118
119     if (This->numJobs - This->indexJobs < celt)
120     {
121         This->indexJobs = This->numJobs;
122         return S_FALSE;
123     }
124
125     This->indexJobs += celt;
126     return S_OK;
127 }
128
129 static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_Reset(
130     IEnumBackgroundCopyJobs* iface)
131 {
132     EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
133     This->indexJobs = 0;
134     return S_OK;
135 }
136
137 static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_Clone(
138     IEnumBackgroundCopyJobs* iface,
139     IEnumBackgroundCopyJobs **ppenum)
140 {
141     FIXME("Not implemented\n");
142     return E_NOTIMPL;
143 }
144
145 static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_GetCount(
146     IEnumBackgroundCopyJobs* iface,
147     ULONG *puCount)
148 {
149     EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
150     *puCount = This->numJobs;
151     return S_OK;
152 }
153
154 static const IEnumBackgroundCopyJobsVtbl BITS_IEnumBackgroundCopyJobs_Vtbl =
155 {
156     BITS_IEnumBackgroundCopyJobs_QueryInterface,
157     BITS_IEnumBackgroundCopyJobs_AddRef,
158     BITS_IEnumBackgroundCopyJobs_Release,
159     BITS_IEnumBackgroundCopyJobs_Next,
160     BITS_IEnumBackgroundCopyJobs_Skip,
161     BITS_IEnumBackgroundCopyJobs_Reset,
162     BITS_IEnumBackgroundCopyJobs_Clone,
163     BITS_IEnumBackgroundCopyJobs_GetCount
164 };
165
166 HRESULT EnumBackgroundCopyJobsConstructor(LPVOID *ppObj,
167                                           IBackgroundCopyManager* copyManager)
168 {
169     BackgroundCopyManagerImpl *qmgr = (BackgroundCopyManagerImpl *) copyManager;
170     EnumBackgroundCopyJobsImpl *This;
171     BackgroundCopyJobImpl *job;
172     ULONG i;
173
174     TRACE("%p, %p)\n", ppObj, copyManager);
175
176     This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
177     if (!This)
178         return E_OUTOFMEMORY;
179     This->lpVtbl = &BITS_IEnumBackgroundCopyJobs_Vtbl;
180     This->ref = 1;
181
182     /* Create array of jobs */
183     This->indexJobs = 0;
184
185     EnterCriticalSection(&qmgr->cs);
186     This->numJobs = list_count(&qmgr->jobs);
187
188     if (0 < This->numJobs)
189     {
190         This->jobs = HeapAlloc(GetProcessHeap(), 0,
191                                This->numJobs * sizeof *This->jobs);
192         if (!This->jobs)
193         {
194             LeaveCriticalSection(&qmgr->cs);
195             HeapFree(GetProcessHeap(), 0, This);
196             return E_OUTOFMEMORY;
197         }
198     }
199     else
200         This->jobs = NULL;
201
202     i = 0;
203     LIST_FOR_EACH_ENTRY(job, &qmgr->jobs, BackgroundCopyJobImpl, entryFromQmgr)
204     {
205         IBackgroundCopyJob *iJob = (IBackgroundCopyJob *) job;
206         IBackgroundCopyJob_AddRef(iJob);
207         This->jobs[i++] = iJob;
208     }
209     LeaveCriticalSection(&qmgr->cs);
210
211     *ppObj = &This->lpVtbl;
212     return S_OK;
213 }