/** set the first half face handle of the hedron */ void TopologyKernel::set_first_half_face_handle(const HedronHandle & _hh, const HalfFaceHandle & _hfh) { if (is_valid_handle(_hh) && is_valid_handle(_hfh)) { hedrons_[_hh].hfh_ = _hfh; } }
/** check if the input half face has opposite half face */ bool TopologyKernel::has_opposite_half_face(const HalfFaceHandle & _hfh) const { if (is_valid_handle(_hfh)) { return (is_valid_handle(half_face(_hfh).opp_hfh_)); } return false; }
/** check if the input half edge has opposite half edge */ bool TopologyKernel::has_opposite_half_edge(const HalfEdgeHandle & _heh) const { if (is_valid_handle(_heh)) { return (is_valid_handle(half_edge(_heh).opp_heh_)); } return false; }
/** set the opposite half edge handle */ void TopologyKernel::set_ccw_opposite_half_edge(const HalfEdgeHandle & _heh, const HalfEdgeHandle & _ohfh, bool _double /* = true */) { if (is_valid_handle(_heh)) { half_edge(_heh).opp_heh_ = _ohfh; } if (is_valid_handle(_ohfh) && _double) { half_edge(_ohfh).opp_heh_ = _heh; } }
/** set the opposite half face handle */ void TopologyKernel::set_opposite_half_face(const HalfFaceHandle & _hfh, const HalfFaceHandle & _ohfh, bool _double /* = true */) { if (is_valid_handle(_hfh)) { half_face(_hfh).opp_hfh_ = _ohfh; } if (is_valid_handle(_ohfh) && _double) { half_face(_ohfh).opp_hfh_ = _hfh; } }
bool zz_thread::thread_start () { #ifdef ZZ_MULTI_THREAD if (is_valid_handle(handle_)) return true; handle_ = (HANDLE)_beginthreadex(NULL, 0, call_thread_proc , (void*)this, 0, (unsigned int*)&thread_id_); assert(is_valid_handle(handle_)); return is_valid_handle(handle_); #else return false; #endif }
/****************************************************************************** * release_handle * * Releases resources occupied by the specified handle in the given table. * The reference count of the handled object is decremented. If it becomes * zero and if the 'destructor' function pointer member is non NULL, the * destructor function will be called. Note that release_handle does not * release resources other than the handle itself. If this is wanted, do it * in the destructor function. * * PARAMS * lpTable [I] Pointer to the handle table, from which a handle is to be * released. * handle [I] The handle, which is to be released * dwType [I] Identifier for the type of the object, for which a handle is * to be released. * * RETURNS * non zero, if successful * zero, if not successful (invalid handle) */ int release_handle(HANDLETABLE *lpTable, unsigned int handle, DWORD dwType) { unsigned int index = HANDLE2INDEX(handle); OBJECTHDR *pObject; int ret = 0; TRACE("(lpTable=%p, hande=%d)\n", lpTable, handle); EnterCriticalSection(&lpTable->mutex); if (!is_valid_handle(lpTable, handle, dwType)) goto exit; pObject = lpTable->paEntries[index].pObject; if (InterlockedDecrement(&pObject->refcount) == 0) { TRACE("destroying handle %d\n", handle); if (pObject->destructor) pObject->destructor(pObject); } lpTable->paEntries[index].pObject = NULL; lpTable->paEntries[index].iNextFree = lpTable->iFirstFree; lpTable->iFirstFree = index; ret = 1; exit: LeaveCriticalSection(&lpTable->mutex); return ret; }
/** set the half face handle for half edge */ void TopologyKernel::set_half_face(const HalfEdgeHandle & _heh, const HalfFaceHandle & _hfh) { if (is_valid_handle(_heh)) { half_edge(_heh).fh_ = _hfh; } }
void GLMeshRendererFactory::free_mesh_renderer(RendererHandle handle) { // Invalid handle, nothing to free if (!is_valid_handle(handle)) return; if (renderers_[handle]) // valid non-null renderer, needs to be freed { delete renderers_[handle]; renderers_[handle] = NULL; if (renderers_for_vpm_[handle]) { delete renderers_for_vpm_[handle]; renderers_for_vpm_[handle] = NULL; } if (meshes_[handle]) { delete meshes_[handle]; meshes_[handle] = NULL; } free_handles_.push_back(handle); } }
/** set the half edge handle for vertex */ void TopologyKernel::set_vertex_half_edge(const VertexHandle & _vh, const HalfEdgeHandle & _heh) { if (is_valid_handle(_vh)) { vertex(_vh).heh_ = _heh; } }
IMeshRenderer* GLMeshRendererFactory::get_renderer(RendererHandle handle) { if (!is_valid_handle(handle)) return NULL; else return renderers_[handle]; }
/** retrieve the half face handle of a half edge */ HalfFaceHandle TopologyKernel::half_face_handle(const HalfEdgeHandle & _heh) const { if (is_valid_handle(_heh)) { return half_edge(_heh).fh_; } return HalfFaceHandle(-1); }
bool zz_thread::thread_resume () { #ifdef ZZ_MULTI_THREAD if (!is_valid_handle(handle_)) return false; // not started return (::ResumeThread(handle_) != ((DWORD)-1)); #else return false; #endif }
void tmout_destroy (timeout_t handle) { assert (is_valid_handle (handle)); dtable_remove ((void **)&table_, &table_used_, handle, (unused_setter_t)set_unused); }
/** retrieve the opposite half edge handle */ HalfEdgeHandle TopologyKernel::ccw_opp_half_edge_handle(const HalfEdgeHandle & _heh) const { if (is_valid_handle(_heh)) { return half_edge(_heh).opp_heh_; } return HalfEdgeHandle(-1); }
/* * execute the 'index' procedure */ int sblib_proc_exec(int index, int param_count, slib_par_t *params, var_t *retval) { int success = 0; int handle; switch ( index ) { case 0: // GDBM_CLOSE handle success = mod_parint(0, params, param_count, &handle); if ( success ) { if ( is_valid_handle(handle) ) { gdbm_close(table[handle].dbf); table[handle].dbf = NULL; success = 1; } else { success = 0; v_setstr(retval, "GDBM_CLOSE: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_CLOSE: argument error"); break; case 1: // GDBM_SYNC handle success = mod_parint(0, params, param_count, &handle); if ( success ) { if ( is_valid_handle(handle) ) { gdbm_sync(table[handle].dbf); success = 1; } else { success = 0; v_setstr(retval, "GDBM_SYNC: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_SYNC: argument error"); break; default: v_setstr(retval, "GDBM: procedure does not exist!"); } return success; }
/** retrieve the half edge handle of a vertex */ HalfEdgeHandle TopologyKernel::half_edge_handle(const VertexHandle & _vh) const { if (is_valid_handle(_vh)) { return vertex(_vh).heh_; } return HalfEdgeHandle(-1); }
/** set the start vertex of a half edge */ void TopologyKernel::set_start_vertex(const HalfEdgeHandle & _heh, const VertexHandle & _vh) { if (is_valid_handle(_heh)) { half_edge(_heh).vh_ = _vh; } }
void tmout_start (timeout_t handle) { struct timeout *tmout; assert (is_valid_handle (handle)); tmout = &(table_[handle]); crono_start (&(tmout->to_crono)); }
void tmout_set (timeout_t handle, const struct timeval *max) { struct timeout *tmout; assert (is_valid_handle (handle)); assert (max != NULL); tmout = &(table_[handle]); memcpy (&(tmout->to_maxval), max, sizeof(*max)); }
MatchErrorCode MatchTableAbstract::query_counters(entry_handle_t handle, counter_value_t *bytes, counter_value_t *packets) const { ReadLock lock = lock_read(); if(!with_counters) return MatchErrorCode::COUNTERS_DISABLED; if(!is_valid_handle(handle)) return MatchErrorCode::INVALID_HANDLE; const MatchUnit::EntryMeta &meta = match_unit_->get_entry_meta(handle); // should I hide counter implementation more? meta.counter.query_counter(bytes, packets); return MatchErrorCode::SUCCESS; }
void win_file_event::shutdown() { LOG_COMP_TRACE_FUNCTION(win_file_event); if(is_valid_handle(change_handle_)) { LOG_COMP_NOTICE(win_file_event, "shutting down event notifications"); terminated_ = true; ::FindCloseChangeNotification(change_handle_); change_handle_ = INVALID_HANDLE_VALUE; } }
void tmout_print (timeout_t handle) { struct timeout *tmout; assert (is_valid_handle (handle)); tmout = &(table_[handle]); printf ("at "); crono_print (&(tmout->to_crono)); printf (" max "); tv_print (&(tmout->to_maxval)); }
bool tmout_left (timeout_t handle, struct timeval *result) { struct timeval elapsed; struct timeval left; struct timeout *tmout; assert (is_valid_handle (handle)); tmout = &(table_[handle]); crono_measure (&(tmout->to_crono), &elapsed); tv_diff (&left, &(tmout->to_maxval), &elapsed); if (result) memcpy (result, &left, sizeof(*result)); if (tv_cmp (&left, &time_0ms) <= 0) return FALSE; return TRUE; }
/****************************************************************************** * lookup_handle * * Returns the object identified by the handle in the given handle table * * PARAMS * lpTable [I] Pointer to the handle table, in which the handle is looked up. * handle [I] The handle, which is to be looked up * lplpObject [O] Pointer to the variable, into which the pointer to the * object looked up is copied. * RETURNS * non zero, if successful * zero, if not successful (invalid handle) */ int lookup_handle(HANDLETABLE *lpTable, unsigned int handle, DWORD dwType, OBJECTHDR **lplpObject) { int ret = 0; TRACE("(lpTable=%p, handle=%d, lplpObject=%p)\n", lpTable, handle, lplpObject); EnterCriticalSection(&lpTable->mutex); if (!is_valid_handle(lpTable, handle, dwType)) { *lplpObject = NULL; goto exit; } *lplpObject = lpTable->paEntries[HANDLE2INDEX(handle)].pObject; ret = 1; exit: LeaveCriticalSection(&lpTable->mutex); return ret; }
void win_file_event::initialize() { LOG_COMP_TRACE_FUNCTION(win_file_event); if(!is_valid_handle(change_handle_)) { LOG_COMP_NOTICE(win_file_event, "initializing event notifications"); terminated_ = false; std::string const path = util::path::remove_filespec(file_.filename()); change_handle_ = ::FindFirstChangeNotificationA(path.c_str(), FALSE, FILE_NOTIFY_CHANGE_SIZE); if(INVALID_HANDLE_VALUE == change_handle_) { throw std::runtime_error(util::win::error_to_string("FindFirstChangeNotification", ::GetLastError())); } } }
/* * execute the 'index' function */ int sblib_func_exec(int index, int param_count, slib_par_t *params, var_t *retval) { int success = 0; switch ( index ) { case 0: // handle <- GDBM_OPEN(file[, block_size, flags, mode]) { char *file; int bsize, flags, mode; success = mod_parstr_ptr(0, params, param_count, &file); success = mod_opt_parint(1, params, param_count, &bsize, 0); success = mod_opt_parint(2, params, param_count, &flags, GDBM_WRCREAT); success = mod_opt_parint(3, params, param_count, &mode, 0666); if ( success ) { int handle; handle = get_free_handle(); if ( handle >= 0 ) { table[handle].dbf = gdbm_open(file, bsize, flags, mode, NULL); success = (table[handle].dbf != NULL); if ( success ) v_setint(retval, handle); else v_setstr(retval, gdbm_strerror(gdbm_errno)); } else { success = 0; v_setstr(retval, "GDBM_OPEN: NO FREE HANDLES"); } } else v_setstr(retval, "GDBM_OPEN: argument error"); } break; case 1: // handle <- GDBM_STORE(handle, key, data [, flags]) { int handle, flags; char *key, *data; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); success = mod_parstr_ptr(2, params, param_count, &data); success = mod_opt_parint(3, params, param_count, &flags, GDBM_REPLACE); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key, dt_data; int r; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; dt_data.dptr = data; dt_data.dsize = strlen(data) + 1; r = gdbm_store(table[handle].dbf, dt_key, dt_data, flags); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_STORE: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_STORE: argument error"); } break; case 2: // data <- GDBM_FETCH(handle, key) { int handle; char *key; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key, dt_data; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; dt_data = gdbm_fetch(table[handle].dbf, dt_key); v_setstr(retval, (char *) dt_data.dptr); success = 1; } else { success = 0; v_setstr(retval, "GDBM_FETCH: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_FETCH: argument error"); } break; case 3: // status <- GDBM_DELETE(handle, key) { int handle; char *key; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key; int r; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; r = gdbm_delete(table[handle].dbf, dt_key); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_DELETE: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_DELETE: argument error"); } break; case 4: // key <- GDBM_FIRSTKEY(handle) { int handle; success = mod_parint (0, params, param_count, &handle); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key; dt_key = gdbm_firstkey(table[handle].dbf); v_setstr(retval, (char *) dt_key.dptr); success = 1; } else { success = 0; v_setstr(retval, "GDBM_FIRSTKEY: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_FIRSTKEY: argument error"); } break; case 5: // key <- GDBM_NEXTKEY(handle, key) { int handle; char *key; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; dt_key = gdbm_nextkey(table[handle].dbf, dt_key); v_setstr(retval, (char *) dt_key.dptr); success = 1; } else { success = 0; v_setstr(retval, "GDBM_NEXTKEY: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_NEXTKEY: argument error"); } break; case 6: // status <- GDBM_REORGANIZE(handle) { int handle; success = mod_parint (0, params, param_count, &handle); if ( success ) { if ( is_valid_handle(handle) ) { int r; r = gdbm_reorganize(table[handle].dbf); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_REORGANIZE: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_REORGANIZE: argument error"); } break; case 7: // status <- GDBM_EXISTS(handle, key) { int handle; char *key; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key; int r; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; r = gdbm_exists(table[handle].dbf, dt_key); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_EXISTS: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_EXISTS: argument error"); } break; case 8: // str <- GDBM_STRERROR() v_setstr(retval, gdbm_strerror(gdbm_errno)); break; case 9: // status <- GDBM_SETOPT(handle, option, value, size) { int handle, option, value, size; success = mod_parint (0, params, param_count, &handle); success = mod_parint (1, params, param_count, &option); success = mod_parint (2, params, param_count, &value); success = mod_parint (3, params, param_count, &size); if ( success ) { if ( is_valid_handle(handle) ) { int r; r = gdbm_setopt(table[handle].dbf, option, &value, size); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_SETOPT: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_SETOPT: argument error"); } break; case 10: // status <- GDBM_FDESC(handle) { int handle; success = mod_parint (0, params, param_count, &handle); if ( success ) { if ( is_valid_handle(handle) ) { int r; r = gdbm_fdesc(table[handle].dbf); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_FDESC: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_FDESC: argument error"); } break; default: v_setstr(retval, "GDBM: function does not exist!"); } return success; }
GLMeshRendererFactory::RendererHandle GLMeshRendererFactory::new_mesh_renderer(const std::string& filename, GLsizei viewport_width, GLsizei viewport_height) { // Get an available handle RendererHandle handle = get_next_avail_handle(); // No more free handles, do not create the object if (!is_valid_handle(handle)) return handle; if (filename.rfind(".vpm") != std::string::npos) { ViewDependentProgressiveMesh* mesh = NULL; GLMeshRendererES1* renderer = NULL; GLVpmMeshRenderer* result = NULL; try { mesh = new ViewDependentProgressiveMesh(filename); renderer = new GLMeshRendererES1(viewport_width, viewport_height); result = new GLVpmMeshRenderer(*renderer, mesh); } catch (MobiMeshException& ex) { if (mesh) delete mesh; if (renderer) delete renderer; if (result) delete result; throw UnableToCreateRendererException(ex.what()); } renderers_[handle] = result; renderers_for_vpm_[handle] = renderer; meshes_[handle] = mesh; } else if (filename.rfind( ".pm") != std::string::npos) { ProgressiveMesh* mesh = NULL; GLMeshRendererES1* renderer = NULL; try { mesh = new ProgressiveMesh(filename); renderer = new GLMeshRendererES1(mesh, viewport_width, viewport_height); } catch (MobiMeshException& ex) { if (mesh) delete mesh; if (renderer) delete renderer; throw UnableToCreateRendererException(ex.what()); } renderers_[handle] = renderer; meshes_[handle] = mesh; } else if (filename.rfind(".tvpm") != std::string::npos) { TrulyViewDependentPM* mesh = NULL; GLMeshRendererES1* renderer = NULL; GLTvpmMeshRenderer* result = NULL; try { if (filename.rfind(".tvpm64") != std::string::npos) mesh = new TrulyViewDependentPM64(filename); else mesh = new TrulyViewDependentPM32(filename); renderer = new GLMeshRendererES1(viewport_width, viewport_height); result = new GLTvpmMeshRenderer(*renderer, mesh); } catch (MobiMeshException& ex) { if (mesh) delete mesh; if (renderer) delete renderer; if (result) delete result; throw UnableToCreateRendererException(ex.what()); } renderers_[handle] = result; renderers_for_vpm_[handle] = renderer; meshes_[handle] = mesh; } else { throw InvalidMeshTypeException("filename must end with .vpm, .pm, " ".tvpm, or .tvpm64"); } use_next_avail_handle(); return handle; }
/** check if the input half face has opposite half face */ bool TopologyKernel::has_opposite_half_face(const HalfFace & _hf) const { return (is_valid_handle(_hf.opp_hfh_)); }
/** check if the input half edge has opposite half edge */ bool TopologyKernel::has_opposite_half_edge(const HalfEdge & _he) const { return (is_valid_handle(_he.opp_heh_)); }