void init_fasta_enzyme_function ( const string& enzyme ) { static bool called = false; if ( called ) return; called = true; static DigestTable& digestTable = DigestTable::instance (); if ( enzyme == "No enzyme" ) { ErrorHandler::genError ()->error ( "No enzyme not valid option for this program." ); return; } StringVector enzymeNameTable; cnbr_digest = false; StringSizeType start = 0; StringSizeType end = 0; for ( ; ; ) { end = enzyme.find_first_of ( "/", start ); string enzymeName = enzyme.substr ( start, end-start ); if ( enzymeName == "CNBr" ) cnbr_digest = true; enzymeNameTable.push_back ( enzymeName ); if ( end == string::npos ) break; start = end + 1; } numDigests = enzymeNameTable.size (); for ( int i = 0 ; i < numDigests ; i++ ) { string br_aas = digestTable.getBreakMask (enzymeNameTable[i]); break_aas_array.push_back ( br_aas ); break_mask_array.push_back ( string_to_mask ( br_aas ) ); string exclude_aas = digestTable.getExcludeMask (enzymeNameTable[i]); exclude_aas_array.push_back ( exclude_aas ); if ( exclude_aas != "-" ) exclude_mask_array.push_back ( string_to_mask ( exclude_aas ) ); else exclude_mask_array.push_back ( 0 ); digestSpecificityArray.push_back ( digestTable.getSpecificity (enzymeNameTable[i]) ); } if ( numDigests == 1 ) { break_mask = break_mask_array [0]; break_aas = break_aas_array [0]; exclude_mask = exclude_mask_array [0]; digestSpecificity = digestSpecificityArray [0]; if ( digestSpecificity == 'C' ) enzyme_fragmenter = calc_fasta_c_term_fragments; else enzyme_fragmenter = calc_fasta_n_term_fragments; } else { int i; for ( i = 1 ; i < numDigests ; i++ ) { if ( digestSpecificityArray [i] != digestSpecificityArray [0] ) break; } if ( i == numDigests ) digestSpecificity = digestSpecificityArray [0]; /* All digest specificities must be the same for digestSpecificity to be set */ enzyme_fragmenter = calc_fasta_multi_digest_fragments; } }
EStatusCode CFFEmbeddedFontWriter::AddDependentGlyphs(UIntVector& ioSubsetGlyphIDs) { EStatusCode status = PDFHummus::eSuccess; UIntSet glyphsSet; UIntVector::iterator it = ioSubsetGlyphIDs.begin(); bool hasCompositeGlyphs = false; for(;it != ioSubsetGlyphIDs.end() && PDFHummus::eSuccess == status; ++it) { bool localHasCompositeGlyphs; status = AddComponentGlyphs(*it,glyphsSet,localHasCompositeGlyphs); hasCompositeGlyphs |= localHasCompositeGlyphs; } if(hasCompositeGlyphs) { UIntSet::iterator itNewGlyphs; for(it = ioSubsetGlyphIDs.begin();it != ioSubsetGlyphIDs.end(); ++it) glyphsSet.insert(*it); ioSubsetGlyphIDs.clear(); for(itNewGlyphs = glyphsSet.begin(); itNewGlyphs != glyphsSet.end(); ++itNewGlyphs) ioSubsetGlyphIDs.push_back(*itNewGlyphs); sort(ioSubsetGlyphIDs.begin(),ioSubsetGlyphIDs.end()); } return status; }
static UIntVector GetOrderedKeys(const UIntAndGlyphEncodingInfoVector& inMap) { UIntVector result; for(UIntAndGlyphEncodingInfoVector::const_iterator it = inMap.begin(); it != inMap.end(); ++it) result.push_back(it->first); sort(result.begin(),result.end()); return result; }
EStatusCode CFFDescendentFontWriter::WriteFont( ObjectIDType inDecendentObjectID, const std::string& inFontName, FreeTypeFaceWrapper& inFontInfo, const UIntAndGlyphEncodingInfoVector& inEncodedGlyphs, ObjectsContext* inObjectsContext, bool inEmbedFont) { // reset embedded font object ID (and flag...to whether it was actually embedded or not, which may // happen due to font embedding restrictions) mEmbeddedFontFileObjectID = 0; // Logically speaking, i shouldn't be getting to CID writing // if in type 1. at least, this is the current assumption, since // i don't intend to support type 1 CIDs, but just regular type 1s. // as such - fail if got here for type 1 const char* fontType = inFontInfo.GetTypeString(); if(strcmp(scType1,fontType) == 0) { TRACE_LOG1("CFFDescendentFontWriter::WriteFont, Exception. identified type1 font when writing CFF CID font, font name - %s. type 1 CIDs are not supported.",inFontName.substr(0, MAX_TRACE_SIZE - 200).c_str()); return PDFHummus::eFailure; } if (inEmbedFont) { CFFEmbeddedFontWriter embeddedFontWriter; UIntAndGlyphEncodingInfoVector encodedGlyphs = inEncodedGlyphs; UIntVector orderedGlyphs; UShortVector cidMapping; // Gal: the following sort completely ruins everything. // the order of the glyphs should be maintained per the ENCODED characthers // which is how the input is recieved. IMPORTANT - the order is critical // for the success of the embedding, as the order determines the order of the glyphs // in the subset font and so their GID which MUST match the encoded char. //sort(encodedGlyphs.begin(), encodedGlyphs.end(), sEncodedGlypsSort); for (UIntAndGlyphEncodingInfoVector::const_iterator it = encodedGlyphs.begin(); it != encodedGlyphs.end(); ++it) { orderedGlyphs.push_back(it->first); cidMapping.push_back(it->second.mEncodedCharacter); } EStatusCode status = embeddedFontWriter.WriteEmbeddedFont(inFontInfo, orderedGlyphs, scCIDFontType0C, inFontName, inObjectsContext, &cidMapping, mEmbeddedFontFileObjectID); if (status != PDFHummus::eSuccess) return status; } DescendentFontWriter descendentFontWriter; return descendentFontWriter.WriteFont(inDecendentObjectID,inFontName,inFontInfo,inEncodedGlyphs,inObjectsContext,this); }
UIntVector KNearest::Nearest(const RealCoord &state, const RealCoordVector &state_set) const { UIntVector neighbors; std::size_t state_num = state_set.size(); if (state_num <= k_) { for (unsigned i = 0; i < state_num; ++i) { neighbors.push_back(i); } } else { double *dist = new double[state_num]; for (unsigned i = 0; i < state_num; ++i) { dist[i] = metric_->Distance(state, state_set[i]); } for (unsigned i = 0; i <= k_; ++i) { neighbors.push_back(i); } for (unsigned i = 1; i < k_; ++i) { double di = dist[i]; unsigned j = i - 1; while (j != std::numeric_limits<unsigned>::max() && dist[i] < dist[j]) { dist[j + 1] = dist[j]; neighbors[j + 1] = neighbors[j]; --j; } dist[j + 1] = di; neighbors[j + 1] = i; } for (unsigned i = k_; i < state_num; ++i) { double di = dist[i]; unsigned j = k_ - 1; while (j != std::numeric_limits<unsigned>::max() && dist[i] < dist[j]) { dist[j + 1] = dist[j]; neighbors[j + 1] = neighbors[j]; --j; } neighbors[j + 1] = i; } delete[] dist; } neighbors.pop_back(); return neighbors; }
void TrueTypeEmbeddedFontWriter::AddDependentGlyphs(UIntVector& ioSubsetGlyphIDs) { UIntSet glyphsSet; UIntVector::iterator it = ioSubsetGlyphIDs.begin(); bool hasCompositeGlyphs = false; for(;it != ioSubsetGlyphIDs.end(); ++it) hasCompositeGlyphs |= AddComponentGlyphs(*it,glyphsSet); if(hasCompositeGlyphs) { UIntSet::iterator itNewGlyphs; for(it = ioSubsetGlyphIDs.begin();it != ioSubsetGlyphIDs.end(); ++it) glyphsSet.insert(*it); ioSubsetGlyphIDs.clear(); for(itNewGlyphs = glyphsSet.begin(); itNewGlyphs != glyphsSet.end(); ++itNewGlyphs) ioSubsetGlyphIDs.push_back(*itNewGlyphs); sort(ioSubsetGlyphIDs.begin(),ioSubsetGlyphIDs.end()); } }
/*! * Extracts and stores logical lines of code. * Determines and extract logical SLOC to place in the result variable * using addSLOC function. Each time the addSLOC function is called, * a new logical SLOC is added. This function assumes that the directive * is handled before it is called. * * \param result counter results * \param line processed physical line of code * \param lineBak original physical line of code * \param strLSLOC processed logical string * \param strLSLOCBak original logical string * \param paren_cnt count of parenthesis * \param loopWhiteSpace count of white space to determine loop ends */ void CPythonCounter::LSLOC(results* result, string line, size_t lineNumber, string lineBak, string &strLSLOC, string &strLSLOCBak, unsigned int &paren_cnt, UIntVector &loopWhiteSpace) { #define CONT_STR_LENGTH 18 string continuation_str[] = {"is", "in", "not", "+", "-", "*", "/", "=", "<", ">", "|", "&", "%", "^", "\\", "~", ",", "$"}; size_t start = 0; // starting index of the working string size_t i = 0, idx, strSize; int n; bool trunc_flag = false; unsigned int cnt = 0, numWS; string exclude = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_$"; string tmp; // process: // paren_cnt is used with {} [] () // 1. check if the current char is in one of the parentheses // 2. if no, check if the line has : or ; (statement separators), except else: // 3. if yes, count and put the statement in the result // 4. if the line does not ends with a continuation string or a statement separator (handled) // and the line is not in one of the parentheses // then count and put the statement in the result // 5. physical count considers all lines executables (or directives, no declarations) // check for loop ends, new loops, and record white space in order to determine ends if (print_cmplx) { // check white space for loop ends if (loopWhiteSpace.size() > 0) { // get white space tmp = line; tmp = CUtil::TrimString(tmp, -1); numWS = (unsigned)(line.length() - tmp.length()); // check for loop ends for (n = (int)loopWhiteSpace.size() - 1; n >= 0; n--) { if (loopWhiteSpace.at(n) != numWS) break; else loopWhiteSpace.pop_back(); } } // check for loop keywords (for, while) cnt = 0; CUtil::CountTally(line, loop_keywords, cnt, 1, exclude, "", "", NULL); if (cnt > 0) { if (loopWhiteSpace.size() < 1) { // get white space tmp = line; tmp = CUtil::TrimString(tmp, -1); numWS = (unsigned)(line.length() - tmp.length()); } // add nested loop white space and record nested loop level for (i = 0; i < cnt; i++) { loopWhiteSpace.push_back(numWS); if ((unsigned int)result->cmplx_nestloop_count.size() < loopWhiteSpace.size()) result->cmplx_nestloop_count.push_back(1); else result->cmplx_nestloop_count[loopWhiteSpace.size()-1]++; } } } line = CUtil::TrimString(line); lineBak = CUtil::TrimString(lineBak); size_t line_length = line.length(); bool lineContinued = false; while (i < line_length) { switch (line[i]) { case '{': case '[': case '(': // parentheses opener paren_cnt++; break; case '}': case ']': case ')': // parentheses closer if (paren_cnt > 0) paren_cnt--; break; } // 2. if no parentheses enclosing, and if the char is a statement separator if (paren_cnt == 0 && (line[i] == ';' || line[i] == ':')) { tmp = CUtil::ClearRedundantSpaces(line); // if line[..i] is else: then exit the outer if if (tmp.rfind("else:") != tmp.length() - 5) { // 3. strSize = CUtil::TruncateLine(i + 1 - start, strLSLOC.length(), this->lsloc_truncate, trunc_flag); if (strSize > 0) { strLSLOC += line.substr(start, i); strLSLOCBak += lineBak.substr(start, i); } if (result->addSLOC(strLSLOCBak, lineNumber, trunc_flag)) { // increase logical SLOC here result->exec_lines[LOG]++; } strLSLOC = strLSLOCBak = ""; start = i + 1; } else lineContinued = true; } i++; } if (paren_cnt == 0) { // add logical SLOC if the line does not end with a continuation string/char if (!lineContinued) { for (i = 0; i < CONT_STR_LENGTH; i++) { if (continuation_str[i].length() == 1) { if (line[line_length - 1] == continuation_str[i][0]) { lineContinued = true; break; } } else { idx = CUtil::FindKeyword(line, continuation_str[i]); if (idx != string::npos && idx == line_length - continuation_str[i].length() - 1) { lineContinued = true; break; } } } } if (!lineContinued) { strSize = CUtil::TruncateLine(line_length - start, strLSLOC.length(), this->lsloc_truncate, trunc_flag); if (strSize > 0) { strLSLOC += line.substr(start, line_length); strLSLOCBak += lineBak.substr(start, line_length); } if (result->addSLOC(strLSLOCBak, lineNumber, trunc_flag)) { // increase logical SLOC here result->exec_lines[LOG]++; } strLSLOC = strLSLOCBak = ""; } else { tmp = CUtil::TrimString(line.substr(start, line_length - start)); strSize = CUtil::TruncateLine(tmp.length(), strLSLOC.length(), this->lsloc_truncate, trunc_flag); if (strSize > 0) { strLSLOC += tmp.substr(0, strSize); tmp = CUtil::TrimString(lineBak.substr(start, line_length - start)); strLSLOCBak += tmp.substr(0, strSize); } } } result->exec_lines[PHY]++; }