PJ *PROJECTION(bonne) {
double c;
struct pj_opaque *Q = static_cast<struct pj_opaque*>(pj_calloc (1, sizeof (struct pj_opaque)));
if (nullptr==Q)
return pj_default_destructor (P, ENOMEM);
P->opaque = Q;
P->destructor = destructor;
Q->phi1 = pj_param(P->ctx, P->params, "rlat_1").f;
if (fabs(Q->phi1) < EPS10)
return destructor (P, PJD_ERR_LAT1_IS_ZERO);
if (P->es != 0.0) {
Q->en = pj_enfn(P->es);
if (nullptr==Q->en)
return destructor(P, ENOMEM);
Q->m1 = pj_mlfn(Q->phi1, Q->am1 = sin(Q->phi1),
c = cos(Q->phi1), Q->en);
Q->am1 = c / (sqrt(1. - P->es * Q->am1 * Q->am1) * Q->am1);
P->inv = e_inverse;
P->fwd = e_forward;
} else {
if (fabs(Q->phi1) + EPS10 >= M_HALFPI)
Q->cphi1 = 0.;
else
Q->cphi1 = 1. / tan(Q->phi1);
P->inv = s_inverse;
P->fwd = s_forward;
}
return P;
}
int main(){
Employee *pEmp = (Employee *) malloc(sizeof(Employee));
pEmp->homeAddress = (Address *) malloc(sizeof(Address));
pEmp->workAddress = (Address *) malloc(sizeof(Address));
//Filling in a value for Employee and Address(home & work)
strcpy(pEmp->firstName, "John");
strcpy(pEmp->lastName, "Rasay");
pEmp->height = 5.10;
//Home Address
strcpy(pEmp->homeAddress->street,"1724 C North School St");
strcpy(pEmp->homeAddress->city,"Honolulu");
strcpy(pEmp->homeAddress->state,"Hi");
strcpy(pEmp->homeAddress->country,"United States");
pEmp->homeAddress->zipcode = 96819;
//Work Address
strcpy(pEmp->workAddress->street,"98-1005 Moanalua Road Aiea");
strcpy(pEmp->workAddress->city,"Honolulu");
strcpy(pEmp->workAddress->state,"Hi");
strcpy(pEmp->workAddress->country,"United States");
pEmp->workAddress->zipcode = 96701;
//Prints the info of the Employee
printinfo(pEmp);
//Free memory
destructor(pEmp);
printf("\n\nPress any key to continue.");
getchar();
exit(0);
}
int main(){
int n;
printf("\nCuantas personas van hacer la encuesta?\n");
scanf("%d", &n);
persona *personas = (persona *) malloc(n * N * sizeof(persona));
preguntas = (char **) malloc(10 * N * sizeof(char *));
*(preguntas + 0) = "Pregunta 1";
*(preguntas + 1) = "Pregunta 2";
*(preguntas + 2) = "Pregunta 3";
*(preguntas + 3) = "Pregunta 4";
*(preguntas + 4) = "Pregunta 5";
*(preguntas + 5) = "Pregunta 6";
*(preguntas + 6) = "Pregunta 7";
*(preguntas + 7) = "Pregunta 8";
*(preguntas + 8) = "Pregunta 9";
*(preguntas + 9) = "Pregunta 10";
srand((int) time(NULL));
agregar(personas, n);
histograma(personas, n);
destructor(personas, n);
free(preguntas);
return 0;
}
/*
* Function: globus_handle_table_destroy()
*
* Description: Destroy a handle table
*
* Parameters:
*
* Returns:
*/
int
globus_handle_table_destroy(
globus_handle_table_t * e_handle_table)
{
int i;
globus_l_handle_entry_t ** table;
globus_l_handle_entry_t * inactive;
globus_l_handle_entry_t * save;
globus_handle_destructor_t destructor;
globus_l_handle_table_t * handle_table;
if(!e_handle_table)
{
return GLOBUS_FAILURE;
}
handle_table = *e_handle_table;
if(!handle_table)
{
return GLOBUS_FAILURE;
}
/* first free all active handles */
table = handle_table->table;
destructor = handle_table->destructor;
i = handle_table->next_slot;
while(--i > GLOBUS_NULL_HANDLE)
{
if(table[i])
{
if(destructor)
{
destructor(table[i]->value);
}
globus_libc_free(table[i]);
}
}
/* then free inactive handles */
inactive = handle_table->inactive;
while(inactive)
{
save = inactive->pnext;
globus_libc_free(inactive);
inactive = save;
}
/* free the table */
globus_libc_free(table);
/* free the table handle */
globus_libc_free(handle_table);
/* finally, invalidate the handle */
*e_handle_table = NULL;
return GLOBUS_SUCCESS;
}
/*
* mowgli_object_unref
*
* Decrement the reference counter on an object.
*
* Inputs:
* - the object to refcount
*
* Outputs:
* - none
*
* Side Effects:
* - if the refcount is 0, the object is destroyed.
*/
void
mowgli_object_unref(void *object)
{
mowgli_object_t *obj = mowgli_object(object);
return_if_fail(object != NULL);
obj->refcount--;
if (obj->refcount <= 0)
{
mowgli_object_message_broadcast(obj, "destroy");
if (obj->name != NULL)
free(obj->name);
if (obj->klass != NULL)
{
mowgli_destructor_t destructor = obj->klass->destructor;
if (obj->klass->dynamic == TRUE)
mowgli_object_class_destroy(obj->klass);
if (destructor != NULL)
destructor(obj);
else
free(obj);
}
else
{
mowgli_log_warning("invalid object class");
}
}
}
int main(int argc, char *argv[])
{
struct m_inode *mip;
FILE *fp;
if(argc != 5)
{
panic(__FILE__, __LINE__,
"Usage: %s Image super_block_id pathname filename\n",
argv[0]);
}
fp = fopen(argv[4], "rb");
if(!fp)
{
panic(__FILE__, __LINE__, "Can't open %s\n", argv[4]);
}
constructor(argv[1]);
add_file(fp, atoi(argv[2]), argv[3]);
destructor();
return 0;
}
PJ *PROJECTION(lcca) {
double s2p0, N0, R0, tan0;
struct pj_opaque *Q = static_cast<struct pj_opaque*>(pj_calloc (1, sizeof (struct pj_opaque)));
if (nullptr==Q)
return pj_default_destructor (P, ENOMEM);
P->opaque = Q;
(Q->en = pj_enfn(P->es));
if (!Q->en)
return pj_default_destructor (P, ENOMEM);
if (P->phi0 == 0.) {
return destructor(P, PJD_ERR_LAT_0_IS_ZERO);
}
Q->l = sin(P->phi0);
Q->M0 = pj_mlfn(P->phi0, Q->l, cos(P->phi0), Q->en);
s2p0 = Q->l * Q->l;
R0 = 1. / (1. - P->es * s2p0);
N0 = sqrt(R0);
R0 *= P->one_es * N0;
tan0 = tan(P->phi0);
Q->r0 = N0 / tan0;
Q->C = 1. / (6. * R0 * N0);
P->inv = lcca_e_inverse;
P->fwd = lcca_e_forward;
P->destructor = destructor;
return P;
}
void QThreadStorageData::finish(void **p)
{
QMap<int, void *> *tls = reinterpret_cast<QMap<int, void *> *>(p);
if (!tls || tls->isEmpty() || !mutex())
return; // nothing to do
DEBUG_MSG("QThreadStorageData: Destroying storage for thread %p", QThread::currentThread());
QMap<int, void *>::iterator it = tls->begin();
while (it != tls->end()) {
int id = it.key();
void *q = it.value();
it.value() = 0;
++it;
if (!q) {
// data already deleted
continue;
}
mutex()->lock();
void (*destructor)(void *) = destructors()->value(id);
mutex()->unlock();
if (!destructor) {
if (QThread::currentThread())
qWarning("QThreadStorage: Thread %p exited after QThreadStorage %d destroyed",
QThread::currentThread(), id);
continue;
}
destructor(q);
}
tls->clear();
}
void adt_list_destroy(adt_list_t *self)
{
if (self != 0)
{
adt_list_elem_t *iter = self->pFirst;
void (*destructor)(void*) = (void (*)(void*)) 0;
if (iter == 0)
{
return; //empty list
}
if ( (self->destructorEnable != false) && (self->pDestructor != 0) )
{
destructor = self->pDestructor;
}
while( iter != 0 )
{
adt_list_elem_t *pNext = iter->pNext;
if (destructor != 0)
{
destructor(iter->pItem);
}
adt_list_elem_delete(iter);
iter=pNext;
}
}
}
/** Internal deinitialization */
static
void _su_home_deinit(su_home_t *home)
{
if (home->suh_blocks) {
size_t i;
su_block_t *b;
void *suh_lock = home->suh_lock;
home->suh_lock = NULL;
if (home->suh_blocks->sub_destructor) {
void (*destructor)(void *) = home->suh_blocks->sub_destructor;
home->suh_blocks->sub_destructor = NULL;
destructor(home);
}
b = home->suh_blocks;
#ifdef DEBUG
SU_DEBUG_9(("%s: block %p sub_used is %ld sub_n %ld used %d\n", __func__, b, b->sub_used, b->sub_n, su_get_used_count(b))) ;
#endif
su_home_check_blocks(b);
for (i = 0; i < b->sub_n; i++) {
if (b->sub_nodes[i].sua_data) {
if (b->sub_nodes[i].sua_home) {
su_home_t *subhome = b->sub_nodes[i].sua_data;
su_block_t *subb = MEMLOCK(subhome);
assert(subb); assert(subb->sub_ref >= 1);
#if 0
if (subb->sub_ref > 0)
SU_DEBUG_7(("su_home_unref: subhome %p with destructor %p has still %u refs\n",
subhome, subb->sub_destructor, subb->sub_ref));
#endif
subb->sub_ref = 0; /* zap them all */
_su_home_deinit(subhome);
}
else if (su_is_preloaded(b, b->sub_nodes[i].sua_data))
continue;
safefree(b->sub_nodes[i].sua_data);
}
}
if (b->sub_preload && !b->sub_preauto)
free(b->sub_preload);
if (b->sub_stats)
free(b->sub_stats);
if (!b->sub_auto)
free(b);
home->suh_blocks = NULL;
if (suh_lock) {
/* Unlock, or risk assert() or leak handles on Windows */
_su_home_unlocker(suh_lock);
_su_home_destroy_mutexes(suh_lock);
}
}
}
PJ *PROJECTION(imw_p) {
double del, sig, s, t, x1, x2, T2, y1, m1, m2, y2;
int err;
struct pj_opaque *Q = static_cast<struct pj_opaque*>(pj_calloc (1, sizeof (struct pj_opaque)));
if (nullptr==Q)
return pj_default_destructor (P, ENOMEM);
P->opaque = Q;
if (!(Q->en = pj_enfn(P->es))) return pj_default_destructor (P, ENOMEM);
if( (err = phi12(P, &del, &sig)) != 0) {
return destructor(P, err);
}
if (Q->phi_2 < Q->phi_1) { /* make sure P->phi_1 most southerly */
del = Q->phi_1;
Q->phi_1 = Q->phi_2;
Q->phi_2 = del;
}
if (pj_param(P->ctx, P->params, "tlon_1").i)
Q->lam_1 = pj_param(P->ctx, P->params, "rlon_1").f;
else { /* use predefined based upon latitude */
sig = fabs(sig * RAD_TO_DEG);
if (sig <= 60) sig = 2.;
else if (sig <= 76) sig = 4.;
else sig = 8.;
Q->lam_1 = sig * DEG_TO_RAD;
}
Q->mode = NONE_IS_ZERO;
if (Q->phi_1 != 0.0)
xy(P, Q->phi_1, &x1, &y1, &Q->sphi_1, &Q->R_1);
else {
Q->mode = PHI_1_IS_ZERO;
y1 = 0.;
x1 = Q->lam_1;
}
if (Q->phi_2 != 0.0)
xy(P, Q->phi_2, &x2, &T2, &Q->sphi_2, &Q->R_2);
else {
Q->mode = PHI_2_IS_ZERO;
T2 = 0.;
x2 = Q->lam_1;
}
m1 = pj_mlfn(Q->phi_1, Q->sphi_1, cos(Q->phi_1), Q->en);
m2 = pj_mlfn(Q->phi_2, Q->sphi_2, cos(Q->phi_2), Q->en);
t = m2 - m1;
s = x2 - x1;
y2 = sqrt(t * t - s * s) + y1;
Q->C2 = y2 - T2;
t = 1. / t;
Q->P = (m2 * y1 - m1 * y2) * t;
Q->Q = (y2 - y1) * t;
Q->Pp = (m2 * x1 - m1 * x2) * t;
Q->Qp = (x2 - x1) * t;
P->fwd = e_forward;
P->inv = e_inverse;
P->destructor = destructor;
return P;
}
void fun_sub ()
{
VAR_ rval = *copyCons(top()); /* make a copy */
pop(); /* remove the r-operand */
subtract(top(), &rval); /* subtract the rval to the top */
destructor(&rval); /* remove the local var */
}
PJ *PROJECTION(laea) {
double t;
struct pj_opaque *Q = pj_calloc (1, sizeof (struct pj_opaque));
if (0==Q)
return pj_default_destructor (P, ENOMEM);
P->opaque = Q;
P->destructor = destructor;
t = fabs(P->phi0);
if (fabs(t - M_HALFPI) < EPS10)
Q->mode = P->phi0 < 0. ? S_POLE : N_POLE;
else if (fabs(t) < EPS10)
Q->mode = EQUIT;
else
Q->mode = OBLIQ;
if (P->es != 0.0) {
double sinphi;
P->e = sqrt(P->es);
Q->qp = pj_qsfn(1., P->e, P->one_es);
Q->mmf = .5 / (1. - P->es);
Q->apa = pj_authset(P->es);
if (0==Q->apa)
return destructor(P, ENOMEM);
switch (Q->mode) {
case N_POLE:
case S_POLE:
Q->dd = 1.;
break;
case EQUIT:
Q->dd = 1. / (Q->rq = sqrt(.5 * Q->qp));
Q->xmf = 1.;
Q->ymf = .5 * Q->qp;
break;
case OBLIQ:
Q->rq = sqrt(.5 * Q->qp);
sinphi = sin(P->phi0);
Q->sinb1 = pj_qsfn(sinphi, P->e, P->one_es) / Q->qp;
Q->cosb1 = sqrt(1. - Q->sinb1 * Q->sinb1);
Q->dd = cos(P->phi0) / (sqrt(1. - P->es * sinphi * sinphi) *
Q->rq * Q->cosb1);
Q->ymf = (Q->xmf = Q->rq) / Q->dd;
Q->xmf *= Q->dd;
break;
}
P->inv = e_inverse;
P->fwd = e_forward;
} else {
if (Q->mode == OBLIQ) {
Q->sinb1 = sin(P->phi0);
Q->cosb1 = cos(P->phi0);
}
P->inv = s_inverse;
P->fwd = s_forward;
}
return P;
}
int main() {
barcos = 0;
embarcacion *embarcaciones = (embarcacion *) malloc(N * L * L * sizeof(embarcaciones));
menu(embarcaciones);
destructor(embarcaciones);
return 0;
}
void __attribute__ ((destructor)) default_impl_destroy(void){
#else
void __attribute__ ((destructor(1000))) default_impl_destroy(void){
#endif
free_default_device_storage_path();
free_default_device_info();
}
SensorsList& SensorsList::operator=(const SensorsList& other)
{
if(this != &other)
{
destructor();
constructor(other);
}
return *this;
}
void popElement( const char* name ){
ASSERT_MESSAGE( string_equal( name, "entity" ), PARSE_ERROR );
NodeSmartReference entity( m_entityTable.createEntity( GlobalEntityClassManager().findOrInsert( Node_getEntity( node() )->getKeyValue( "classname" ), node_is_group( node() ) ) ) );
{
EntityCopyingVisitor visitor( *Node_getEntity( entity ) );
Node_getEntity( node() )->forEachKeyValue( visitor );
}
if ( Node_getTraversable( entity ) != 0 && !Node_getEntity( entity )->getEntityClass().fixedsize ) {
parentBrushes( node(), entity );
}
Node_getTraversable( m_parent )->insert( entity );
destructor( primitive() );
destructor( node() );
}
slab*
ObjectCache::InitSlab(slab* slab, void* pages, size_t byteCount, uint32 flags)
{
TRACE_CACHE(this, "construct (%p, %p .. %p, %lu)", slab, pages,
((uint8*)pages) + byteCount, byteCount);
slab->pages = pages;
slab->count = slab->size = byteCount / object_size;
slab->free = NULL;
size_t spareBytes = byteCount - (slab->size * object_size);
if ((this->flags & CACHE_ALIGN_ON_SIZE) != 0) {
slab->offset = cache_color_cycle;
if (slab->offset > spareBytes)
cache_color_cycle = slab->offset = 0;
else
cache_color_cycle += kCacheColorPeriod;
} else
slab->offset = 0;
TRACE_CACHE(this, " %lu objects, %lu spare bytes, offset %lu",
slab->size, spareBytes, slab->offset);
uint8* data = ((uint8*)pages) + slab->offset;
CREATE_PARANOIA_CHECK_SET(slab, "slab");
for (size_t i = 0; i < slab->size; i++) {
status_t status = B_OK;
if (constructor)
status = constructor(cookie, data);
if (status != B_OK) {
data = ((uint8*)pages) + slab->offset;
for (size_t j = 0; j < i; j++) {
if (destructor)
destructor(cookie, data);
data += object_size;
}
DELETE_PARANOIA_CHECK_SET(slab);
return NULL;
}
_push(slab->free, object_to_link(data, object_size));
ADD_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, slab,
&object_to_link(data, object_size)->next, sizeof(void*));
data += object_size;
}
return slab;
}
/**
* @brief Destroy a List Element
* @param elt The element to destroy
* @param destructor The Destructor Function to clean Element Item (can be NULL)
*/
static void wbxml_elt_destroy(WBXMLListElt *elt, WBXMLListEltCleaner *destructor)
{
if (elt == NULL)
return;
if (destructor != NULL)
destructor(elt->item);
wbxml_free(elt);
}
void
_thread_cleanupspecific(void)
{
struct pthread *curthread = _get_curthread();
const_key_destructor_t destructor;
const void *data = NULL;
int key;
int i;
if (curthread->specific == NULL)
return;
/* Lock the key table: */
THR_LOCK_ACQUIRE(curthread, &_keytable_lock);
for (i = 0; (i < PTHREAD_DESTRUCTOR_ITERATIONS) &&
(curthread->specific_data_count > 0); i++) {
for (key = 0; (key < PTHREAD_KEYS_MAX) &&
(curthread->specific_data_count > 0); key++) {
destructor = NULL;
if (_thread_keytable[key].allocated &&
(curthread->specific[key].data != NULL)) {
if (curthread->specific[key].seqno ==
_thread_keytable[key].seqno) {
data = curthread->specific[key].data;
destructor = (const_key_destructor_t)
_thread_keytable[key].destructor;
}
curthread->specific[key].data = NULL;
curthread->specific_data_count--;
}
/*
* If there is a destructore, call it
* with the key table entry unlocked:
*/
if (destructor != NULL) {
/*
* Don't hold the lock while calling the
* destructor:
*/
THR_LOCK_RELEASE(curthread, &_keytable_lock);
destructor(data);
THR_LOCK_ACQUIRE(curthread, &_keytable_lock);
}
}
}
THR_LOCK_RELEASE(curthread, &_keytable_lock);
free(curthread->specific);
curthread->specific = NULL;
if (curthread->specific_data_count > 0)
stderr_debug("Thread %p has exited with leftover "
"thread-specific data after %d destructor iterations\n",
curthread, PTHREAD_DESTRUCTOR_ITERATIONS);
}
void popElement( const char* name ){
if ( string_equal( name, "epair" ) ) {
}
else
{
m_importer->popElement( name );
destructor( subprimitive() );
m_importer = 0;
}
}
SceneGraph::~SceneGraph()
{
/* User destructor(s) */
if( destructor ) {
destructor(destructor_context);
}
/* Delete Frames */
for( auto &pair : frame_map ) delete pair.second;
/* Delete Limits */
for( auto &pair : limits_map ) free(pair.second);
}
void
pthread_exit(void *value_ptr) {
struct __cleanup_handler *handler;
int loop, again;
volatile struct _thread_local_storage *tls = LIBC_TLS();
// Disable pthread_cancel and set cancel type to deferred
atomic_set(&tls->__flags, PTHREAD_CANCEL_DISABLE);
atomic_clr(&tls->__flags, PTHREAD_CANCEL_ASYNCHRONOUS); /* make defered */
// call the cleanup handlers
while((handler = tls->__cleanup)) {
tls->__cleanup = handler->__next;
handler->__routine(handler->__save);
}
// Call the thread_specific_data destructor functions
for(loop = 0, again = 1; again && loop < PTHREAD_DESTRUCTOR_ITERATIONS; loop++) {
int i;
int num;
again = 0;
num = min(tls->__numkeys, _key_count);
for(i = 0; i < num; i++) {
void *data;
void (*destructor)(void *);
if((destructor = _key_destructor[i]) && (destructor != _KEY_NONE) && (data = tls->__keydata[i])) {
// Setting the data to NULL was the intention of the POSIX
// committe, but did not make it into the POSIX spec. Doing
// this still keeps our implementation POSIX complient, but
// allow non-POSIX complient applications to be more efficient.
tls->__keydata[i] = 0;
destructor(data);
again = 1;
}
}
}
// Unlock hanging file mutexes before exiting
_Unlockfilemtx();
// Unlock hanging system mutexes before exiting
_Unlocksysmtx();
(void)ThreadDestroy_r(0, -1, value_ptr);
#ifdef __GNUC__
for( ;; ) ; /* Get gcc to shut up about a noreturn function returning */
#endif
}
void sf_list_destroy(struct sf_list *l, sf_list_destructor_t *destructor) {
struct sf_list_node *node;
while (l->nelts) {
node = l->head->next;
if (destructor) {
destructor(node->elt);
}
remove_node(node);
free(node);
--l->nelts;
}
free(l);
}
GLXOSD::~GLXOSD() {
for_each(pluginDestructors->begin(), pluginDestructors->end(),
[this](PluginDestructor destructor) {
destructor(this);
});
delete configurationManager;
for_each(pluginSharedObjectHandles->begin(),
pluginSharedObjectHandles->end(), [](void* handle) {
dlclose(handle);
});
delete pluginSharedObjectHandles;
delete pluginDataProviders;
delete drawableHandlers;
glxosdInstance = nullptr;
}
// Given the (data) address of an array, the number of elements, and the
// size of its elements, call the given destructor on each element. If the
// destructor throws an exception, call terminate(). The destructor pointer
// may be NULL, in which case this routine does nothing.
_LIBCXXABI_FUNC_VIS void __cxa_vec_cleanup(void *array_address,
size_t element_count,
size_t element_size,
void (*destructor)(void *)) {
if ( NULL != destructor ) {
char *ptr = static_cast <char *> (array_address);
size_t idx = element_count;
st_terminate exception_guard;
ptr += element_count * element_size; // one past the last element
while ( idx-- > 0 ) {
ptr -= element_size;
destructor ( ptr );
}
exception_guard.release (); // We're done!
}
}
void list_destroy(List *list, list_item_destructor_t *destructor)
{
void *item;
if (list == NULL)
return;
if (destructor != NULL) {
while ((item = list_extract_first(list)) != NULL)
destructor(item);
}
mutex_destroy(list->permanent_lock);
mutex_destroy(list->single_operation_lock);
pthread_cond_destroy(&list->nonempty);
gw_free(list->tab);
gw_free(list);
}
void DecorationRegistry::construct(DecorationContainer* decorable) const {
auto iter = _decorationInfo.cbegin();
try {
for (; iter != _decorationInfo.cend(); ++iter) {
iter->constructor(decorable->getDecoration(iter->descriptor));
}
} catch (...) {
try {
while (iter != _decorationInfo.cbegin()) {
--iter;
iter->destructor(decorable->getDecoration(iter->descriptor));
}
} catch (...) {
std::terminate();
}
throw;
}
}
struct sk_buff *__skb_try_recv_from_queue(struct sock *sk,
struct sk_buff_head *queue,
unsigned int flags,
void (*destructor)(struct sock *sk,
struct sk_buff *skb),
int *peeked, int *off, int *err,
struct sk_buff **last)
{
bool peek_at_off = false;
struct sk_buff *skb;
int _off = 0;
if (unlikely(flags & MSG_PEEK && *off >= 0)) {
peek_at_off = true;
_off = *off;
}
*last = queue->prev;
skb_queue_walk(queue, skb) {
if (flags & MSG_PEEK) {
if (peek_at_off && _off >= skb->len &&
(_off || skb->peeked)) {
_off -= skb->len;
continue;
}
if (!skb->len) {
skb = skb_set_peeked(skb);
if (unlikely(IS_ERR(skb))) {
*err = PTR_ERR(skb);
return NULL;
}
}
*peeked = 1;
refcount_inc(&skb->users);
} else {
__skb_unlink(skb, queue);
if (destructor)
destructor(sk, skb);
}
*off = _off;
return skb;
}
return NULL;
}
int main(int argc, char* argv[])
{
assert(argc == REQUIRED_ARGUMENTS_NUMBER);
//the std::vector which will hold the songs
std::vector<Song*> songCollection;
std::map<std::string, GradingCategory*> gradersCollection;
std::ifstream processedFile;
for(int i = 1; i < argc; i ++)
{
std::string filePath = argv[i];
processedFile.open(filePath, std::ifstream::in);
if(processedFile.is_open())
{
switch(i)
{
case (SONGS_FILE_ARGV_INDX): //songs data file
SongParser::initillizer();
songCollection = SongParser::parseSong(processedFile);
break;
case (LEARNED_PARAM_FILE_ARGV_INDX):
ParametersParser::getInstance();
gradersCollection = ParametersParser::_parseParameterFile(processedFile);
break;
case (QUERIES_FILE_ARGV_INDX):
SongGrader::getSongGraderInstance();
SongGrader::parseQueryFile(processedFile);
SongGrader::runGrading(songCollection, gradersCollection);
break;
}
processedFile.close();
}
else
{
fileLoadFailure();
break;
}
}
destructor(songCollection, gradersCollection);
return 0;
}