void Class::Coding(FormatStream& fos) const { auto itPrev = Fields().rbegin(); for(auto itField = Fields().rbegin() + 1; itField != Fields().rend(); ++itField) { (*itField)->SetNext(*itPrev); itPrev = itField; } CodingSerialize2Array(fos); CodingSerialize2CodedStream(fos); CodingDeserialize(fos); CodingByteSize(fos); fos.BaseStream()<<std::endl; }
// returns the content of the header in unicode (decoded) String MimeHeader::GetUnicodeHeaderContents() { String sResponse; // Iterate through the header fields and add to sResponse. std::vector<MimeField> oFields = Fields(); std::vector<MimeField>::iterator iterField = oFields.begin(); while (iterField != oFields.end()) { AnsiString sHeaderField = (*iterField).GetName(); AnsiString sHeaderValue = (*iterField).GetValue(); String decodedValue = GetUnicodeFieldValue(sHeaderField, sHeaderValue); sResponse += String(sHeaderField) + _T(": ") + decodedValue + _T("\r\n"); iterField++; } sResponse += "\r\n"; return sResponse; }
/** * * * @param buf */ void TableRecord::Unpack(const char *buf) { int sbyte = 0; for (int f=0; f<Fields(); f++) { Isis::TableField &field = p_fields[f]; field = (void *)&buf[sbyte]; sbyte += field.Bytes(); } }
bool FieldsModel::readOffLineFields() { QFile wntlist(FIELDS_FILENAME); if (wntlist.exists()) //Если есть файл с данными, читаем из него { if(!wntlist.open(QIODevice::ReadOnly)) { qDebug() << "Couldn`t open fieldsfile "; return false; } else { QByteArray saveData = wntlist.readAll(); wntlist.close(); QJsonDocument loadDoc(QJsonDocument::fromJson(saveData)); QJsonArray result = loadDoc.array(); qDebug() << "Releases in Json " <<result; if (result.size()>0) { emit beginInsertRows(QModelIndex(), rowCount(), rowCount()+result.size()-1); for (QJsonArray::const_iterator iter = result.begin();iter!= result.end(); ++iter) { const QJsonObject o = (*iter).toObject(); QJsonArray options = o["options"].toArray(); QStringList i_options; for (int i=0; i<options.size();i++) { i_options << options.at(i).toString(); } bool i_isDropdown; if (o["type"].toString()=="dropdown") i_isDropdown = true; else i_isDropdown = false; m_Fields << Fields(o["name"].toString(), i_options, o["id"].toInt(), o["position"].toInt(), o["type"].toString(), o["public"].toBool(), o["lines"].toInt(), i_isDropdown); } emit endInsertRows(); } O1Requestor::instance().setIsOffline(true); // Признак того что работаем в оффлайне emit isOfflineChanged(); return true; } } return false; }
void CmyWord::UpdateField(CString strBMark) { COleVariant varBMark_del(strBMark); //设置变量 Bookmarks bookmarks = m_wdDoc.GetBookmarks(); if(!bookmarks.Exists((LPCTSTR)strBMark)) { return; } m_wdSel.GoTo(COleVariant(short(1),VT_BOOL),COleVariant((short)0),COleVariant((short)0),varBMark_del); Fields fields = Fields(m_wdSel.GetFields()); fields.Update(); bookmarks.ReleaseDispatch(); }
//--------------------------------------------------------- int CTable_Query_GUI::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter) { if( pParameter->Cmp_Identifier("TABLES") ) { CSG_Parameters &Tables = *pParameters->Get_Parameter("TABLES")->asParameters(); CSG_Parameters &Fields = *pParameters->Get_Parameter("FIELDS")->asParameters(); CSG_Parameters &Group = *pParameters->Get_Parameter("GROUP" )->asParameters(); for(int i=0; i<Tables.Get_Count(); i++) { CSG_String Table = Tables[i].Get_Identifier(); if( Tables[i].asBool() && !Fields(Table) ) { CSG_Table Desc = Get_Connection()->Get_Field_Desc(Table); CSG_Parameter *pFields = Fields.Add_Node("", Table, Table, ""); CSG_Parameter *pGroup = Group .Add_Node("", Table, Table, ""); for(int j=0; j<Desc.Get_Count(); j++) { CSG_String ID = Table + "." + Desc[j].asString(0); Fields.Add_Bool(pFields, ID, Desc[j].asString(0), ""); Group .Add_Bool(pGroup , ID, Desc[j].asString(0), ""); } } else if( !Tables[i].asBool() && Fields(Table) ) { Fields.Del_Parameter(Table); Group .Del_Parameter(Table); } } } return( CSG_PG_Tool::On_Parameter_Changed(pParameters, pParameter) ); }
//--------------------------------------------------------------------------- void File_Ibi::InformData() { Element_Name("InformData"); //Parsing Ztring InformData_FromFile; Get_UTF8 (Element_Size, InformData_FromFile, "Data"); //Filling #if MEDIAINFO_IBIUSAGE if (Config->Ibi_UseIbiInfoIfAvailable_Get()) { ZtringListList Fields(InformData_FromFile); for (size_t Pos=0; Pos<Fields.size(); Pos++) { if (Pos==0 || Fields[Pos].size()<2) { if (Pos) Pos++; if (Pos>Fields.size() || Fields[Pos].size()<1) break; //End or problem if (Fields[Pos][0]==__T("General")) ; //Nothing to do else if (Fields[Pos][0]==__T("Video")) Stream_Prepare(Stream_Video); else if (Fields[Pos][0]==__T("Audio")) Stream_Prepare(Stream_Audio); else if (Fields[Pos][0]==__T("Text")) Stream_Prepare(Stream_Text); else if (Fields[Pos][0]==__T("Other")) Stream_Prepare(Stream_Other); else if (Fields[Pos][0]==__T("Image")) Stream_Prepare(Stream_Image); else if (Fields[Pos][0]==__T("Menu")) Stream_Prepare(Stream_Menu); else break; //Problem Pos++; } Fill(StreamKind_Last, StreamPos_Last, Fields[Pos][0].To_UTF8().c_str(), Fields[Pos][1], true); if (Info_Options<Fields[Pos].size()) (*Stream_More)[StreamKind_Last][StreamPos_Last](Fields[Pos][0].To_UTF8().c_str(), Info_Options)=Fields[Pos][Info_Options]; } } #endif //MEDIAINFO_IBIUSAGE }
/** * * * @param buf * * @throws Isis::iException::Programmer - Invalid field type */ void TableRecord::Pack(char *buf) const { int sbyte = 0; for (int f=0; f<Fields(); f++) { const Isis::TableField &field = p_fields[f]; if (field.IsDouble()) { vector<double> vals = field; for (unsigned int i=0; i<vals.size(); i++) { //*((double *)(buf+sbyte)) = vals[i]; memmove (buf+sbyte, &vals[i], 8); sbyte += sizeof(double); } } else if (field.IsInteger()) { vector<int> vals = field; for (unsigned int i=0; i<vals.size(); i++) { //*((int *)(buf+sbyte)) = vals[i]; memmove (buf+sbyte, &vals[i], 4); sbyte += sizeof(int); } } else if (field.IsText()) { string val = (string)field; for( int i=0; i<field.Size(); i++ ) { if( i < (int)val.length() ) { buf[sbyte] = val[i]; } else { buf[sbyte] = 0; } sbyte++; } } else if (field.IsReal()) { vector<float> vals = field; for (unsigned int i=0; i<vals.size(); i++) { //*((int *)(buf+sbyte)) = vals[i]; memmove (buf+sbyte, &vals[i], 4); sbyte += sizeof(float); } } else { string msg = "Invalid field type"; throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_); } } }
BLOCK_EX(fos,mSerialize2ArrayDeclare) { PreSerialize(fos); for(auto& pBase : Bases()) { fos<<"target = WireFormatLite::WriteUInt32NoTagToArray((uint32)ByteSizeInternal(static_cast<"<<pBase->Name()<<"&>(obj)),target);"<<std::endl; fos<<"target = Serialize2Array(target,static_cast<"<<pBase->Name()<<"&>(obj));"<<std::endl; } for(auto& pField : Fields()) { fos<<"//serialize "<<pField->Name()<<std::endl; pField->CodingSerialize2Array(fos); } PostSerialize(fos); fos<<"return target;"<<std::endl; }
/** expression without query parameters */ std::string operator()() { return std::string("SELECT ") + //helper::impl_select_part<0,Fields...>()() + Fields()() + std::string(" ") + From()() + (std::is_same<Where,none>::value ? std::string("") : Where()() + (std::is_same<GroupBy,none>::value ? std::string("") : GroupBy()() + (std::is_same<Having,none>::value ? std::string("") : Having()()))) + (std::is_same<OrderBy,none>::value ? std::string("") : OrderBy()()); }
/** * * * @param buf * * @throws Isis::iException::Programmer - Invalid field type */ void TableRecord::Swap(char *buf) const { int sbyte = 0; for (int f=0; f<Fields(); f++) { const Isis::TableField &field = p_fields[f]; if (field.IsDouble()) { for (int i=0; i<field.Size(); i++) { char *swap = &buf[sbyte]; char temp; temp = swap[0]; swap[0] = swap[7]; swap[7] = temp; temp = swap[1]; swap[1] = swap[6]; swap[6] = temp; temp = swap[2]; swap[2] = swap[5]; swap[5] = temp; temp = swap[3]; swap[3] = swap[4]; swap[4] = temp; sbyte += sizeof(double); } } else if (field.IsInteger()) { for (int i=0; i<field.Size(); i++) { char *swap = &buf[sbyte]; char temp; temp = swap[0]; swap[0] = swap[3]; swap[3] = temp; temp = swap[1]; swap[1] = swap[2]; swap[2] = temp; sbyte += sizeof(int); } } else if (field.IsText()) { sbyte += field.Bytes(); } else if (field.IsReal()) { for (int i=0; i<field.Size(); i++) { char *swap = &buf[sbyte]; char temp; temp = swap[0]; swap[0] = swap[3]; swap[3] = temp; temp = swap[1]; swap[1] = swap[2]; swap[2] = temp; sbyte += sizeof(float); } } else { string msg = "Invalid field type"; throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_); } } }
IADOCEField* cADOCE::Item(long lColumn) { /////////////////////////////////////////////////////////////// // Return a given field from the Fields collection /////////////////////////////////////////////////////////////// VARIANT vColumn; VariantInit(&vColumn); vColumn.vt = VT_I4; pField = NULL; vColumn.lVal = lColumn; //Get the Fields Collection, if required if(!g_pFields) g_pFields = Fields(); // Retrieve the Item if(g_pFields) hr = g_pFields->get_Item(vColumn, &pField); // Return the Field Object return pField; }
///******************************************************************************************************* void FieldsModel::getFields() { bool error = false; QString strReply; QJsonArray fullResult; if(O1Requestor::instance().isLoggin()) { QNetworkRequest request(QUrl(O1Requestor::instance().value("collection_fields_url"))); if (!O1Requestor::instance().getWithWait(request,strReply, timeOut)) { qDebug() << "ERROR get Fields:"; error = true; } else { qDebug() << "Get Fields collection OK"; QJsonDocument jsonResponse = QJsonDocument::fromJson(strReply.toUtf8()); QJsonObject jsonObj = jsonResponse.object(); QJsonArray fields = jsonObj["fields"].toArray(); qDebug() << "Fields in Json " <<jsonObj; emit beginInsertRows(QModelIndex(), rowCount(), rowCount()+fields.size()-1); for (QJsonArray::const_iterator iter = fields.begin(); iter!= fields.end(); ++iter) { const QJsonObject o = (*iter).toObject(); QJsonArray options = o["options"].toArray(); QStringList i_options; for (int i=0; i<options.size();i++) { i_options << options.at(i).toString(); } bool i_isDropdown; if (o["type"].toString()=="dropdown") i_isDropdown = true; else i_isDropdown = false; m_Fields << Fields(o["name"].toString(), i_options, o["id"].toInt(), o["position"].toInt(), o["type"].toString(), o["public"].toBool(), o["lines"].toInt(), i_isDropdown); fullResult.append(o); } emit endInsertRows(); } if (!error) { //Пишем JSon в файл, если данные по сети были успешно считаны qDebug() << "Save Fields to file "; QFile fieldslist(FIELDS_FILENAME); if(!fieldslist.open(QIODevice::WriteOnly)) { qDebug() << "Couldn`t open file to save"; } else { QJsonDocument jsonToFile(fullResult); fieldslist.write(jsonToFile.toJson()); fieldslist.close(); } } else { // O1Requestor::instance().setIsLoggin(false); if(!readOffLineFields()) {O1Requestor::instance().setIsOffline(false); emit isOfflineChanged();} } } else { if(O1Requestor::instance().onlinked()) { if (!readOffLineFields()) {O1Requestor::instance().setIsOffline(false); emit isOfflineChanged();} } } }
Header Project::header() { return strategy == COPY ? source->header().project(flds) : Header(lisp(Fields(), flds), flds); }
Header HistoryTable::header() { return Header(lisp(Fields(), lisp(gcstring("_date"), gcstring("_action")), Fields(), theDB()->get_fields(table)), columns()); }
*/ #include "ItoaWidget.h" BEGIN_NAMESPACE(itoa) ///////////////////////////////////////////////// FreeLayoutParams #define JB_CURRENT_CLASS FreeLayoutParams JB_DEFINE_WRAPPER_CLASS( "com/itoa/FreeLayout$LayoutParams" , Fields ( Matrix, "matrix","Landroid/graphics/Matrix;" ) , Methods ( Constructor, "<init>", "(IILandroid/graphics/Matrix;)V" ) ) FreeLayoutParams::FreeLayoutParams(): ViewLayoutParams(JB_NEW(Constructor,0,0,0)) { }
std::map<SortBy, Fields> fillSortingFields() { std::map<SortBy, Fields> sortingFields; sortingFields.insert(std::pair<SortBy, Fields>(SortByNone, Fields())); sortingFields[SortByLabel].insert(FieldLabel); sortingFields[SortByDate].insert(FieldDate); sortingFields[SortBySize].insert(FieldSize); sortingFields[SortByFile].insert(FieldPath); sortingFields[SortByFile].insert(FieldStartOffset); sortingFields[SortByPath].insert(FieldPath); sortingFields[SortByPath].insert(FieldStartOffset); sortingFields[SortByDriveType].insert(FieldDriveType); sortingFields[SortByTitle].insert(FieldTitle); sortingFields[SortByTrackNumber].insert(FieldTrackNumber); sortingFields[SortByTime].insert(FieldTime); sortingFields[SortByArtist].insert(FieldArtist); sortingFields[SortByArtist].insert(FieldYear); sortingFields[SortByArtist].insert(FieldAlbum); sortingFields[SortByArtist].insert(FieldTrackNumber); sortingFields[SortByArtistThenYear].insert(FieldArtist); sortingFields[SortByArtistThenYear].insert(FieldYear); sortingFields[SortByArtistThenYear].insert(FieldAlbum); sortingFields[SortByArtistThenYear].insert(FieldTrackNumber); sortingFields[SortByAlbum].insert(FieldAlbum); sortingFields[SortByAlbum].insert(FieldArtist); sortingFields[SortByAlbum].insert(FieldTrackNumber); sortingFields[SortByAlbumType].insert(FieldAlbumType); sortingFields[SortByGenre].insert(FieldGenre); sortingFields[SortByCountry].insert(FieldCountry); sortingFields[SortByYear].insert(FieldYear); sortingFields[SortByYear].insert(FieldAirDate); sortingFields[SortByYear].insert(FieldAlbum); sortingFields[SortByYear].insert(FieldTrackNumber); sortingFields[SortByRating].insert(FieldRating); sortingFields[SortByVotes].insert(FieldVotes); sortingFields[SortByTop250].insert(FieldTop250); sortingFields[SortByProgramCount].insert(FieldProgramCount); sortingFields[SortByPlaylistOrder].insert(FieldProgramCount); sortingFields[SortByEpisodeNumber].insert(FieldEpisodeNumber); sortingFields[SortByEpisodeNumber].insert(FieldSeason); sortingFields[SortByEpisodeNumber].insert(FieldEpisodeNumberSpecialSort); sortingFields[SortByEpisodeNumber].insert(FieldSeasonSpecialSort); sortingFields[SortByEpisodeNumber].insert(FieldTitle); sortingFields[SortByEpisodeNumber].insert(FieldSortTitle); sortingFields[SortBySeason].insert(FieldSeason); sortingFields[SortBySeason].insert(FieldSeasonSpecialSort); sortingFields[SortByNumberOfEpisodes].insert(FieldNumberOfEpisodes); sortingFields[SortByNumberOfWatchedEpisodes].insert(FieldNumberOfWatchedEpisodes); sortingFields[SortByTvShowStatus].insert(FieldTvShowStatus); sortingFields[SortByTvShowTitle].insert(FieldTvShowTitle); sortingFields[SortBySortTitle].insert(FieldSortTitle); sortingFields[SortBySortTitle].insert(FieldTitle); sortingFields[SortByProductionCode].insert(FieldProductionCode); sortingFields[SortByMPAA].insert(FieldMPAA); sortingFields[SortByVideoResolution].insert(FieldVideoResolution); sortingFields[SortByVideoCodec].insert(FieldVideoCodec); sortingFields[SortByVideoAspectRatio].insert(FieldVideoAspectRatio); sortingFields[SortByAudioChannels].insert(FieldAudioChannels); sortingFields[SortByAudioCodec].insert(FieldAudioCodec); sortingFields[SortByAudioLanguage].insert(FieldAudioLanguage); sortingFields[SortBySubtitleLanguage].insert(FieldSubtitleLanguage); sortingFields[SortByStudio].insert(FieldStudio); sortingFields[SortByDateAdded].insert(FieldDateAdded); sortingFields[SortByDateAdded].insert(FieldId); sortingFields[SortByLastPlayed].insert(FieldLastPlayed); sortingFields[SortByPlaycount].insert(FieldPlaycount); sortingFields[SortByListeners].insert(FieldListeners); sortingFields[SortByBitrate].insert(FieldBitrate); sortingFields[SortByChannel].insert(FieldChannelName); sortingFields[SortByChannelNumber].insert(FieldChannelNumber); sortingFields[SortByDateTaken].insert(FieldDateTaken); sortingFields.insert(std::pair<SortBy, Fields>(SortByRandom, Fields())); return sortingFields; }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Operand* ConstantFolder::LoadFromAddress(Operand* op, const Type* loadType, __int64 offset) { // If the operand has a defining instruction then we try to compute // the offset from which we should load. If it's a variable reference // we try to load from the offset that was already computed. if(op->HasDefiningInstruction() == false) { return LoadFromGlobal(op, loadType, offset); } auto instr = op->DefiningInstruction(); switch(instr->GetOpcode()) { case Instr_Index: { // If the index operand is not a constant give up. auto indexInstr = instr->As<IndexInstr>(); auto indexConst = indexInstr->IndexOp()->As<IntConstant>(); if(indexConst == nullptr) { return nullptr; } // The type of the base is 'pointer-to-array', so we need to strip the pointer. auto elementType = indexInstr->GetElementType(); __int64 index = indexConst->Value(); __int64 elemSize = TypeInfo::GetSize(elementType, target_); // The offset is incremented by the index multiplied with the element size. __int64 newOffset = offset + (index * elemSize); return LoadFromAddress(indexInstr->BaseOp(), loadType, newOffset); } case Instr_Element: { auto elemInstr = instr->As<ElementInstr>(); __int64 index = elemInstr->GetFieldIndex(); // The type of the base is 'pointer-to-record', // so we need to strip the pointer. auto recordType = elemInstr->GetRecordType(); // Obtain the offset of the selected field. // The new offset is the old one added with the field offset. __int64 fieldOffset = recordType->Fields()[index].FieldOffset; __int64 newOffset = offset + fieldOffset; return LoadFromAddress(elemInstr->BaseOp(), loadType, newOffset); } case Instr_Address: { // If the index operand is not a constant give up. auto addrInstr = instr->As<AddressInstr>(); auto indexConst = addrInstr->IndexOp()->As<IntConstant>(); if(indexConst == nullptr) { return nullptr; } // The type of the base is 'pointer-to-object', // so we need to strip the pointer. auto objectType = addrInstr->GetPointeeType(); __int64 index = indexConst->Value(); __int64 elemSize = TypeInfo::GetSize(objectType, target_); // The offset is incremented by the index multiplied with the object size. __int64 newOffset = offset + (index * elemSize); return LoadFromAddress(addrInstr->BaseOp(), loadType, newOffset); } case Instr_Ptop: { // This instruction is ignored (the previous recursion step // has already taken care about its effects). auto ptopInstr = instr->As<PtopInstr>(); auto targetInstr = ptopInstr->TargetOp()->DefiningInstruction(); return LoadFromAddress(ptopInstr->TargetOp(), loadType, offset); } case Instr_Load: { // This happens when the variable is a pointer. auto loadInstr = instr->As<LoadInstr>(); return LoadFromAddress(loadInstr->SourceOp(), loadType, offset); } default: { // All other cases don't lead to a constant operand. return nullptr; } } }