nsresult
Http2Decompressor::OutputHeader(uint32_t index)
{
// bounds check
if (mHeaderTable.Length() <= index)
return NS_ERROR_ILLEGAL_VALUE;
return OutputHeader(mHeaderTable[index]->mName,
mHeaderTable[index]->mValue);
}
nsresult
Http2Decompressor::DecodeHeaderBlock(const uint8_t *data, uint32_t datalen,
nsACString &output)
{
mAlternateReferenceSet.Clear();
mOffset = 0;
mData = data;
mDataLen = datalen;
mOutput = &output;
mOutput->Truncate();
mHeaderStatus.Truncate();
mHeaderHost.Truncate();
mHeaderScheme.Truncate();
mHeaderPath.Truncate();
mHeaderMethod.Truncate();
nsresult rv = NS_OK;
while (NS_SUCCEEDED(rv) && (mOffset < datalen)) {
if (mData[mOffset] & 0x80) {
rv = DoIndexed();
LOG(("Decompressor state after indexed"));
} else if (mData[mOffset] & 0x40) {
rv = DoLiteralWithIncremental();
LOG(("Decompressor state after literal with incremental"));
} else if (mData[mOffset] & 0x20) {
rv = DoContextUpdate();
LOG(("Decompressor state after context update"));
} else if (mData[mOffset] & 0x10) {
rv = DoLiteralNeverIndexed();
LOG(("Decompressor state after literal never index"));
} else {
rv = DoLiteralWithoutIndex();
LOG(("Decompressor state after literal without index"));
}
DumpState();
}
// after processing the input the decompressor comapres the alternate
// set to the inherited reference set and generates headers for
// anything implicit in reference - alternate.
uint32_t setLen = mReferenceSet.Length();
for (uint32_t index = 0; index < setLen; ++index) {
if (!mAlternateReferenceSet.Contains(mReferenceSet[index])) {
LOG(("HTTP decompressor carryover in reference set with index %u %s %s\n",
mReferenceSet[index],
mHeaderTable[mReferenceSet[index]]->mName.get(),
mHeaderTable[mReferenceSet[index]]->mValue.get()));
OutputHeader(mReferenceSet[index]);
}
}
mAlternateReferenceSet.Clear();
return rv;
}
nsresult
Http2Decompressor::OutputHeader(uint32_t index)
{
// NWGH - make this < index
// bounds check
if (mHeaderTable.Length() <= index) {
LOG(("Http2Decompressor::OutputHeader index too large %u", index));
return NS_ERROR_ILLEGAL_VALUE;
}
return OutputHeader(mHeaderTable[index]->mName,
mHeaderTable[index]->mValue);
}
void OutputByAttribute (SItemTableCtx &Ctx, const SItemTypeList &ItemList)
{
int i, j;
// Make a categorized list by attribute
SByAttributeTypeList ByAttributeTable;
for (i = 0; i < ItemList.GetCount(); i++)
{
const CString &sKey = ItemList.GetKey(i);
CItemType *pType = ItemList[i];
// Loop over all attributes
TArray<CString> Attribs;
ParseAttributes(pType->GetAttributes(), &Attribs);
for (j = 0; j < Attribs.GetCount(); j++)
{
bool bNew;
SAttributeEntry *pEntry = ByAttributeTable.SetAt(Attribs[j], &bNew);
if (bNew)
pEntry->sAttribute = Attribs[j];
pEntry->ItemTable.Insert(sKey, pType);
}
// If no attribute
if (Attribs.GetCount() == 0)
{
bool bNew;
SAttributeEntry *pEntry = ByAttributeTable.SetAt(CONSTLIT("(none)"), &bNew);
if (bNew)
pEntry->sAttribute = CONSTLIT("(none)");
pEntry->ItemTable.Insert(sKey, pType);
}
}
// Now loop over all attributes
for (i = 0; i < ByAttributeTable.GetCount(); i++)
{
const SAttributeEntry &Entry = ByAttributeTable[i];
printf("%s\n\n", Entry.sAttribute.GetASCIIZPointer());
OutputHeader(Ctx);
OutputTable(Ctx, Entry.ItemTable);
printf("\n");
}
}
void GenerateItemTable (CUniverse &Universe, CXMLElement *pCmdLine)
{
// Create the context
SItemTableCtx Ctx;
Ctx.pUniverse = &Universe;
Ctx.pCmdLine = pCmdLine;
// Compute the criteria
TArray<CItemType *> Selection;
SelectByCriteria(Ctx, pCmdLine->GetAttribute(CRITERIA_ATTRIB), &Selection);
if (Selection.GetCount() == 0)
{
printf("No entries match criteria.\n");
return;
}
// Compute columns
if (!CalcColumns(Ctx, pCmdLine))
return;
// Sort the list
SItemTypeList ItemList;
SortTable(Ctx, Selection, &ItemList);
// If by attribute, output categorized list
if (pCmdLine->GetAttributeBool(BY_ATTRIBUTE_ATTRIB))
OutputByAttribute(Ctx, ItemList);
else if (pCmdLine->GetAttributeBool(BY_SHIP_CLASS_ATTRIB))
OutputByShipClass(Ctx, ItemList, false);
else if (pCmdLine->GetAttributeBool(BY_SHIP_CLASS_USAGE_ATTRIB))
OutputByShipClass(Ctx, ItemList, true);
// Otherwise, just output a full table
else
{
OutputHeader(Ctx);
OutputTable(Ctx, ItemList);
}
printf("\n");
}
void OutputByShipClass (SItemTableCtx &Ctx, const SItemTypeList &ItemList, bool bShowUsage)
{
int i, j;
// Make a map of ship classes for each item
TSortMap<DWORD, TArray<CShipClass *>> ItemToShipClass;
for (i = 0; i < g_pUniverse->GetShipClassCount(); i++)
{
CShipClass *pClass = g_pUniverse->GetShipClass(i);
// Skip non-generic ones
if (!pClass->HasLiteralAttribute(CONSTLIT("genericClass")))
continue;
// Add the list of types used by the ship
TSortMap<DWORD, bool> TypesUsed;
pClass->AddTypesUsed(&TypesUsed);
// For each item type, add it to the map
for (j = 0; j < TypesUsed.GetCount(); j++)
{
CDesignType *pType = g_pUniverse->FindDesignType(TypesUsed.GetKey(j));
if (pType && pType->GetType() == designItemType)
{
TArray<CShipClass *> *pList = ItemToShipClass.SetAt(pType->GetUNID());
pList->Insert(pClass);
}
}
}
// If we want to show usage, then we print each item along with the
// ship classes using each item.
if (bShowUsage)
{
for (i = 0; i < ItemList.GetCount(); i++)
{
CItemType *pType = ItemList[i];
printf("%s\n", (LPSTR)pType->GetNounPhrase());
TArray<CShipClass *> *pList = ItemToShipClass.SetAt(pType->GetUNID());
for (j = 0; j < pList->GetCount(); j++)
printf("\t%s\n", (LPSTR)pList->GetAt(j)->GetName());
if (pList->GetCount() == 0)
printf("\t(none)\n");
printf("\n");
}
}
// Otherwise we categorize by ship class
else
{
// Now make a list of all ship classes that have our items
SByShipClassTypeList ByShipClassTable;
for (i = 0; i < ItemList.GetCount(); i++)
{
const CString &sKey = ItemList.GetKey(i);
CItemType *pType = ItemList[i];
// Loop over all ship classes
TArray<CShipClass *> *pList = ItemToShipClass.SetAt(pType->GetUNID());
for (j = 0; j < pList->GetCount(); j++)
{
CString sClassName = pList->GetAt(j)->GetName();
bool bNew;
SShipClassEntry *pEntry = ByShipClassTable.SetAt(sClassName, &bNew);
if (bNew)
pEntry->sShipClassName = sClassName;
pEntry->ItemTable.Insert(sKey, pType);
}
// If no ship class
if (pList->GetCount() == 0)
{
bool bNew;
SShipClassEntry *pEntry = ByShipClassTable.SetAt(CONSTLIT("(none)"), &bNew);
if (bNew)
pEntry->sShipClassName = CONSTLIT("(none)");
pEntry->ItemTable.Insert(sKey, pType);
}
}
// Now loop over all attributes
for (i = 0; i < ByShipClassTable.GetCount(); i++)
{
const SShipClassEntry &Entry = ByShipClassTable[i];
printf("%s\n\n", Entry.sShipClassName.GetASCIIZPointer());
OutputHeader(Ctx);
OutputTable(Ctx, Entry.ItemTable);
printf("\n");
}
}
}
bool PovrayFormat::WriteMolecule(OBBase* pOb, OBConversion* pConv)
{
OBMol* pmol = dynamic_cast<OBMol*>(pOb);
if(pmol==NULL)
return false;
// Model-type should be one of "bas", "spf" or "cas"
model_type = "BAS"; // Default is ball-and-stick
const char* tmp = pConv->IsOption("m");
if (tmp) {
model_type = string(tmp);
// Convert to uppercase
std::transform(model_type.begin(), model_type.end(), model_type.begin(), static_cast< int(*)(int) >(std::toupper));
if (model_type != "BAS" && model_type != "SPF" && model_type != "CST") {
obErrorLog.ThrowError(__FUNCTION__, "Unknown model type specified. Using the default instead (\"BAS\", ball-and-stick).\n",obWarning);
model_type = "BAS";
}
}
// Set private class variables for options
trans_texture = pConv->IsOption("t") ? true : false;
sky = pConv->IsOption("s") ? true : false;
checkerboard = pConv->IsOption("c") ? true : false;
sphere = pConv->IsOption("f") ? true : false;
//Define some references so we can use the old parameter names
ostream &ofs = *pConv->GetOutStream();
OBMol &mol = *pmol;
const char* title = pmol->GetTitle();
static long num = 0;
double min_x, max_x, min_y, max_y, min_z, max_z; /* Edges of bounding box */
/* ---- We use mol_${num}_ as our prefix ---- */
stringstream ss;
ss << "mol_" << num;
string prefix = ss.str();
/* ---- Check if we have already written a molecule to this file ---- */
if (num == 0)
{
/* ---- Print the header ---- */
OutputHeader(ofs, mol, prefix);
}
else
{
/* ---- Convert the unique molecule-number to a string and set the prefix ---- */
ostringstream numStr;
numStr << num << ends;
prefix += numStr.str().c_str();
}
/* ---- Print positions and descriptions of all atoms ---- */
OutputAtoms(ofs, mol, prefix);
/* ---- Check #bonds ---- */
if (mol.NumBonds() > 0)
{
/* ---- Write an comment ---- */
ofs << "//Povray-description of bonds 1 - " << mol.NumBonds() << endl;
/* ---- Do a ball and sticks model? ---- */
ofs << "#if (BAS)" << endl;
/* ---- Print bonds using "ball and sticks style" ---- */
OutputBASBonds(ofs, mol, prefix);
/* ---- End of povray-conditional for ball and sticks ---- */
ofs << "#end //(BAS-Bonds)" << endl << endl;
/* ---- Do a capped-sticks model? ---- */
ofs << "#if (CST)" << endl;
/* ---- Print bonds using "capped sticks style" ---- */
OutputCSTBonds(ofs, mol, prefix);
/* ---- End of povray-conditional for capped sticks ---- */
ofs << "#end // (CST-Bonds)" << endl << endl;
}
/* ---- Print out unions of atoms and bonds ---- */
OutputUnions(ofs, mol, prefix);
/* ---- Calculate bounding-box ---- */
CalcBoundingBox(mol, min_x, max_x, min_y, max_y, min_z, max_z);
/* ---- Check #bonds ---- */
if (mol.NumBonds() > 0)
{
/* ---- Print out description of molecule ---- */
OutputMoleculeBonds(ofs,
prefix,
min_x, max_x,
min_y, max_y,
min_z, max_z);
}
else
{
/* ---- Now we can define the molecule without bonds ---- */
OutputMoleculeNoBonds(ofs, prefix);
}
/* ---- Insert declaration for centering the molecule ---- */
OutputCenterComment(ofs,
prefix,
min_x, max_x,
min_y, max_y,
min_z, max_z);
/* ---- Insert the molecule ---- */
ofs << prefix << endl;
/* ---- Increment the static molecule output-counter ---- */
num++;
/* ---- Everything is ok! ---- */
return(true);
}
