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;
}
}
}
