/** Parses the given xml node to get the last name and firstname or abreviation of a name. @param node: xml node to parse, should be a contrib node with a 'name' or 'string-name' as a child @return CName object containing the parsed data */ CName AuthorParser::parseName(pugi::xml_node &node) { //Select the 'name' item pugi::xml_node nameNode=node.child("name"); if(!nameNode){ nameNode=node.child("string-name"); if(!nameNode){ return CName("", ""); } } //Select firstname and surname string authorLastname=nameNode.child("surname").child_value(); string authorFirstname=nameNode.child("given-names").child_value(); return CName(authorFirstname, authorLastname); }
//---------------------------------------------------------------------------------------------- int ObjectSerializer::SerializeUserDefinedType(ISerializable *pObj, TypeNode* pType, bool isPtr, fstream& pen) { int size = 0; bool isNull = false; if (isPtr) { // Access the pointer pointed by the pointer to pointer pObj = (*(ISerializable**)pObj); int length = 0; string typeName; char buffer[MaxTypeNameLength + 1]; isNull = (NULL == pObj); pen.write(reinterpret_cast<char*>(&isNull), sizeof(bool)); if (!isNull) { auto objLayout = pObj->GetObjectLayout(); typeName = g_ObjectFactory.FromCName(objLayout.CName()); PerformLateBinding(pObj, pType); length = typeName.size(); _ASSERTE(length <= MaxTypeNameLength); strcpy_s(buffer, typeName.c_str()); buffer[length] = 0; pen.write(buffer, MaxTypeNameLength + 1); Iterator* addresses = objLayout.GetIterator(); unsigned* addr32; for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx) { _ASSERTE(memberIdx < pType->Children.size()); addr32 = reinterpret_cast<unsigned*>(addresses->Current()); SerializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, pen); } } size = sizeof(unsigned); } else { auto objLayout = pObj->GetObjectLayout(); Iterator* addresses = objLayout.GetIterator(); unsigned* addr32; for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx) { _ASSERTE(memberIdx < pType->Children.size()); addr32 = reinterpret_cast<unsigned*>(addresses->Current()); SerializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, pen); } size = objLayout.TypeSize(); } return size; }
void AudioENF::PrintHeader() { char cID[4]; cout<<"------------ENF Audio header inform-----------"<<endl; CName(enfHeader.formatID,cID); cout<<"formatID: " << cID[0] << cID[1]<< cID[2]<< cID[3]<< endl; CName(enfHeader.locationID.NationID,cID); cout<<"locationID: " << cID[0] << cID[1]<< cID[2]<< cID[3]; CName(enfHeader.locationID.RegionID,cID); cout<<", " << cID[0] << cID[1]<< cID[2]<< cID[3]<< endl; cout<<"creationTime: " << enfHeader.creationTime.day<<"." << enfHeader.creationTime.mon<<"." << enfHeader.creationTime.year<<" " << enfHeader.creationTime.hour<<":" << enfHeader.creationTime.min<<":" << enfHeader.creationTime.sec<< endl; cout<<"sampleRate: " << enfHeader.sampleRate <<" HZ "<< endl; cout<<"bitsperSample: " << enfHeader.bitsperSample << endl; cout<<"dataSize: " << enfHeader.dataSize <<" bytes " << endl; }
//---------------------------------------------------------------------------------------------- void ObjectSerializer::PerformLateBinding(ISerializable* pObj, TypeNode*& pType) { auto objLayout = pObj->GetObjectLayout(); string candidateChild = g_ObjectFactory.FromCName(objLayout.CName()); string candidateAncestor = pType->FullName(); if (candidateChild != candidateAncestor && IsAncestor(candidateAncestor, candidateChild)) { pType = m_typeTable[candidateChild].TypeGraph; } }
//-------------------------------------------------------------------------------------------------- void legato::Executable::OutputPath ( const std::string& path ///< [IN] The file system path of the executable to be generated. ) //-------------------------------------------------------------------------------------------------- { m_OutputPath = path; if (m_CName == "") { CName(GetCSafeName(GetLastPathNode(m_OutputPath))); } }
//---------------------------------------------------------------------------------------------- void ObjectSerializer::Serialize(const ISerializable* pObject, string objFilename) { fstream pen; pen.open(objFilename.c_str(), ios::binary | ios::out); _ASSERTE(pen.is_open()); auto objLayout = const_cast<ISerializable*>(pObject)->GetObjectLayout(); const string& typeName = g_ObjectFactory.FromCName(objLayout.CName()); _ASSERTE(m_typeTable.find(typeName) != m_typeTable.end()); TypeData& typeData = m_typeTable[typeName]; SerializeType(reinterpret_cast<char*>(const_cast<ISerializable*>(pObject)), typeData.TypeGraph, pen); pen.close(); }
//---------------------------------------------------------------------------------------------- void ObjectSerializer::Deserialize(ISerializable* pObj, string objectFileName) { fstream eye; eye.open(objectFileName.c_str(), ios::binary | ios::in); _ASSERTE(eye.is_open()); _ASSERTE(pObj); auto objLayout = pObj->GetObjectLayout(); const string& typeName = g_ObjectFactory.FromCName(objLayout.CName()); _ASSERTE(m_typeTable.find(typeName) != m_typeTable.end()); TypeData& typeData = m_typeTable[typeName]; DeserializeType(reinterpret_cast<char*>(pObj), typeData.TypeGraph, eye); eye.close(); }
//--------------------------------------------------------------------------- // @function: // CTableDescriptorTest::EresUnittest_Basic // // @doc: // basic naming, assignment thru copy constructors // //--------------------------------------------------------------------------- GPOS_RESULT CTableDescriptorTest::EresUnittest_Basic() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); // Setup an MD cache with a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( pmp, &mda, NULL, /* pceeval */ CTestUtils::Pcm(pmp) ); CWStringConst strName(GPOS_WSZ_LIT("MyTable")); CMDIdGPDB *pmdid = GPOS_NEW(pmp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID, 1, 1); CTableDescriptor *ptabdesc = CTestUtils::PtabdescCreate(pmp, 10, pmdid, CName(&strName)); #ifdef GPOS_DEBUG CWStringDynamic str(pmp); COstreamString oss(&str); ptabdesc->OsPrint(oss); GPOS_TRACE(str.Wsz()); #endif // GPOS_DEBUG ptabdesc->Release(); return GPOS_OK; }
/** Adds to the aAuthors vector one author (CName object) with first and lastname given @param firstName: firstName of the author @param lastName: lastName of the author */ void CArticle::addAuthor(const string &firstName, const string &lastName) { aAuthors.push_back(CName(firstName, lastName)); }
void CCellView::Read(BPositionIO& stream) { CSwapStream str(stream); scChunk chunk; long offset; int *funcList, *styleList, *fontList, *formatList; int funcCount, styleCount, fontCount, formatCount, borderFont = fBorderFontID; bool warnForIncorrectFormula = true; scCell cl; styleCount = 0; styleList = (int *)MALLOC(0); fontCount = 0; fontList = (int *)MALLOC(0); formatCount = 0; formatList = (int *)MALLOC(0); funcList = NULL; scCSElement *colStyles = NULL; int colStyleCount = 0; offset = 0; StProgress progress(this, 1, pColorYellow, false); StWriteLock lock(fContainer); try { stream.Seek(offset, SEEK_SET); str >> chunk; if (chunk.type == kscVersion) { scVersion vers; str >> vers; if (vers.major != 3) THROW((errTooNewFileFormat)); } else THROW((errUnknownFileFormat, ((CCellWindow *)Window())->EntryRef()->name)); do { if (stream.Seek(offset, SEEK_SET) < offset) { MStopAlert("File is too short").Go(); break; } str >> chunk; offset += 4 + chunk.size; switch (chunk.type) { case kscVersion: break; case kscHeader: { scHeader head; str >> head; funcList = (int *)CALLOC(head.functionCount, sizeof(int)); FailNil(funcList); funcCount = head.functionCount; progress.NewMax(head.cellCount); break; } case kscView: { scView view; str >> view; if (view.windowRect.left > 0 && view.windowRect.top > 0) { BRect r; { r = BScreen().Frame(); } r.InsetBy(4, 4); r = r & view.windowRect; if (r.IsValid() && r.Width() >= 300 && r.Height() >= 100) { Window()->MoveTo(r.left, r.top); Window()->ResizeTo(r.Width(), r.Height()); } } if (view.position.h > 0 && view.position.v > 0) fPosition = view.position; fFrozen = view.frozen; if (view.selection.IsValid()) fSelection = view.selection; if (fSelection.Contains(view.curCell)) fCurCell = view.curCell; borderFont = view.headingFont; fShowGrid = (view.flags & kscShowGrid) != 0; fShowBorders = (view.flags & kscShowHeadings) != 0; if (!fShowBorders) { fCellBounds.left -= fBorderWidth; fCellBounds.top -= fBorderHeight; } Window()->Show(); Window()->UpdateIfNeeded(); break; } case kscPrint: break; case kscWidths: case kscHeights: { int count = chunk.size/(sizeof(short)*2); scWidthElement *elems = (scWidthElement *)MALLOC(chunk.size); FailNil(elems); int k = count * sizeof(scWidthElement); stream.Read(elems, k); if (chunk.type == kscWidths) fCellWidths.Read(count, elems); else fCellHeights.Read(count, elems); FREE(elems); break; } case kscColStyles: { colStyleCount = chunk.size/(sizeof(short)*2); colStyles = (scCSElement *)MALLOC(chunk.size); FailNil(colStyles); for (int i = 0; i < colStyleCount; i++) str >> colStyles[i]; break; } case kscName: { char buf[50]; scName *name = (scName *)buf; int l = std::min((int)chunk.size, 50); stream.Read(name, l); range r; memcpy(&r, name->reference+1, sizeof(cell)); if (name->reference[0] == valRange) memcpy(&r.bottom, name->reference+5, sizeof(cell)); else r.BotRight() = r.TopLeft(); swap_order(r); if (fNames->count(name->name) == 0) (*fNames)[CName(name->name)] = r; break; } case kscFunc: { scFunc func; str >> func; if (!funcList) THROW((errCorruptedFile)); if (func.funcNr >= funcCount) THROW((errCorruptedFile)); funcList[func.funcNr] = GetFunctionNr(func.name); if (funcList[func.funcNr] == -1) WarnForMissingFunction(func.name); break; } case kscFont: { scFont font; str >> font; font_family fam; font_style sty; ReadCString(stream, sizeof(font_style), sty); ReadCString(stream, sizeof(font_family), fam); int *t = (int *)REALLOC(fontList, (fontCount+1)*sizeof(int)); FailNil(t); fontList = t; fontList[fontCount] = gFontSizeTable.GetFontID( fam, sty, font.size, font.color); fontCount++; break; } case kscFormat: { scFormat format; str >> format; int *t = (int *)REALLOC(formatList, (formatCount+1)*sizeof(int)); FailNil(t); formatList = t; if (format.nr < eFirstNewFormat) formatList[formatCount] = format.nr; else { char fs[256]; ReadCString(stream, 255, fs); formatList[formatCount] = gFormatTable.GetFormatID(fs); } formatCount++; break; } case kscStyle: { scStyle style; str >> style; int *t = (int *)REALLOC(styleList, (styleCount+1)*sizeof(int)); FailNil(t); styleList = t; CellStyle cs; if (style.font >= fontCount) THROW((errCorruptedFile)); cs.fFont = fontList[style.font]; if (style.format >= formatCount) THROW((errCorruptedFile)); cs.fFormat = formatList[style.format]; cs.fAlignment = style.align; cs.fLowColor = style.lowColor; cs.fLocked = (style.flags & kscLocked) != 0; cs.fHidden = (style.flags & kscHidden) != 0; styleList[styleCount] = gStyleTable.GetStyleID(cs); styleCount++; break; } case kscCellEmpty: case kscCellBool: case kscCellNumber: case kscCellDateTime: case kscCellText: { str >> cl; Value val; switch (chunk.type) { case kscCellBool: { bool b; str >> b; val = b; break; } case kscCellNumber: { double d; str >> d; val = d; break; } case kscCellDateTime: { time_t t; str >> t; val = t; break; } case kscCellText: { // do nothing yet... } } fContainer->NewCell(cl.loc, val, NULL); if (cl.style >= styleCount) /*THROW((errCorruptedFile))*/; else fContainer->SetCellStyleNr(cl.loc, styleList[cl.style]); progress.Step(); break; } case kscString: { char s[256]; Value val; stream.Read(s, std::min((int)chunk.size, 255)); s[std::min((int)chunk.size, 255)] = 0; val = s; fContainer->SetValue(cl.loc, val); break; } case kscFormula: { CFormula form; try { if (!funcList) THROW((errCorruptedFile)); form.Read(stream, funcList); Value v; form.Calculate(cl.loc, v, fContainer); fContainer->SetCellFormula(cl.loc, form.CopyString()); } catch (CErr& e) { CATCHED; char s[32]; cl.loc.GetName(s); #if DEBUG printf("%s in formula of cell %s\n", (char *)e, s); #endif if (warnForIncorrectFormula) { char m[256]; sprintf(m, GetMessage(msgIncorrectFormula), s); MAlert *a = new MWarningAlert(m, GetMessage(msgOK), GetMessage(msgNoMoreWarnings)); if (a->Go() == 2) warnForIncorrectFormula = false; } } form.Clear(); break; } case kscChart: ReadChart(stream, chunk.size); case kscEnd: break; default: MStopAlert("File contains errors").Go(); chunk.type = kscEnd; break; } } while (chunk.type != kscEnd); // adjust the fields that couldn't be adjusted before if (fontCount && borderFont < fontCount) fBorderFontID = fontList[borderFont]; if (colStyles && styleList) { for (int i = 0; i < colStyleCount; i++) { if (colStyles[i].style >= 0 && colStyles[i].style < styleCount) colStyles[i].style = styleList[colStyles[i].style]; } fContainer->GetColumnStyles().Read(colStyleCount, colStyles); } }
//--------------------------------------------------------------------------- // @function: // CPredicateUtilsTest::EresUnittest_Implication // // @doc: // Test removal of implied predicates // //--------------------------------------------------------------------------- GPOS_RESULT CPredicateUtilsTest::EresUnittest_Implication() { CAutoMemoryPool amp; IMemoryPool *mp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( mp, &mda, NULL, /* pceeval */ CTestUtils::GetCostModel(mp) ); // generate a two cascaded joins CWStringConst strName1(GPOS_WSZ_LIT("Rel1")); CMDIdGPDB *pmdid1 = GPOS_NEW(mp) CMDIdGPDB(GPOPT_TEST_REL_OID1, 1, 1); CTableDescriptor *ptabdesc1 = CTestUtils::PtabdescCreate(mp, 3, pmdid1, CName(&strName1)); CWStringConst strAlias1(GPOS_WSZ_LIT("Rel1")); CExpression *pexprRel1 = CTestUtils::PexprLogicalGet(mp, ptabdesc1, &strAlias1); CWStringConst strName2(GPOS_WSZ_LIT("Rel2")); CMDIdGPDB *pmdid2 = GPOS_NEW(mp) CMDIdGPDB(GPOPT_TEST_REL_OID2, 1, 1); CTableDescriptor *ptabdesc2 = CTestUtils::PtabdescCreate(mp, 3, pmdid2, CName(&strName2)); CWStringConst strAlias2(GPOS_WSZ_LIT("Rel2")); CExpression *pexprRel2 = CTestUtils::PexprLogicalGet(mp, ptabdesc2, &strAlias2); CWStringConst strName3(GPOS_WSZ_LIT("Rel3")); CMDIdGPDB *pmdid3 = GPOS_NEW(mp) CMDIdGPDB(GPOPT_TEST_REL_OID3, 1, 1); CTableDescriptor *ptabdesc3 = CTestUtils::PtabdescCreate(mp, 3, pmdid3, CName(&strName3)); CWStringConst strAlias3(GPOS_WSZ_LIT("Rel3")); CExpression *pexprRel3 = CTestUtils::PexprLogicalGet(mp, ptabdesc3, &strAlias3); CExpression *pexprJoin1 = CTestUtils::PexprLogicalJoin<CLogicalInnerJoin>(mp, pexprRel1, pexprRel2); CExpression *pexprJoin2 = CTestUtils::PexprLogicalJoin<CLogicalInnerJoin>(mp, pexprJoin1, pexprRel3); { CAutoTrace at(mp); at.Os() << "Original expression:" << std::endl << *pexprJoin2 <<std::endl; } // imply new predicates by deriving constraints CExpression *pexprConstraints = CExpressionPreprocessor::PexprAddPredicatesFromConstraints(mp, pexprJoin2); { CAutoTrace at(mp); at.Os() << "Expression with implied predicates:" << std::endl << *pexprConstraints <<std::endl;; } // minimize join predicates by removing implied conjuncts CExpressionHandle exprhdl(mp); exprhdl.Attach(pexprConstraints); CExpression *pexprMinimizedPred = CPredicateUtils::PexprRemoveImpliedConjuncts(mp, (*pexprConstraints)[2], exprhdl); { CAutoTrace at(mp); at.Os() << "Minimized join predicate:" << std::endl << *pexprMinimizedPred <<std::endl; } CExpressionArray *pdrgpexprOriginalConjuncts = CPredicateUtils::PdrgpexprConjuncts(mp, (*pexprConstraints)[2]); CExpressionArray *pdrgpexprNewConjuncts = CPredicateUtils::PdrgpexprConjuncts(mp, pexprMinimizedPred); GPOS_ASSERT(pdrgpexprNewConjuncts->Size() < pdrgpexprOriginalConjuncts->Size()); // clean up pdrgpexprOriginalConjuncts->Release(); pdrgpexprNewConjuncts->Release(); pexprJoin2->Release(); pexprConstraints->Release(); pexprMinimizedPred->Release(); return GPOS_OK; }