int find(poly_t *p, double r[]) { int k; while (p->n > 0 && iszero(p->a[p->n])) p->n--; if (p->n == 0) { r[0] = 0; return 1; } if (p->n == 1) { r[0] = -(p->a[0] / p->a[1]); return 1; } if (p->n == 2) { double t; t = p->a[1] * p->a[1] - 4. * p->a[0] * p->a[2]; t = (t < 0.) ? 0. : sqrt(t); r[0] = (-p->a[1] + t) / (2. * p->a[2]); r[1] = (-p->a[1] - t) / (2. * p->a[2]); return 2; } if ((k = bis(p, r)) > 0) return k; return 0; }
int main(int argc,char** argv){ if (argc!=4) { std::cerr << "Usage: " << argv[0] << " -estremo a- -estremo b- -precisione-"<<std::endl; return -1; } int npassi = 300; double a=atof(argv[1]); double b=atof(argv[2]); double prec=atof(argv[3]); if(a>b){ double c=a; a=b; b=c; } Parabola p(3,5,-2); Retta r(1, 1); Bisezione bis(npassi); double zero=bis.Precision(prec).CercaZeri(a,b,&p); if(bis.Trovato()) { std::cout << "Zero trovato in: " << std::fixed << std::setprecision(-log10(prec)) << zero << std::endl; std::cout << "in " << bis.Steps() << " passi, con un'incertezza di ±" << bis.Incertezza() << std::endl; std::cout << "la precisione richiesta era " << prec << std::endl; } else std::cerr << "Non è stato possibile trovare uno zero con la precisione richiesta" << std::endl; return 0; }
void MSDevice_Tripinfo::loadState(const SUMOSAXAttributes& attrs) { std::istringstream bis(attrs.getString(SUMO_ATTR_STATE)); bis >> myDepartLane; bis >> myDepartPosLat; bis >> myDepartSpeed; }
void testPLWAH1_2() { vector<vector<int>> sets(SETNUM); int n = dataGen_2(sets); #ifdef TIMING_FOR_PLWAH1 clock_t t1,t2,t3,t4; #endif vector<PLWAH1Set> bis(SETNUM); for(int i=0;i<SETNUM;i++){ bis[i].fromVector(sets[i]); } vector<int> res; #ifdef TIMING_FOR_PLWAH1 t3 = clock(); #endif PLWAH1Set::intersection(bis,res); #ifdef TIMING_FOR_APLWAH t4 = clock(); printf("PLWAH1 Intersection:\n%d Sets, each with %d numbers, Step %d\nResult: %d numbers.\nIntersection Time: %d\n\n",SETNUM,INTNUM,STEP,res.size(),t4-t3); #endif #ifdef NUM_LIST printf("Intersection: "); int max = NUM_LIST < res.size()?NUM_LIST:res.size(); for(int i=0;i<max;i++){ printf(" %d",res[i]); } #endif }
int main(int argc, char* argv[]) { // read the file std::ifstream ifs(argv[1], std::ios::binary); std::string buffer((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>())); if (!buffer.size()) { std::ofstream ofs(argv[2], std::ios::binary); exit(0); } // make Stream std::stringstream ss(buffer); BitInputStream bis(ss); // build tree HCTree hct; hct.build(bis.frequences); bis.size = getSize(hct, bis.frequences); std::ofstream ofs(argv[2], std::ios::binary); // decode int c = hct.decode(bis); int i = 0; while (c >= 0) { ofs << (byte)c; c = hct.decode(bis); } return 0; }
/* * Fill up caching arrays for path and cdpath */ void dohash(char cachearray[]) { struct stat stb; DIR *dirp; struct dirent *dp; int cnt; int i = 0; struct varent *v; tchar **pv; int hashval; tchar curdir_[MAXNAMLEN+1]; #ifdef TRACE tprintf("TRACE- dohash()\n"); #endif /* Caching $path */ if (cachearray == xhash) { havhash = 1; v = adrof(S_path /* "path" */); } else { /* Caching $cdpath */ havhash2 = 1; v = adrof(S_cdpath /* "cdpath" */); } for (cnt = 0; cnt < (HSHSIZ / 8); cnt++) cachearray[cnt] = 0; if (v == 0) { return; } for (pv = v->vec; *pv; pv++, i++) { if (pv[0][0] != '/') continue; dirp = opendir_(*pv); if (dirp == NULL) continue; if (fstat(dirp->dd_fd, &stb) < 0 || !isdir(stb)) { unsetfd(dirp->dd_fd); closedir_(dirp); continue; } while ((dp = readdir(dirp)) != NULL) { if (dp->d_ino == 0) continue; if (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' || dp->d_name[1] == '.' && dp->d_name[2] == '\0')) continue; hashval = hash(hashname(strtots(curdir_, dp->d_name)), i); bis(cachearray, hashval); } unsetfd(dirp->dd_fd); closedir_(dirp); } }
void protein_load_truth_data_from_file(std::string fname, protein_truth_asg_type& truth_asgs) { binary_input_stream bis(fname.c_str()); size_t num_vertices = bis.read<int>(); truth_asgs.resize(num_vertices); foreach(protein_asg_set_type& asgs, truth_asgs) { size_t valid_assignments = bis.read<int>(); assert(valid_assignments > 0); for(size_t i = 0; i < valid_assignments; ++i) { size_t asg = bis.read<int>(); asgs.insert(asg); } }
int main( int argc, char *argv[] ) { if( argc != 3 ) { cerr << "Invalid number of arguments.\n"; return EXIT_FAILURE; } ifstream fin; ofstream fout; fin.open( argv[1], ios::binary ); /* Check to see if the input file opened correctly. */ if( !fin.is_open() ) { return EXIT_FAILURE; } vector<int> freqs( 256, 0 ); int fsize = 0; HCTree hufftree; fin.clear(); /* Read in the header. */ for( size_t i = 0; i < freqs.size(); ++i ) { fin.read( (char *) &freqs[i], sizeof( int ) ); fsize += freqs[i]; } /* Build the Huffman tree. */ if( fsize != 0 ) { hufftree.build( freqs ); } fout.open( argv[2], ios::binary ); BitInputStream bis( fin ); byte tmp = 0; for( int i = 0; i < fsize; ++i ) { tmp = hufftree.decode( bis ); fout.write( (char *) &tmp, 1); } fin.close(); fout.close(); return EXIT_SUCCESS; }
int main(int argc,char** argv){ double prec = 1e-6; Buca bu(0); FunzioneBase* t = &(bu); Bisezione bis(3000); bis.Precision(prec); double a, b, zero; for (int i=0;i<21;++i){ a=i*M_PI; b=i*M_PI+M_PI/2; zero = bis.CercaZeri(a,b,&bu); std::cout << std::fixed << "Zero trovato: " << std::setprecision(-log10(prec)) << zero << " nell'intervallo ["<<a<<","<<b<<"]"<<std::endl; } return 0; }
void PopPredict::LoadModel() { Log::I("recsys", "PopPredict::LoadModel()"); BinaryInputStream bis(mModelFilepath); int numItem; bis >> numItem; assert(numItem == mTrainData->NumItem()); mItemAverages.resize(numItem); bis.Read(mItemAverages.data(), mItemAverages.size()); mItemPopularities.resize(numItem); bis.Read(mItemPopularities.data(), mItemPopularities.size()); int numUser; bis >> numUser; assert(numUser == mTrainData->NumUser()); mUserAverages.resize(numUser); bis.Read(mUserAverages.data(), mUserAverages.size()); }
void robust::solve(real a, real b){ real tol_bis = cfratio * tol; bisection bis(f,tol_bis,maxit/2,criteria); bis.solve(a,b); real x_d=bis.get_result(); newton nwt(f,fprime,tol,maxit/2,criteria); nwt.solve(x_d); alpha=nwt.get_result(); done=true; nit_coarse=bis.get_iter(); nit=nwt.get_iter(); return; }
/*---------------------------------------------------------------------- | main +---------------------------------------------------------------------*/ int main(int /*argc*/, char** /*argv*/) { // setup debugging #if defined(_DEBUG) && defined(WIN32) int flags = _crtDbgFlag | _CRTDBG_ALLOC_MEM_DF | _CRTDBG_DELAY_FREE_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF; _CrtSetDbgFlag(flags); //AllocConsole(); //freopen("CONOUT$", "w", stdout); #endif #if 0 const char* b0 = ""; const char* b1 = "\n"; const char* b2 = "\r"; const char* b3 = "\r\n"; const char* b4 = "0\r1\r\r2\r\r\r" // only \r, up to 3 "3\n4\n\n5\n\n\n" // only \n, up to 3 "6\r\n7\n\r" // one \r and one \n "8\r\n\r9\r\r\na\n\r\r" // two \r and one \n "b\n\r\nc\n\n\rd\r\n\n" // two \n and one \r ; const char* b5 = "aaa\r"; const char* b6 = "aaa\n"; const char* b7 = "aaa\r\n"; printf("BufferedInputStream test1 passed\n"); #endif NPT_InputStreamReference isr1(new NPT_MemoryStream("0123456789", 10)); NPT_BufferedInputStream bis(isr1, 3); char buffer[256]; NPT_Result result = bis.ReadLine(buffer, 2); CHECK(result == NPT_ERROR_NOT_ENOUGH_SPACE); return 0; }
void /*ARGSUSED*/ dohash(Char **v, struct command *t) { struct dirent *dp; struct varent *pathv; DIR *dirp; Char **pv; size_t cnt; int hashval, i; i = 0; havhash = 1; pathv = adrof(STRpath); for (cnt = 0; cnt < sizeof xhash; cnt++) xhash[cnt] = 0; if (pathv == 0) return; for (pv = pathv->vec; *pv; pv++, i++) { if (pv[0][0] != '/') continue; dirp = opendir(short2str(*pv)); if (dirp == NULL) continue; while ((dp = readdir(dirp)) != NULL) { if (dp->d_ino == 0) continue; if (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' || (dp->d_name[1] == '.' && dp->d_name[2] == '\0'))) continue; hashval = hash(hashname(str2short(dp->d_name)), i); bis(xhash, hashval); /* tw_add_comm_name (dp->d_name); */ } (void) closedir(dirp); } }
int main() { int x = 0x98FDECBA; int temp = x; mask_height_bit((byte_pointer)&temp, sizeof(x)); printf("reset all bit without least:%x\n", temp); int temp1 = x; complement_least((byte_pointer)&temp1); printf("complement least without other:%x\n", temp1); int temp2 = x; reset_least((byte_pointer)&temp2); printf("reset least bit without other:%x\n", temp2); int temp3 = bis(0x0000000, 31); printf("0 after bis operator:%08x\n", temp3); int temp4 = bic(0x80000000, 31); printf("0 after bic operator:%08x\n", temp4); return 0; }
NDIS_STATUS xmpSetInformation( IN xmpNicCtx_t *pNicCtx, IN PNDIS_OID_REQUEST NdisRequest ) { NDIS_STATUS Status = NDIS_STATUS_SUCCESS; NDIS_OID Oid; PVOID InformationBuffer; ULONG InformationBufferLength; ULONG BytesRead; ULONG BytesNeeded; ULONG PacketFilter; ULONG MCastCnt; ULONG HashType; ULONG validBits; USHORT i; xge_hal_device_t *pHalDev; NDIS_RECEIVE_SCALE_PARAMETERS *pRssParam; xmpSetRssContext SetRssCtx = {0}; static ULONG setRssCount = 10; pHalDev = XMP_NIC_GET_DEV(pNicCtx); Oid = NdisRequest->DATA.SET_INFORMATION.Oid; InformationBuffer = NdisRequest->DATA.SET_INFORMATION.InformationBuffer; InformationBufferLength = NdisRequest->DATA.SET_INFORMATION.InformationBufferLength; XMPTRACE(XMP_DBG_REQ, ("==> xmpSetInformation %x\n", Oid)); BytesRead = 0; BytesNeeded = 0; switch(Oid) { case OID_802_3_MULTICAST_LIST: XMPTRACE(XMP_DBG_REQ, ("xmpSetInformation Multicast list\n")); if ( InformationBufferLength % ETH_LENGTH_OF_ADDRESS != 0 ) return(NDIS_STATUS_INVALID_LENGTH); MCastCnt = InformationBufferLength / ETH_LENGTH_OF_ADDRESS; xmpHalMcastFilterClr(pNicCtx); Status = xmpHalSetMcastList(pNicCtx, (UCHAR *) InformationBuffer, &MCastCnt); BytesRead = MCastCnt * ETH_LENGTH_OF_ADDRESS; break; case OID_GEN_CURRENT_PACKET_FILTER: XMPTRACE(XMP_DBG_REQ, ("xmpSetInformation: packet filter\n")); if ( InformationBufferLength != sizeof (ULONG) ) return ( NDIS_STATUS_INVALID_LENGTH ); BytesRead = InformationBufferLength; PacketFilter = *((PULONG) InformationBuffer); Status = xmpSetFilter(pNicCtx, PacketFilter); break; case OID_GEN_CURRENT_LOOKAHEAD: XMPTRACE(XMP_DBG_REQ, ("xmpSetInformation: current lookahead\n")); if( InformationBufferLength < sizeof(ULONG) ) { BytesNeeded = sizeof(ULONG); Status = NDIS_STATUS_INVALID_LENGTH; break; } pNicCtx->LookAheadSz = *((PULONG) InformationBuffer); BytesRead = sizeof(ULONG); Status = NDIS_STATUS_SUCCESS; break; case OID_GEN_RECEIVE_SCALE_PARAMETERS: XMPTRACE(XMP_DBG_INFO, ("xmpSetInformation: OID_GEN_RECEIVE_SCALE_PARAMETERS\n")); if ( !(XMP_NIC_RSS_IN_CONFIG(pNicCtx)) ) { Status = NDIS_STATUS_NOT_SUPPORTED; break; } if ( InformationBufferLength < sizeof(NDIS_RECEIVE_SCALE_PARAMETERS) ) { BytesNeeded = sizeof(NDIS_RECEIVE_SCALE_PARAMETERS); Status = NDIS_STATUS_INVALID_LENGTH; break; } pRssParam = (PNDIS_RECEIVE_SCALE_PARAMETERS)InformationBuffer; #ifdef NDISTEST_BUG if ( !XENAMP_NDIS_OBJECT_VALID(&pRssParam->Header, NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_1, NDIS_OBJECT_TYPE_RSS_PARAMETERS, sizeof(NDIS_RECEIVE_SCALE_PARAMETERS)) ) { XMPTRACE(XMP_DBG_WRN, ("xmpSetInformation:RSS_PARAMETERS invalid!!" " Revision=%d Type=%d Size=%d\n", pRssParam->Header.Revision, pRssParam->Header.Type, pRssParam->Header.Size)); BytesRead = sizeof(NDIS_OBJECT_HEADER); Status = NDIS_STATUS_INVALID_PARAMETER; break; } #endif BytesRead = sizeof(NDIS_RECEIVE_SCALE_PARAMETERS); if ( (InformationBufferLength < (pRssParam->IndirectionTableSize + pRssParam->IndirectionTableOffset)) || (InformationBufferLength < (pRssParam->HashSecretKeySize + pRssParam->HashSecretKeyOffset)) ) { BytesNeeded = sizeof(NDIS_RECEIVE_SCALE_PARAMETERS); Status = NDIS_STATUS_INVALID_LENGTH; break; } HashType = NDIS_RSS_HASH_TYPE_FROM_HASH_INFO(pRssParam->HashInformation); /*if ( HashType != 0 || NDIS_RSS_HASH_FUNC_FROM_HASH_INFO(pRssParam->HashInformation) != 0) */ validBits = (NDIS_HASH_IPV4 | NDIS_HASH_TCP_IPV4 #ifndef XMP_RSS_IPV4_ONLY | NDIS_HASH_IPV6 | NDIS_HASH_TCP_IPV6 | NDIS_HASH_IPV6_EX | NDIS_HASH_TCP_IPV6_EX #endif ); if ( ((NDIS_RSS_HASH_FUNC_FROM_HASH_INFO(pRssParam->HashInformation) != NdisHashFunctionToeplitz) || /* the only hash function supported */ !bit(HashType, validBits) || /* at least one type should be set */ (HashType & ~validBits)) && /* no other type should be set */ (!(bit(pRssParam->Flags, NDIS_RSS_PARAM_FLAG_DISABLE_RSS)) && NDIS_RSS_HASH_FUNC_FROM_HASH_INFO(pRssParam->HashInformation) != 0) ) { Status = NDIS_STATUS_INVALID_PARAMETER; break; } if ( /*(pRssParam->IndirectionTableSize < (1 << pRssParam->NumberOfLsbs)) || */ (pRssParam->HashSecretKeySize & 0x7) || /* must be 8-bytes align */ (pRssParam->HashSecretKeySize > 40) || /* max secret key size */ (pRssParam->BaseCpuNumber & (pRssParam->BaseCpuNumber - 1)) )/*pow2 */ { XMPTRACE(XMP_DBG_WRN, ("xmpReqSetRss:Invalid settings: Key Size=%d" " IDT size=%d BaseCpu=%d\n", pRssParam->HashSecretKeySize, pRssParam->IndirectionTableSize, pRssParam->BaseCpuNumber)); Status = NDIS_STATUS_INVALID_PARAMETER; break; } if ((pRssParam->IndirectionTableSize + pRssParam->IndirectionTableOffset) > (pRssParam->HashSecretKeySize + pRssParam->HashSecretKeyOffset)) BytesRead = (pRssParam->IndirectionTableSize + pRssParam->IndirectionTableOffset); else BytesRead = (pRssParam->HashSecretKeySize + pRssParam->HashSecretKeyOffset); SetRssCtx.pNicCtx = pNicCtx; SetRssCtx.pParams = pRssParam; #if 0 if(NdisMSynchronizeWithInterruptEx(pNicCtx->hInterrupt, 0, xmpReqSetRss, &SetRssCtx)) #endif if ( NDIS_RSS_HASH_FUNC_FROM_HASH_INFO(pRssParam->HashInformation) == 0 ) bis(pRssParam->Flags, NDIS_RSS_PARAM_FLAG_DISABLE_RSS); if ( bit(pRssParam->Flags, NDIS_RSS_PARAM_FLAG_DISABLE_RSS) ) { pNicCtx->ndisRssSet.size = sizeof(NDIS_RECEIVE_SCALE_PARAMETERS); pNicCtx->ndisRssSet.params.BaseCpuNumber = 0; pNicCtx->ndisRssSet.params.Flags = 0; pNicCtx->ndisRssSet.params.HashInformation = 0; pNicCtx->ndisRssSet.params.IndirectionTableSize = 0; pNicCtx->ndisRssSet.params.IndirectionTableOffset = 0; pNicCtx->ndisRssSet.params.HashSecretKeySize = 0; pNicCtx->ndisRssSet.params.HashSecretKeyOffset = 0; } else { NdisMoveMemory(&pNicCtx->ndisRssSet.params, pRssParam, BytesRead); pNicCtx->ndisRssSet.size = BytesRead; } xmpReqSetRss(pNicCtx); #if 0 if ( !(setRssCount % 10) ) { xmpReqSetRss(pNicCtx); } setRssCount++; #endif Status = NDIS_STATUS_SUCCESS; break; case OID_OFFLOAD_ENCAPSULATION: XMPTRACE(XMP_DBG_OFLD, ("xmpSetInformation: offload encapsulation\n")); if ( InformationBufferLength < sizeof(NDIS_OFFLOAD_ENCAPSULATION) ) { BytesNeeded = sizeof(NDIS_OFFLOAD_ENCAPSULATION); Status = NDIS_STATUS_INVALID_LENGTH; break; } NdisMoveMemory(&pNicCtx->OffloadEncapsulation, InformationBuffer, sizeof(NDIS_OFFLOAD_ENCAPSULATION)); BytesRead = sizeof(NDIS_OFFLOAD_ENCAPSULATION); Status = NDIS_STATUS_SUCCESS; break; case OID_GEN_INTERRUPT_MODERATION: { NDIS_INTERRUPT_MODERATION_PARAMETERS *pIntrModr; if ( InformationBufferLength < sizeof(NDIS_INTERRUPT_MODERATION_PARAMETERS) ) { BytesNeeded = sizeof(NDIS_INTERRUPT_MODERATION_PARAMETERS); Status = NDIS_STATUS_INVALID_LENGTH; break; } pIntrModr = (NDIS_INTERRUPT_MODERATION_PARAMETERS *) InformationBuffer; if ( !XENAMP_NDIS_OBJECT_VALID(&pIntrModr->Header, NDIS_INTERRUPT_MODERATION_PARAMETERS_REVISION_1, NDIS_OBJECT_TYPE_DEFAULT, sizeof(NDIS_INTERRUPT_MODERATION_PARAMETERS)) ) { BytesRead = sizeof(NDIS_OBJECT_HEADER); Status = NDIS_STATUS_INVALID_DATA; break; } break; } case OID_TCP_OFFLOAD_PARAMETERS: { NDIS_OFFLOAD_PARAMETERS *pAdmin; NDIS_STATUS_INDICATION StatusIndication; ULONG size; pAdmin = (NDIS_OFFLOAD_PARAMETERS *) InformationBuffer; if ( InformationBufferLength < NDIS_SIZEOF_OFFLOAD_PARAMETERS_REVISION_1 ) { BytesNeeded = NDIS_SIZEOF_OFFLOAD_PARAMETERS_REVISION_1; Status = NDIS_STATUS_INVALID_LENGTH; break; } if ( !XENAMP_NDIS_OBJECT_VALID(&pAdmin->Header, NDIS_OFFLOAD_PARAMETERS_REVISION_1, NDIS_OBJECT_TYPE_DEFAULT, NDIS_SIZEOF_OFFLOAD_PARAMETERS_REVISION_1 )) { BytesRead = sizeof(NDIS_OBJECT_HEADER); Status = NDIS_STATUS_INVALID_DATA; break; } XMP_NIC_SET_ADMIN_OFFLOADS(pNicCtx, pAdmin); xmpNicSetCkoFlags(pNicCtx); xmpNicInitOffloadCapabilities(pNicCtx, &pNicCtx->OffloadCapabilities); /* TODO: Generate event */ BytesRead = NDIS_SIZEOF_OFFLOAD_PARAMETERS_REVISION_1; Status = NDIS_STATUS_SUCCESS; XENAMP_NDIS_OBJECT_INIT(&StatusIndication.Header, NDIS_OBJECT_TYPE_STATUS_INDICATION, NDIS_STATUS_INDICATION_REVISION_1, sizeof(NDIS_STATUS_INDICATION)); StatusIndication.SourceHandle = pNicCtx->hMPAdapter; StatusIndication.PortNumber = 0; StatusIndication.StatusCode = NDIS_STATUS_TASK_OFFLOAD_CURRENT_CONFIG; StatusIndication.Flags = 0; StatusIndication.DestinationHandle = NULL; StatusIndication.RequestId = NdisRequest->RequestId; StatusIndication.StatusBuffer = &pNicCtx->OffloadCapabilities; StatusIndication.StatusBufferSize = sizeof(NDIS_OFFLOAD); NdisMIndicateStatusEx(pNicCtx->hMPAdapter, &StatusIndication); } break; case OID_GEN_HD_SPLIT_PARAMETERS: { NDIS_HD_SPLIT_PARAMETERS *pHdSplit; pHdSplit = (NDIS_HD_SPLIT_PARAMETERS *) InformationBuffer; if ( InformationBufferLength < NDIS_SIZEOF_HD_SPLIT_PARAMETERS_REVISION_1 ) { BytesNeeded = NDIS_SIZEOF_HD_SPLIT_PARAMETERS_REVISION_1; Status = NDIS_STATUS_INVALID_LENGTH; break; } if ( !XENAMP_NDIS_OBJECT_VALID(&pHdSplit->Header, NDIS_HD_SPLIT_PARAMETERS_REVISION_1, NDIS_OBJECT_TYPE_DEFAULT, NDIS_SIZEOF_HD_SPLIT_PARAMETERS_REVISION_1 )) { BytesRead = sizeof(NDIS_OBJECT_HEADER); Status = NDIS_STATUS_INVALID_DATA; break; } if( bit(pHdSplit->HDSplitCombineFlags, NDIS_HD_SPLIT_COMBINE_ALL_HEADERS) ) bis( pNicCtx->Flags, XMP_NIC_FLAGS_RX_SPLIT_COMBINE ); else bic( pNicCtx->Flags, XMP_NIC_FLAGS_RX_SPLIT_COMBINE ); } break; default: XMPTRACE(XMP_DBG_INFO, ("xmpSetInformation: unsupported OID=%lx\n", Oid)); Status = xmpDiagSetInformation( pNicCtx, Oid, InformationBuffer, InformationBufferLength, &BytesRead, &BytesNeeded); break; } NdisRequest->DATA.SET_INFORMATION.BytesRead = BytesRead; NdisRequest->DATA.SET_INFORMATION.BytesNeeded = BytesNeeded; XMPTRACE(XMP_DBG_REQ, ("<== xmpSetInformation: Status=%x\n", Status)); return Status; }
void ana_network_manager::handle_receive( ana::error_code error, ana::net_id client, ana::read_buffer buffer) { if (error) network::disconnect( client ); else { std::set< ana_component* >::iterator it; it = std::find_if( components_.begin(), components_.end(), boost::bind(&ana_component::get_id, _1) == client ); if ( it != components_.end() ) (*it)->add_buffer( buffer, client ); else { if (components_.empty() ) throw std::runtime_error("Received a message while no component was running.\n"); std::map< ana::server*, clients_manager* >::iterator mgrs; for ( mgrs = server_manager_.begin(); mgrs != server_manager_.end(); ++mgrs) { if (mgrs->second->is_a_client( client ) ) // Is this your client? { if ( mgrs->second->is_pending_handshake( client ) ) // Did he login already? { // all handshakes are 4 bytes long if ( buffer->size() != sizeof(ana::ana_uint32) ) mgrs->first->disconnect( client ); ana::ana_uint32 handshake; { ana::serializer::bistream bis( buffer->string() ); bis >> handshake; ana::network_to_host_long( handshake ); //I'm expecting a 0 anyway } if ( handshake != 0 ) mgrs->first->disconnect( client ); else { mgrs->second->handshaked( client ); //send back it's id ana::serializer::bostream bos; ana::ana_uint32 network_byte_order_id = client; ana::host_to_network_long( network_byte_order_id ); bos << network_byte_order_id; ana_handshake_finisher_handler* handler = new ana_handshake_finisher_handler( mgrs->first, mgrs->second); mgrs->first->send_one(client, ana::buffer( bos.str() ), handler ); mgrs->first->set_header_first_mode( client ); } } else // just add the buffer to the associated clients_manager { ana::net_id server_id = mgrs->first->id(); it = std::find_if( components_.begin(), components_.end(), boost::bind(&ana_component::get_id, _1) == server_id ); if ( (*it)->is_client() ) throw std::runtime_error("Wrong id to receive from."); (*it)->add_buffer( buffer, client ); } } } } }
/* Compute x&y using only calls to functions bis and bic */ int bool_and(int x, int y) { int result = bic(bis(x, y), bis(bic(x, y), bic(y, x))); return result; }
bool parse_protein(universe& universe, factor_graph_model<F>& fg, const std::string& filename) { typedef typename factor_graph_model<F>::variable_type variable_type; binary_input_stream bis(filename.c_str()); size_t numvars = bis.read<int32_t>(); size_t numedges = bis.read<int32_t>(); if (bis.fail()) return false; std::vector<variable_type*> idtovar; idtovar.resize(numvars); // ignore the next 2 * num_edges * int32_t bytes // this will contain the list of edges which we do not need // we can construct this from the factors later on bis.seekg(2 * numedges * sizeof(int32_t), std::ios_base::cur); if (bis.fail()) return false; // this will now be the node potentials for (size_t i = 0;i < numvars; ++i) { // will be nice if the node potentials are given to me in numerical order // but I certainly can't guarantee that given the file format size_t varid = bis.read<int32_t>(); size_t cardinality = bis.read<int32_t>(); if (bis.fail()) return false; if (cardinality <= 0) return false; // create the variable //char temp[16]; sprintf(temp,"%d", varid); std::stringstream varname; varname << varid; variable_type* var = universe.new_finite_variable(varname.str(), cardinality); idtovar[varid] = var; // create the factor F factor(make_domain(var), 0.0); for (size_t asg = 0; asg < cardinality; ++asg) { factor.set_logv(asg, proteinparsing::bound_infinity(bis.read<double>())); } factor.normalize(); fg.add_factor(factor); } // this will now be the edge potentials size_t table_count = bis.read<int32_t>(); if (bis.fail()) return false; // this may or may not be equal to num_edges depending on whether // both edge directions were counted... so lets not check that if(! (table_count == numedges || table_count == numedges / 2)) { return false; } // read the binary factors for (size_t i = 0;i < table_count; ++i) { // read the src vertex size_t srcid = bis.read<int32_t>(); assert(srcid< numvars); variable_type* varsrc = idtovar[srcid]; size_t srccard = bis.read<int32_t>(); if (bis.fail()) return false; // read the destination vertex size_t destid = bis.read<int32_t>(); assert(destid < numvars); variable_type* vardest = idtovar[destid]; size_t destcard = bis.read<int32_t>(); if (bis.fail()) return false; if (srccard != varsrc->size() || destcard != vardest->size()) { return false; } F factor(make_domain(varsrc, vardest), 0.0); for (size_t j = 0; j < srccard * destcard; ++j) { size_t srcasg = bis.read<int32_t>(); size_t destasg = bis.read<int32_t>(); double value = bis.read<double>(); if (bis.fail()) return false; if (!((srcasg < srccard) && (destasg < destcard))) return false; //assert(srcasg < srccard); //assert(destasg < destcard); // slow! /* finite_assignment fasg; fasg[varsrc] = srcasg; fasg[vardest] = destasg; proteinparsing::valueassign(factor(fasg), value); */ // faster, but a little awkward if (factor.arg_vector()[0] == varsrc) { factor.set_logv(srcasg, destasg, proteinparsing::bound_infinity(value)); } else { factor.set_logv(destasg, srcasg, proteinparsing::bound_infinity(value)); } } if (std::isinf(-std::log(factor.minimum())) ) { // std::cout << factor << "\n"; // getchar(); } fg.add_factor(factor); } // std::cout << "done!" << std::endl; return true; }
void CryptoManager::decodeHuffman(const u_int8_t* is, string& os, const size_t len) throw(CryptoException) { // BitInputStream bis; int pos = 0; if(len < 11 || is[pos] != 'H' || is[pos+1] != 'E' || !((is[pos+2] == '3') || (is[pos+2] == '0'))) { throw CryptoException(STRING(DECOMPRESSION_ERROR)); } pos+=5; int size; size = *(int*)&is[pos]; pos+=4; dcdebug("Size: %d\n", size); unsigned short treeSize; treeSize = *(unsigned short*)&is[pos]; pos+=2; if(len < (size_t)(11 + treeSize * 2)) throw CryptoException(STRING(DECOMPRESSION_ERROR)); Leaf** leaves = new Leaf*[treeSize]; int i; for(i=0; i<treeSize; i++) { int chr = is[pos++]; int bits = is[pos++]; leaves[i] = new Leaf(chr, bits); } BitInputStream bis(is, pos, len); DecNode* root = new DecNode(); for(i=0; i<treeSize; i++) { DecNode* node = root; for(int j=0; j<leaves[i]->len; j++) { try { if(bis.get()) { if(node->right == NULL) node->right = new DecNode(); node = node->right; } else { if(node->left == NULL) node->left = new DecNode(); node = node->left; } } catch(const BitStreamException&) { throw CryptoException(STRING(DECOMPRESSION_ERROR)); } } node->chr = leaves[i]->chr; } bis.skipToByte(); // We know the size, so no need to use strange STL stuff... AutoArray<char> buf(size+1); pos = 0; for(i=0; i<size; i++) { DecNode* node = root; while(node->chr == -1) { try { if(bis.get()) { node = node->right; } else { node = node->left; } } catch(const BitStreamException&) { throw CryptoException(STRING(DECOMPRESSION_ERROR)); } if(node == NULL) { for(i=0; i<treeSize; i++) { delete leaves[i]; } delete[] leaves; delete root; dcdebug("Bad node found!!!\n"); throw CryptoException(STRING(DECOMPRESSION_ERROR)); } } buf[pos++] = (u_int8_t)node->chr; } buf[pos] = 0; os.assign(buf, size); for(i=0; i<treeSize; i++) { delete leaves[i]; } delete[] leaves; delete root; }
void Trimmer::CutTrack(string outputFLACFile, unsigned int leftSecond, unsigned int rightSecond) { /* if (bs.GetString(3) == "ID3") { bs.Skip(3); uint32_t id3size = 0; uint32_t b1 = 0, b2 = 0, b3 = 0, b4 = 0; bs.GetInteger(&b1, 8); bs.GetInteger(&b2, 8); bs.GetInteger(&b3, 8); bs.GetInteger(&b4, 8); id3size = (b1 << 21) | (b2 << 14) | (b3 << 7) | b4; bs.Skip(id3size); }*/ BitIStream bis(fileName); BitOStream bos(outputFLACFile); FLACMetaStreamInfo msi; if (bis.ReadString(4) != "fLaC") { throw NoFLACFile(); } bos.WriteString("fLaC"); FLACMetaBlockHeader mbh; mbh.IsLastBlock = false; while (!mbh.IsLastBlock) { ReadMetaBlockHeader(bis, &mbh); WriteMetaBlockHeader(bos, &mbh); switch (mbh.BlockType) { case FLAC_META_STREAMINFO: ReadStreamInfo(bis, &msi); WriteStreamInfo(bos, &msi); break; case FLAC_META_SEEKTABLE: case FLAC_META_APPLICATION: case FLAC_META_VORBIS_COMMENT: case FLAC_META_CUESHEET: case FLAC_META_PADDING: CopyBytes(bis, bos, mbh.BlockSize); break; default: cerr << "Warning: unknown block type" << endl; CopyBytes(bis, bos, mbh.BlockSize); break; } } for (int i = 0; i < 10; i++) { //Frame start FLACFrameHeader fh; ReadFrameHeader(bis, &fh); WriteFrameHeader(bos, &fh); if (fh.SyncCode != 0b11111111111110) { cout << "Invalid sync code" << endl; throw NoFLACFile(); } for (int subframeN = 0; subframeN <= msi.ChannelsCount; subframeN++) { FLACSubframeHeader sfh; ReadSubframeHeader(bis, &sfh); WriteSubframeHeader(bos, &sfh); switch (sfh.Type) { case FLAC_SF_CONSTANT: cout << "const" << endl; CopyConstantSubframe(bis, bos, &fh, &msi); break; case FLAC_SF_VERBATIM: cout << "verbatim" << endl; CopyVerbatimSubframe(bis, bos, &fh, &msi); break; case FLAC_SF_FIXED: cout << "fixed" << endl; CopyFixedSubframe(bis, bos, &fh, &msi, &sfh); break; case FLAC_SF_LPC: cout << "lpc" << endl; CopyLPCSubframe(bis, bos, &fh, &msi, &sfh); break; default: break; } } bos.AlignByte(); uint16_t crc16; bis.ReadInteger(&crc16, 16); bos.WriteInteger(crc16, 16); /*ReadFrameHeader(bis, &fh); cout << fh.SyncCode << endl;*/ //Frame end } }
unsigned char readvirtIOport(struct virtual_IO_port *virtualPort) { unsigned char pin; unsigned char result = 0x00; /* buffer for pin status -> port status */ READ_IO_DEBUG("\r\nreadIOport\r\n"); for (pin = 0; pin < VIRTUAL_PORT_PINCOUNT; pin++) { /* loop over all virtual IO Pins */ READ_IO_DEBUG("pPort:0x%x;",virtualPort->pins[pin].PPORT); READ_IO_DEBUG("pDDR:0x%x;",virtualPort->pins[pin].PDDR); READ_IO_DEBUG("pPin:0x%x;",virtualPort->pins[pin].PPIN); READ_IO_DEBUG("pin:%i\r\n",pin); READ_IO_DEBUG("func:0x%x\r\n",virtualPort->pins[pin].function_code); if(virtualPort->pins[pin].PPORT == 0 || virtualPort->pins[pin].PDDR == 0 || virtualPort->pins[pin].PPIN == 0) { READ_IO_DEBUG("conti\r\n"); continue; } switch (virtualPort->pins[pin].function_code) { case PIN_S0: /* * S0 functionality * - check ddr/port/pin for S0 pin (only interrupt pins possible for this function) * - write current counter value to virtual pin data area of txbuffer */ break; case PIN_INPUT: /* input pin -> read pin status to buffer */ if (bis(*(virtualPort->pins[pin].PPIN),virtualPort->pins[pin].pin)) { /* get status of current pin */ //set "ON" cbi(result, pin%8); /* clear bit */ } else { //set "OFF" sbi(result, pin%8); /* set bit */ } break; case PIN_SWITCH: /* switch pin -> read current pin status to buffer */ case PIN_TOGGLE: case PIN_PULSE: if (bis(*(virtualPort->pins[pin].PPORT),virtualPort->pins[pin].pin)) { /* get status of current pin */ //set "ON" cbi(result, pin%8); /* clear bit */ } else { //set "OFF" sbi(result, pin%8); /* set bit */ } break; #ifdef USE_OW case PIN_OW_POWER_PARASITE: read1WirePin(&virtualPort->pins[pin], DS18X20_POWER_PARASITE); break; case PIN_OW_POWER_EXTERN: read1WirePin(&virtualPort->pins[pin], DS18X20_POWER_EXTERN); break; #endif case PIN_DISABLED: default: /* default handling */ cbi(result, (pin%8)); /* clear bit in buffer */ break; } } READ_IO_DEBUG("result0x%x\r\n",result); return result; }
bool RapMapIndex::load(std::string& indexPrefix) { auto logger = spdlog::get("stderrLog"); std::string kmerInfosName = indexPrefix + "kinfo.bin"; std::string eqClassListName = indexPrefix + "eqclass.bin"; std::string eqLabelListName = indexPrefix + "eqlab.bin"; std::string posListName = indexPrefix + "pos.bin"; std::string jfFileName = indexPrefix + "rapidx.jfhash"; std::string txpNameFile = indexPrefix + "txpnames.bin"; std::string txpLenFile = indexPrefix + "txplens.bin"; std::string fwdJumpFile = indexPrefix + "fwdjump.bin"; std::string revJumpFile = indexPrefix + "revjump.bin"; // Load the kmer info list first --- this will // give us the # of unique k-mers std::ifstream kmerInfoStream(kmerInfosName, std::ios::binary); { logger->info("loading k-mer info list . . ."); ScopedTimer timer; cereal::BinaryInputArchive kmerInfoArchive(kmerInfoStream); kmerInfoArchive(kmerInfos); logger->info("done\n"); } kmerInfoStream.close(); size_t numDistinctKmers = kmerInfos.size(); { ScopedTimer timer; logger->info("loading k-mer => id hash . . . "); std::ifstream bis(jfFileName); const SpecialHeader bh(bis); // mapFile.reset(new jellyfish::mapped_file(jfFileName.c_str())); const size_t sizeInBytes = bh.size_bytes(); // Load the hash from file logger->info("\theader format = {}" , bh.format()); logger->info("\t# distinct k-mers = {}" , numDistinctKmers); logger->info("\thash key len = {}" , bh.key_len()); logger->info("\tcounter len = {}" , bh.counter_len()); logger->info("\tmax reprobe offset = {}" , bh.max_reprobe()); logger->info("\tsize in bytes = {}" , sizeInBytes); // Allocate the actual storage rawHashMem.reset(new char[sizeInBytes]); bis.read(rawHashMem.get(), sizeInBytes); // We can close the file now bis.close(); merHash.reset( new FileMerArray(rawHashMem.get(),//mapFile->base() + bh.offset(), sizeInBytes, bh.size(), bh.key_len(), bh.counter_len(), bh.max_reprobe(), bh.matrix())); // Set the key size rapmap::utils::my_mer::k(bh.key_len() / 2); logger->info("done"); } std::ifstream eqClassStream(eqClassListName, std::ios::binary); { logger->info("loading eq classes . . . "); ScopedTimer timer; cereal::BinaryInputArchive eqClassArchive(eqClassStream); eqClassArchive(eqClassList); logger->info("[{}] classes", eqClassList.size()); logger->info("done"); } eqClassStream.close(); std::ifstream eqLabelStream(eqLabelListName, std::ios::binary); { logger->info("loading eq class labels . . . "); ScopedTimer timer; cereal::BinaryInputArchive eqLabelArchive(eqLabelStream); eqLabelArchive(eqLabelList); logger->info("[{}] labels", eqLabelList.size()); logger->info("done"); } eqLabelStream.close(); std::ifstream posStream(posListName, std::ios::binary); { logger->info("loading position list . . . "); ScopedTimer timer; cereal::BinaryInputArchive posArchive(posStream); posArchive(posList); logger->info("[{}] total k-mer positions", posList.size()); logger->info("done"); } posStream.close(); std::ifstream txpNameStream(txpNameFile, std::ios::binary); { logger->info("loading transcript names "); ScopedTimer timer; cereal::BinaryInputArchive txpNameArchive(txpNameStream); txpNameArchive(txpNames); logger->info("[{}] transcripts in index ", txpNames.size()); logger->info("done "); } txpNameStream.close(); std::ifstream txpLenStream(txpLenFile, std::ios::binary); { logger->info("loading transcript lengths"); ScopedTimer timer; cereal::BinaryInputArchive txpLenArchive(txpLenStream); txpLenArchive(txpLens); logger->info("[{}] transcripts in index", txpLens.size()); logger->info("done "); } txpLenStream.close(); std::ifstream fwdJumpStream(fwdJumpFile, std::ios::binary); { logger->info("loading forward jumps"); ScopedTimer timer; cereal::BinaryInputArchive fwdJumpArchive(fwdJumpStream); fwdJumpArchive(fwdJumpTable); logger->info("[{}] forward jumps", fwdJumpTable.size()); logger->info("done "); } fwdJumpStream.close(); std::ifstream revJumpStream(revJumpFile, std::ios::binary); { logger->info("loading forward jumps"); ScopedTimer timer; cereal::BinaryInputArchive revJumpArchive(revJumpStream); revJumpArchive(revJumpTable); logger->info("[{}] reverse jumps", revJumpTable.size()); logger->info("done "); } revJumpStream.close(); return true; }
void handleIOport(struct virtual_IO_port *virtualPort, unsigned char instructions, const unsigned char mask) { unsigned char *cur_DDR = 0; /* pointer to DDR register */ unsigned char *cur_PORT = 0; /* pointer to O Port */ unsigned char *cur_PIN = 0; /* pointer to I Pin */ unsigned char cur_pin = 0; /* pin number */ HANDLE_IO_DEBUG("\r\nhandleIOport:0x%x\r\n",instructions); for (int pin = 0; pin < VIRTUAL_PORT_PINCOUNT; pin++) { /* loop over all virtual IO Pins */ if (!(mask & (1 << pin))) { continue; } if(virtualPort->pins[pin].PPORT == 0 || virtualPort->pins[pin].PDDR == 0 || virtualPort->pins[pin].PPIN == 0) { continue; } /* * first get all needed address information for current pin/port * - the "action" data is written by i2c into the rxbuffer -> need correct rxbuffer address * - the function of the current pin is readout from the eeprom -> need correct eeprom address */ cur_PORT = virtualPort->pins[pin].PPORT; /* get pointer to current port */ HANDLE_IO_DEBUG("pPort:0x%x;",cur_PORT); cur_DDR = virtualPort->pins[pin].PDDR; /* get pointer to current datadirectionregister */ HANDLE_IO_DEBUG("pDDR:0x%x;",cur_DDR); cur_PIN = virtualPort->pins[pin].PPIN; /* get pointer to current pin */ HANDLE_IO_DEBUG("pPIN:0x%x\r\n",cur_PIN); cur_pin = virtualPort->pins[pin].pin; HANDLE_IO_DEBUG("pin:0x%x\r\n",cur_pin); HANDLE_IO_DEBUG("func:0x%x\r\n",virtualPort->pins[pin].function_code); switch (virtualPort->pins[pin].function_code) { /* handle current pin by function code */ case PIN_DISABLED: /* pin is marked as disabled */ *cur_DDR &= ~(1 << cur_pin); //disable PIN *cur_PORT &= ~(1 << cur_pin); //disable PULLUP break; case PIN_INPUT: /* pin marked as input -> set as input nothing else to to (value is readout @readIOpins() */ *cur_DDR &= ~(1 << cur_pin); //set DDR "0" *cur_PORT |= (1 << cur_pin); //enable pullup PORT "1" break; case PIN_SWITCH: /* pin marked as output -> set as output and set the value of the specific bit of rxbuffer*/ *cur_DDR |= (1 << cur_pin); /* set DDR "1" -> output */ if (bis(instructions,(pin%8))) { //on or off *cur_PORT &= ~(1 << cur_pin); //set 0 -> "OFF" } else { *cur_PORT |= (1 << cur_pin); //set 1 -> "ON" } break; case PIN_PULSE: /* pin marked as output -> set as output and pulse the specific pin */ *cur_DDR |= (1 << cur_pin); /* set DDR "1" -> output */ if (bis(instructions,(pin%8))) { //only handle active pins *cur_PORT &= ~(1 << cur_pin); //set 0 > "OFF" _delay_ms(pulse_time); /* wait x ms */ *cur_PORT |= (1 << cur_pin); //set 1 -> "ON" } break; case PIN_TOGGLE: /* pin marked as output -> set as output and pulse the specific pin */ *cur_DDR |= (1 << cur_pin); /* set DDR "1" -> output */ if (bis(instructions,(pin%8))) { //only handle active pins if (bis(*cur_PORT,(cur_pin%8))) { //test old value *cur_PORT &= ~(1 << cur_pin); //set OFF } else { *cur_PORT |= (1 << cur_pin); //set 1 -> "ON" } } break; #ifdef USE_OW case PIN_OW_POWER_PARASITE: set1WirePin(&virtualPort->pins[pin], DS18X20_POWER_PARASITE); break; case PIN_OW_POWER_EXTERN: set1WirePin(&virtualPort->pins[pin], DS18X20_POWER_EXTERN); break; #endif case PIN_S0: /* * S0 functionality * * @todo test this function */ /*//INT0 if((cur_PORT == P_S0_0_PORT) && (cur_DDR == P_S0_0_DDR) && (io_pins[pin].pin == S0_0_PIN)){ //enable S0 *cur_DDR &= ~(1 << io_pins[pin].pin); //set DDR "0" *cur_PORT |= (1 << io_pins[pin].pin); //enable pullup PORT "1" S0_Start(0); S0_0 = 1; if(get_S0_data(0)%S0_interval == 0){ save_eeprom(0); } break; }else{ //INT1 if((cur_PORT == P_S0_1_PORT) && (cur_DDR == P_S0_1_DDR) && (io_pins[pin].pin == S0_1_PIN)){ //enable S0 *cur_DDR &= ~(1 << io_pins[pin].pin); //set DDR "0" *cur_PORT |= (1 << io_pins[pin].pin); //enable pullup PORT "1" S0_Start(1); S0_1 = 1; if(get_S0_data(1)%S0_interval == 0){ save_eeprom(1); } break; }else{ eeprom_busy_wait (); eeprom_write_byte(eeprom_address,PIN_DISABLED); //write function code to eeprom } }*/ break; default: HANDLE_IO_DEBUG("unknown_func\r\n"); *cur_DDR &= ~(1 << virtualPort->pins[pin].pin); //disable PIN *cur_PORT &= ~(1 << virtualPort->pins[pin].pin); //disable PULLUP break; } } /* //S0 deaktivieren if(!S0_0){ S0_Stop(0); } if(!S0_1){ S0_Stop(1); }*/ }
bool ScreenPub::onHandleOpen(const void* buf, size_t len, OutputStream& out) { u32 timeStamp = Timer::currentTimeMillis(); ScreenInfo sinfo; ByteBufferInputStream bis((const u8*)buf,len,false); sinfo.load(bis); String dimdimId = "defaultUser"; String roomId = getScreen().getConfKey(); String sessionId = "defaultSession"; String installationId = ""; if(bis.getRemainingByteCount() > 0) { //u32 lenRemains = bis.getRemainingByteCount(); //char *tmp = new char[lenRemains]; //bis.peek(tmp,lenRemains); //std::cout<<"Remaining buffer : "<<lenRemains<<std::endl; //Dump::hexDump(std::cout,tmp,lenRemains); //std::cout<<"Reading RAD strings\n"<<std::endl; size_t len = 0; { bis.readLong((u32*)&len); std::cout<<"Length Read : "<<len<<std::endl; char *buf = new char[len+1]; ScopedArray<char> bufPtr(buf); memset(buf,0,len+1); bis.read(buf,len); std::cout<<"dimdim id : ["<<buf<<"]"<<std::endl; String identity = buf; StringTokenizer st(identity,DDSS_IDENTITY_SEP); if(st.countTokens() == 1) { dimdimId = buf; installationId = ""; } else { installationId = st.nextToken(); dimdimId = st.nextToken(); } DDSS_INFO("ScreenPub")<<"Install ID ["<<installationId<<"] Dimdim ID : ["<<dimdimId<<"]"<<std::endl; } len = 0; { bis.readLong((u32*)&len); std::cout<<"Length Read : "<<len<<std::endl; char *buf = new char[len+1]; ScopedArray<char> bufPtr(buf); memset(buf,0,len+1); bis.read(buf,len); std::cout<<"room name : ["<<buf<<"]"<<std::endl; roomId = buf; } len = 0; { bis.readLong((u32*)&len); std::cout<<"Length Read : "<<len<<std::endl; char *buf = new char[len+1]; ScopedArray<char> bufPtr(buf); memset(buf,0,len+1); bis.read(buf,len); std::cout<<"session id : ["<<buf<<"]"<<std::endl; sessionId = buf; } } DDSS_VERBOSE("ScreenPub")<<"LOADED SCREEN INFO : "<<sinfo<<std::endl; getScreen().init(sinfo); getScreen().setRADParams(dimdimId, roomId, sessionId, installationId); DDSS_VERBOSE("ScreenPub")<<"SCREEN INIT DONE : "<<getScreen().getInfo()<<std::endl; out.write(getId().c_str(),getId().size()); out.write("\n",1); if(dumpOn) { std::cout<<"RAD Dir : "<<getScreen().getRADDir()<<std::endl; String dumpFileName = getScreen().getRADDir(); dumpFileName += "/Inbox/DTP/"; dumpFileName += getScreen().getStreamName(); dumpFileName += ".bin"; std::cout<<"Dumping incoming traffic to : "<<dumpFileName<<"..."<<std::endl; dumpFile.open(dumpFileName.c_str(), std::ios::out | std::ios::binary); if(!dumpFile.is_open()) { DDSS_WARN("ScreenPub")<<"[DUMP-FAIL] Failed to open : ("<<dumpFileName<<")"<<std::endl; dumpOn = false; } } if(dumpOn && dumpFile.is_open() && buf) { ScopedLock sl(dumpLock); //std::cout<<"Writing open buffer of length : "<<len<<"bytes!!! "<<std::endl; dumpFile.write((const char*)&len,4); dumpFile.write((const char*)&timeStamp,4); dumpFile.write((const char*)buf,(int)len); dumpFile.flush(); } return true; }
/* Compute x|y using only calls to functions bis and bic */ int bool_or(int x, int y) { int result = bis(x, y); return result; };
/* Compute x^y using only calls to functions bis and bic */ int bool_xor(int x, int y) { int result = bic ( bis(x, y), bic ( x, bic (x, y))); return result; }
SetupReader* SetupReader::get_empty_reader(){ char *c = new char[1]; BinaryInputByteStream bis(c, 1); SetupReader *sr = new SetupReader(bis, false); return sr; }