void queueInit (tQueue* q) {
/*
** Inicializujte frontu nsledujcm zpsobem:
** - vechny hodnoty v poli q->arr nastavte na '*',
** - index na zatek fronty nastavte na 0,
** - index prvnho volnho msta nastavte tak na 0.
**
** V ppad, e funkce dostane jako parametr q == NULL, volejte funkci
** queueError(QERR_INIT).
*/
if(q == NULL)
{
queueError(QERR_INIT);
}
else
{
int i;
q->f_index = 0;
q->b_index = 0;
for (i = 0; i < (QUEUE_SIZE) ; i++)
{
q->arr[i] = '*';
}
}
}
void queueRemove (tQueue* q) {
/*
** Odstraní znak ze zaèátku fronty q. Pokud je fronta prázdná, o¹etøete
** vzniklou chybu voláním funkce queueError(QERR_REMOVE).
** Hodnotu na uvolnìné pozici ve frontì nijak neo¹etøujte (nepøepisujte).
** Pøi implementaci vyu¾ijte døíve definované funkce queueEmpty a nextIndex.
*/
if (queueEmpty(q))
{
queueError(QERR_REMOVE);
return;
}
q->f_index = nextIndex(q->f_index); /* Indexom prvého prvku sa stáva prvok za aktuálnym f_index */
}
void queueRemove (tQueue* q) {
/*
** Odstraní znak ze zaèátku fronty q. Pokud je fronta prázdná, o¹etøete
** vzniklou chybu voláním funkce queueError(QERR_REMOVE).
** Hodnotu na uvolnìné pozici ve frontì nijak neo¹etøujte (nepøepisujte).
** Pøi implementaci vyu¾ijte døíve definované funkce queueEmpty a nextIndex.
*/
if(queueEmpty(q)){ // Zkontroluj, zda-li neni fronte prazdna
queueError(QERR_REMOVE); // Vyhod chybovou hlasku
return; // Ukonci
}
q->f_index = nextIndex(q->f_index); // Odstran znak ze zacatku fronty
}
void queueGet (tQueue* q, char* c) {
/*
** Odstraní znak ze zaèátku fronty a vrátí ho prostøednictvím parametru c.
** Pokud je fronta prázdná, o¹etøete to voláním funkce queueError(QERR_GET).
**
** Pøi implementaci vyu¾ijte døíve definovaných funkcí queueEmpty,
** queueFront a queueRemove.
*/
if(queueEmpty(q)){ // Zkontroluj, zda-li neni fronte prazdna
queueError(QERR_GET); // Vyhod chybovou hlasku
return; // Ukonci
}
queueFront(q, c); // Vrat znak
queueRemove(q); // A odstran ho
}
void queueRemove (tQueue* q) {
/*
** Odstran znak ze zatku fronty q. Pokud je fronta przdn, oetete
** vzniklou chybu volnm funkce queueError(QERR_REMOVE).
** Hodnotu na uvolnn pozici ve front nijak neoetujte (nepepisujte).
** Pi implementaci vyuijte dve definovan funkce queueEmpty a nextIndex.
*/
if(queueEmpty(q) == 0)
{
q->f_index = nextIndex(q->f_index);
}
else
{
queueError(QERR_REMOVE);
}
}
void queueRemove (tQueue* q) {
/*
** Odstraní znak ze zaèátku fronty q. Pokud je fronta prázdná, o¹etøete
** vzniklou chybu voláním funkce queueError(QERR_REMOVE).
** Hodnotu na uvolnìné pozici ve frontì nijak neo¹etøujte (nepøepisujte).
** Pøi implementaci vyu¾ijte døíve definované funkce queueEmpty a nextIndex.
*/
if(queueEmpty(q) == 0) //fronta nie je prazdna
{
q->f_index = nextIndex(q->f_index); //posunieme sa
}
else //fronta je prazdna
{
queueError(QERR_REMOVE);
}
}
void queueGet (tQueue* q, char* c) {
/*
** Odstraní znak ze zaèátku fronty a vrátí ho prostøednictvím parametru c.
** Pokud je fronta prázdná, o¹etøete to voláním funkce queueError(QERR_GET).
**
** Pøi implementaci vyu¾ijte døíve definovaných funkcí queueEmpty,
** queueFront a queueRemove.
*/
if (queueEmpty(q))
{
queueError(QERR_GET);
return;
}
queueFront(q, c); /* c bude ukazova» na prvý znak fronty */
queueRemove(q); /* Index prvého prvku sa posunie na nasledujúci */
}
void queueUp (tQueue* q, char c) {
/*
** Vlo¾í znak c do fronty. Pokud je fronta plná, o¹etøete chybu voláním
** funkce queueError(QERR_UP). Vkládání do plné fronty se pova¾uje za
** nekorektní operaci. Situace by mohla být øe¹ena i tak, ¾e by operace
** neprovádìla nic, ale v pøípadì pou¾ití takto definované abstrakce by se
** obtí¾nì odhalovaly chyby v algoritmech, které by abstrakci vyu¾ívaly.
**
** Pøi implementaci vyu¾ijte døíve definovaných funkcí queueFull a nextIndex.
*/
if(queueFull(q)){ // Zkontroluj, zda-li neni fronte plna
queueError(QERR_UP); // Vyhod chybovou hlasku
return; // Ukonci
}
q->arr[q->b_index] = c; // Vloz znak
q->b_index = nextIndex(q->b_index); // A posun index posledni volne pozice
}
void queueGet (tQueue* q, char* c) {
/*
** Odstraní znak ze zaèátku fronty a vrátí ho prostøednictvím parametru c.
** Pokud je fronta prázdná, o¹etøete to voláním funkce queueError(QERR_GET).
**
** Pøi implementaci vyu¾ijte døíve definovaných funkcí queueEmpty,
** queueFront a queueRemove.
*/
if(queueEmpty(q) == 0) //fronta nie je prazdna
{
queueFront(q, c); //najprv vratime znak
queueRemove(q); //potom odstranime
}
else //fronta je prazdna
{
queueError(QERR_GET);
}
}
void queueUp (tQueue* q, char c) {
/*
** Vlo¾í znak c do fronty. Pokud je fronta plná, o¹etøete chybu voláním
** funkce queueError(QERR_UP). Vkládání do plné fronty se pova¾uje za
** nekorektní operaci. Situace by mohla být øe¹ena i tak, ¾e by operace
** neprovádìla nic, ale v pøípadì pou¾ití takto definované abstrakce by se
** obtí¾nì odhalovaly chyby v algoritmech, které by abstrakci vyu¾ívaly.
**
** Pøi implementaci vyu¾ijte døíve definovaných funkcí queueFull a nextIndex.
*/
if (queueFull(q))
{
queueError(QERR_UP);
return;
}
q->arr[q->b_index] = c; /* Vlo¾í znak c na prvú voµnú pozíciu vo fronte */
q->b_index = nextIndex(q->b_index); /* Nastaví b_index na ïal¹iu voµnú pozíciu vo fronte */
}
void queueGet (tQueue* q, char* c) {
/*
** Odstran znak ze zatku fronty a vrt ho prostednictvm parametru c.
** Pokud je fronta przdn, oetete to volnm funkce queueError(QERR_GET).
**
** Pi implementaci vyuijte dve definovanch funkc queueEmpty,
** queueFront a queueRemove.
*/
if(queueEmpty(q) == 0)
{
queueFront(q, c);
queueRemove(q);
}
else
{
queueError(QERR_GET);
}
}
void queueFront (const tQueue* q, char* c) {
/*
** Prostøednictvím parametru c crátí znak ze zaèátku fronty q.
** Pokud je fronta prázdná, o¹etøete to voláním funkce queueError(QERR_FRONT).
** Volání této funkce pøi prázdné frontì je v¾dy nutné pova¾ovat za nekorektní.
** Bývá to toti¾ dùsledek ¹patného návrhu algoritmu, ve kterém je fronta
** pou¾ita. O takové situaci se proto musí programátor-vývojáø dozvìdìt.
** V opaèném pøípadì je ladìní programù obtí¾nìj¹í!
**
** Pøi implementaci vyu¾ijte døíve definované funkce queueEmpty.
*/
if (queueEmpty(q))
{
queueError(QERR_FRONT);
return;
}
*c = q->arr[q->f_index]; /* Na adresu kam ukazuje pointer c ulo¾í prvý prvok fronty */
}
void queueFront (const tQueue* q, char* c) {
/*
** Prostøednictvím parametru c crátí znak ze zaèátku fronty q.
** Pokud je fronta prázdná, o¹etøete to voláním funkce queueError(QERR_FRONT).
** Volání této funkce pøi prázdné frontì je v¾dy nutné pova¾ovat za nekorektní.
** Bývá to toti¾ dùsledek ¹patného návrhu algoritmu, ve kterém je fronta
** pou¾ita. O takové situaci se proto musí programátor-vývojáø dozvìdìt.
** V opaèném pøípadì je ladìní programù obtí¾nìj¹í!
**
** Pøi implementaci vyu¾ijte døíve definované funkce queueEmpty.
*/
if(queueEmpty(q)){ // Zkontroluj, zda-li neni fronte prazdna
queueError(QERR_FRONT); // Vyhod chybovou hlasku
return; // Ukonci
}
*c = q->arr[q->f_index]; // Vrat znak zacatku fronty
}
void queueUp (tQueue* q, char c) {
/*
** Vlo¾í znak c do fronty. Pokud je fronta plná, o¹etøete chybu voláním
** funkce queueError(QERR_UP). Vkládání do plné fronty se pova¾uje za
** nekorektní operaci. Situace by mohla být øe¹ena i tak, ¾e by operace
** neprovádìla nic, ale v pøípadì pou¾ití takto definované abstrakce by se
** obtí¾nì odhalovaly chyby v algoritmech, které by abstrakci vyu¾ívaly.
**
** Pøi implementaci vyu¾ijte døíve definovaných funkcí queueFull a nextIndex.
*/
if(queueFull(q) == 0) //fronta nieje plna
{
q->arr[q->b_index] = c; //vlozime znak
q->b_index = nextIndex(q->b_index); //posunieme sa
}
else //fronta je plna vypiseme chybu
{
queueError(QERR_UP);
}
}
void queueInit (tQueue* q) {
/*
** Inicializujte frontu následujícím zpùsobem:
** - v¹echny hodnoty v poli q->arr nastavte na '*',
** - index na zaèátek fronty nastavte na 0,
** - index prvního volného místa nastavte také na 0.
**
** V pøípadì, ¾e funkce dostane jako parametr q == NULL, volejte funkci
** queueError(QERR_INIT).
*/
if (q == NULL)
{
queueError(QERR_INIT);
return;
}
for (int i = 0; i < QUEUE_SIZE; i++)
q->arr[i] = '*';
q->f_index = 0;
q->b_index = 0;
}
void queueFront (const tQueue* q, char* c) {
/*
** Prostednictvm parametru c crt znak ze zatku fronty q.
** Pokud je fronta przdn, oetete to volnm funkce queueError(QERR_FRONT).
** Voln tto funkce pi przdn front je vdy nutn povaovat za nekorektn.
** Bv to toti dsledek patnho nvrhu algoritmu, ve kterm je fronta
** pouita. O takov situaci se proto mus programtor-vvoj dozvdt.
** V opanm ppad je ladn program obtnj!
**
** Pi implementaci vyuijte dve definovan funkce queueEmpty.
*/
if(queueEmpty(q) == 0)
{
*c = q->arr[q->f_index];
}
else
{
queueError(QERR_FRONT);
}
}
void queueUp (tQueue* q, char c) {
/*
** Vlo znak c do fronty. Pokud je fronta pln, oetete chybu volnm
** funkce queueError(QERR_UP). Vkldn do pln fronty se povauje za
** nekorektn operaci. Situace by mohla bt eena i tak, e by operace
** neprovdla nic, ale v ppad pouit takto definovan abstrakce by se
** obtn odhalovaly chyby v algoritmech, kter by abstrakci vyuvaly.
**
** Pi implementaci vyuijte dve definovanch funkc queueFull a nextIndex.
*/
if(queueFull(q) == 0)
{
q->arr[q->b_index] = c;
q->b_index = nextIndex(q->b_index);
}
else
{
queueError(QERR_UP);
}
}
void queueInit (tQueue* q) {
/*
** Inicializujte frontu následujícím zpùsobem:
** - v¹echny hodnoty v poli q->arr nastavte na '*',
** - index na zaèátek fronty nastavte na 0,
** - index prvního volného místa nastavte také na 0.
**
** V pøípadì, ¾e funkce dostane jako parametr q == NULL, volejte funkci
** queueError(QERR_INIT).
*/
if(!q){ // Dostanes-li NULL
queueError(QERR_INIT); // Vyhod chybovou hlasku
return; // A ukonci
}
int i;
for(i = 0; i < QUEUE_SIZE; i++) // Projed frontou
q->arr[i] = '*'; // A nadstav vsude hodnotu hvezdicka
q->f_index = 0; // Oba indexy
q->b_index = 0; // Nadstav na nulu
}
void Logger::queueError(ErrorType type, const wchar_t* format, ...)
{
std::wstring result;
va_list args;
va_start(args,format);
int length = _vscwprintf(format,args);
if (length < 0) // error
{
va_end(args);
return;
}
wchar_t* buffer = (wchar_t*) alloca((length+1)*sizeof(wchar_t));
length = _vsnwprintf(buffer,length+1,format,args);
if (length < 0)
return;
va_end(args);
result = buffer;
queueError(type,result);
}
