StringPairArray ProjectExporter::getAllPreprocessorDefs() const { StringPairArray defs (mergePreprocessorDefs (project.getPreprocessorDefs(), parsePreprocessorDefs (getExporterPreprocessorDefsString()))); defs.set (getExporterIdentifierMacro(), "1"); return defs; }
StringPairArray ProjectExporter::getAllPreprocessorDefs (const ProjectExporter::BuildConfiguration& config) const { StringPairArray defs (mergePreprocessorDefs (config.getAllPreprocessorDefs(), parsePreprocessorDefs (getExporterPreprocessorDefsString()))); defs.set (getExporterIdentifierMacro(), "1"); return defs; }
StringPairArray mergePreprocessorDefs (StringPairArray inheritedDefs, const StringPairArray& overridingDefs) { for (int i = 0; i < overridingDefs.size(); ++i) inheritedDefs.set (overridingDefs.getAllKeys()[i], overridingDefs.getAllValues()[i]); return inheritedDefs; }
void SmugMug::login(const String& username, const String& password) { sessionId = String::empty; StringPairArray params; params.set(("EmailAddress"), username); params.set(("Password"), password); XmlElement* n = smugMugRequest(("smugmug.login.withPassword"), params); if (n) { XmlElement* l = n->getChildByName(("Login")); if (l) { accountType = l->getStringAttribute(("AccountType")); XmlElement* s = l->getChildByName(("Session")); if (s) { sessionId = s->getStringAttribute(("id")); addLogEntry(("Info: logged in session: ") + sessionId); } } delete n; } }
void ProjectExporter::addTargetSpecificPreprocessorDefs (StringPairArray& defs, const ProjectType::Target::Type targetType) const { std::pair<String, ProjectType::Target::Type> targetFlags[] = { {"JucePlugin_Build_VST", ProjectType::Target::VSTPlugIn}, {"JucePlugin_Build_VST3", ProjectType::Target::VST3PlugIn}, {"JucePlugin_Build_AU", ProjectType::Target::AudioUnitPlugIn}, {"JucePlugin_Build_AUv3", ProjectType::Target::AudioUnitv3PlugIn}, {"JucePlugin_Build_RTAS", ProjectType::Target::RTASPlugIn}, {"JucePlugin_Build_AAX", ProjectType::Target::AAXPlugIn}, {"JucePlugin_Build_Standalone", ProjectType::Target::StandalonePlugIn} }; if (targetType == ProjectType::Target::SharedCodeTarget) { for (auto& flag : targetFlags) defs.set (flag.first, (shouldBuildTargetType (flag.second) ? "1" : "0")); defs.set ("JUCE_SHARED_CODE", "1"); } else if (targetType != ProjectType::Target::unspecified) { for (auto& flag : targetFlags) defs.set (flag.first, (targetType == flag.second ? "1" : "0")); } }
static void findTimeSigEvents (MidiFile& midiFile, StringPairArray& midiMetadata) { MidiMessageSequence timeSigEvents; midiFile.findAllTimeSigEvents (timeSigEvents); const int numTimeSigEvents = timeSigEvents.getNumEvents(); MemoryOutputStream timeSigSequence; for (int i = 0; i < numTimeSigEvents; ++i) { int numerator, denominator; timeSigEvents.getEventPointer(i)->message.getTimeSignatureInfo (numerator, denominator); String timeSigString; timeSigString << numerator << '/' << denominator; if (i == 0) midiMetadata.set (CoreAudioFormat::timeSig, timeSigString); if (numTimeSigEvents > 1) timeSigSequence << timeSigString << ',' << timeSigEvents.getEventTime (i) << ';'; } if (timeSigSequence.getDataSize() > 0) midiMetadata.set ("time signature sequence", timeSigSequence.toUTF8()); }
static void findTempoEvents (MidiFile& midiFile, StringPairArray& midiMetadata) { MidiMessageSequence tempoEvents; midiFile.findAllTempoEvents (tempoEvents); const int numTempoEvents = tempoEvents.getNumEvents(); MemoryOutputStream tempoSequence; for (int i = 0; i < numTempoEvents; ++i) { const double tempo = getTempoFromTempoMetaEvent (tempoEvents.getEventPointer (i)); if (tempo > 0.0) { if (i == 0) midiMetadata.set (CoreAudioFormat::tempo, String (tempo)); if (numTempoEvents > 1) tempoSequence << String (tempo) << ',' << tempoEvents.getEventTime (i) << ';'; } } if (tempoSequence.getDataSize() > 0) midiMetadata.set ("tempo sequence", tempoSequence.toUTF8()); }
bool SmugMug::getImageUrls(SmugID id, ImageUrls& urls) { StringPairArray params; params.set(("ImageID"), String(id.id)); params.set(("ImageKey"), id.key); params.set(("Password"), ""); XmlElement* n = smugMugRequest(("smugmug.images.getURLs"), params); if (n) { XmlElement* img = n->getChildByName(("Image")); if (img) { urls.originalURL = img->getStringAttribute(("OriginalURL")); urls.largeURL = img->getStringAttribute(("LargeURL")); urls.mediumURL = img->getStringAttribute(("MediumURL")); urls.smallURL = img->getStringAttribute(("SmallURL")); urls.tinyURL = img->getStringAttribute(("TinyURL")); urls.thumbURL = img->getStringAttribute(("ThumbURL")); urls.albumURL = img->getStringAttribute(("AlbumURL")); } delete n; return true; } return false; }
static void findKeySigEvents (MidiFile& midiFile, StringPairArray& midiMetadata) { MidiMessageSequence keySigEvents; midiFile.findAllKeySigEvents (keySigEvents); const int numKeySigEvents = keySigEvents.getNumEvents(); MemoryOutputStream keySigSequence; for (int i = 0; i < numKeySigEvents; ++i) { const MidiMessage& message (keySigEvents.getEventPointer (i)->message); const int key = jlimit (0, 14, message.getKeySignatureNumberOfSharpsOrFlats() + 7); const bool isMajor = message.isKeySignatureMajorKey(); static const char* majorKeys[] = { "Cb", "Gb", "Db", "Ab", "Eb", "Bb", "F", "C", "G", "D", "A", "E", "B", "F#", "C#" }; static const char* minorKeys[] = { "Ab", "Eb", "Bb", "F", "C", "G", "D", "A", "E", "B", "F#", "C#", "G#", "D#", "A#" }; String keySigString (isMajor ? majorKeys[key] : minorKeys[key]); if (! isMajor) keySigString << 'm'; if (i == 0) midiMetadata.set (CoreAudioFormat::keySig, keySigString); if (numKeySigEvents > 1) keySigSequence << keySigString << ',' << keySigEvents.getEventTime (i) << ';'; } if (keySigSequence.getDataSize() > 0) midiMetadata.set ("key signature sequence", keySigSequence.toUTF8()); }
static void create (MemoryBlock& block, const StringPairArray& values) { auto numNotes = values.getValue ("NumCueNotes", "0").getIntValue(); if (numNotes > 0) { MemoryOutputStream out (block, false); out.writeShortBigEndian ((short) numNotes); for (int i = 0; i < numNotes; ++i) { auto prefix = "CueNote" + String (i); out.writeIntBigEndian (values.getValue (prefix + "TimeStamp", "0").getIntValue()); out.writeShortBigEndian ((short) values.getValue (prefix + "Identifier", "0").getIntValue()); auto comment = values.getValue (prefix + "Text", String()); auto commentLength = jmin (comment.getNumBytesAsUTF8(), (size_t) 65534); out.writeShortBigEndian ((short) commentLength + 1); out.write (comment.toUTF8(), commentLength); out.writeByte (0); if ((out.getDataSize() & 1) != 0) out.writeByte (0); } } }
//====================================================================== static void sendProjectButtonAnalyticsEvent (StringRef label) { StringPairArray data; data.set ("label", label); Analytics::getInstance()->logEvent ("Project Button", data, ProjucerAnalyticsEvent::projectEvent); }
void create (MemoryBlock& block, const StringPairArray& values) { const int numNotes = values.getValue ("NumCueNotes", "0").getIntValue(); if (numNotes > 0) { MemoryOutputStream out (block, false); out.writeShortBigEndian ((short) numNotes); for (int i = 0; i < numNotes; ++i) { const String prefix ("CueNote" + String (i)); out.writeIntBigEndian (values.getValue (prefix + "TimeStamp", "0").getIntValue()); out.writeShortBigEndian ((short) values.getValue (prefix + "Identifier", "0").getIntValue()); const String comment (values.getValue (prefix + "Text", String::empty)); out.write (comment.toUTF8(), jmin (comment.getNumBytesAsUTF8(), 65534)); out.writeByte (0); if ((out.getDataSize() & 1) != 0) out.writeByte (0); } } }
bool metaDataContainsZeroIdentifiers (const StringPairArray& values) { // (zero cue identifiers are valid for WAV but not for AIFF) const String cueString ("Cue"); const String noteString ("CueNote"); const String identifierString ("Identifier"); const StringArray& keys = values.getAllKeys(); for (int i = 0; i < keys.size(); ++i) { const String key (keys[i]); if (key.startsWith (noteString)) continue; // zero identifier IS valid in a COMT chunk if (key.startsWith (cueString) && key.contains (identifierString)) { const int value = values.getValue (key, "-1").getIntValue(); if (value == 0) return true; } } return false; }
//============================================================================== static void setData (const AnalyticsDestination::AnalyticsEvent& event, StringPairArray& data) { data.set ("ea", event.name); if (event.parameters.getAllKeys().contains ("label")) data.set ("el", event.parameters.getValue ("label", {})); data.addArray (event.userProperties); }
//============================================================================== static StringPairArray parseInformationChunk (InputStream& input) { StringPairArray infoStrings; const uint32 numEntries = (uint32) input.readIntBigEndian(); for (uint32 i = 0; i < numEntries; ++i) infoStrings.set (input.readString(), input.readString()); return infoStrings; }
bool SmugMug::getImages(OwnedArray<ImageItem>& images, SmugID albumId) { StringPairArray params; params.set(("AlbumID"), String(albumId.id)); params.set(("AlbumKey"), albumId.key); params.set(("Heavy"), ("1")); XmlElement* n = smugMugRequest(("smugmug.images.get"), params); if (n) { XmlElement* a = n->getChildByName(("Album")); if (a) { XmlElement* i = a->getChildByName(("Images")); if (i) { XmlElement* img = i->getChildByName(("Image")); while (img) { ImageItem* itm = new ImageItem(); itm->id.id = img->getIntAttribute(("id")); itm->id.key = img->getStringAttribute(("Key")); itm->filename = img->getStringAttribute(("FileName")); itm->caption = img->getStringAttribute(("")); itm->keywords = img->getStringAttribute(("")); itm->position = img->getIntAttribute(("Position")); itm->date = img->getStringAttribute(("Date")); itm->format = img->getStringAttribute(("Format")); itm->serial = img->getIntAttribute(("Serial")); itm->watermark = img->getBoolAttribute(("Watermark")); itm->size = img->getIntAttribute(("Size")); itm->width = img->getIntAttribute(("Width")); itm->height = img->getIntAttribute(("Height")); itm->md5sum = img->getStringAttribute(("MD5Sum")); itm->lastUpdated = img->getStringAttribute(("LastUpdated")); itm->originalURL = img->getStringAttribute(("OriginalURL")); itm->largeURL = img->getStringAttribute(("LargeURL")); itm->mediumURL = img->getStringAttribute(("MediumURL")); itm->smallURL = img->getStringAttribute(("SmallURL")); itm->tinyURL = img->getStringAttribute(("TinyURL")); itm->thumbURL = img->getStringAttribute(("ThumbURL")); itm->albumURL = img->getStringAttribute(("AlbumURL")); images.add(itm); img = img->getNextElementWithTagName(("Image")); } } } delete n; return images.size() > 0; } return false; }
String replacePreprocessorDefs (const StringPairArray& definitions, String sourceString) { for (int i = 0; i < definitions.size(); ++i) { const String key (definitions.getAllKeys()[i]); const String value (definitions.getAllValues()[i]); sourceString = sourceString.replace ("${" + key + "}", value); } return sourceString; }
const var EnviJSONRPC::toArray (const StringPairArray &stringPairArray) { var ret = empty(false); DynamicObject *dso = ret.getDynamicObject(); for (int i=0; i<stringPairArray.size(); i++) { dso->setProperty (stringPairArray.getAllKeys() [i], stringPairArray.getAllValues() [i]); } return (ret); }
void testBackend (String type, int64 const seedValue, int numObjectsToTest = 2000) { DummyScheduler scheduler; beginTestCase (String ("Backend type=") + type); StringPairArray params; File const path (File::createTempFile ("node_db")); params.set ("type", type); params.set ("path", path.getFullPathName ()); // Create a batch Batch batch; createPredictableBatch (batch, 0, numObjectsToTest, seedValue); { // Open the backend ScopedPointer <Backend> backend (DatabaseImp::createBackend (params, scheduler)); // Write the batch storeBatch (*backend, batch); { // Read it back in Batch copy; fetchCopyOfBatch (*backend, ©, batch); expect (areBatchesEqual (batch, copy), "Should be equal"); } { // Reorder and read the copy again Batch copy; UnitTestUtilities::repeatableShuffle (batch.size (), batch, seedValue); fetchCopyOfBatch (*backend, ©, batch); expect (areBatchesEqual (batch, copy), "Should be equal"); } } { // Re-open the backend ScopedPointer <Backend> backend (DatabaseImp::createBackend (params, scheduler)); // Read it back in Batch copy; fetchCopyOfBatch (*backend, ©, batch); // Canonicalize the source and destination batches std::sort (batch.begin (), batch.end (), NodeObject::LessThan ()); std::sort (copy.begin (), copy.end (), NodeObject::LessThan ()); expect (areBatchesEqual (batch, copy), "Should be equal"); } }
//============================================================================== static bool read (InputStream& input, StringPairArray& metadataValues) { const int64 originalPos = input.getPosition(); const FileHeader cafFileHeader (input); const bool isCafFile = cafFileHeader.fileType == chunkName ("caff"); if (isCafFile) { while (! input.isExhausted()) { const ChunkHeader chunkHeader (input); if (chunkHeader.chunkType == chunkName ("desc")) { AudioDescriptionChunk audioDescriptionChunk (input); } else if (chunkHeader.chunkType == chunkName ("uuid")) { UserDefinedChunk userDefinedChunk (input, chunkHeader.chunkSize); } else if (chunkHeader.chunkType == chunkName ("data")) { // -1 signifies an unknown data size so the data has to be at the // end of the file so we must have finished the header if (chunkHeader.chunkSize == -1) break; input.skipNextBytes (chunkHeader.chunkSize); } else if (chunkHeader.chunkType == chunkName ("midi")) { metadataValues.addArray (parseMidiChunk (input, chunkHeader.chunkSize)); } else if (chunkHeader.chunkType == chunkName ("info")) { metadataValues.addArray (parseInformationChunk (input)); } else { // we aren't decoding this chunk yet so just skip over it input.skipNextBytes (chunkHeader.chunkSize); } } } input.setPosition (originalPos); return isCafFile; }
bool WebServicesExtractor::extractWebServiceInfo(IPropertyTree * attributeTree, const char * section) { if (visited.contains(*attributeTree)) return false; visited.append(*attributeTree); const char * result = attributeTree->queryProp(section); if (result) { if (strcmp(section, "INFO")==0 || strcmp(section, "HELP")==0 || strcmp(section, "DFORM")==0 || *result=='<') { results.append(*new StringPairItem(section, result)); return true; } StringBuffer nextAttribute; if (extractAttributeReference(nextAttribute, result)) { if (extractWebServiceInfo(nextAttribute, section)) return true; } } Owned<IPropertyTreeIterator> iter = attributeTree->getElements("USES"); ForEach(*iter) { StringBuffer nextAttribute; if (extractAttributeReference(nextAttribute, iter->query().queryProp(""))) if (extractWebServiceInfo(nextAttribute, section)) return true; } return false; }
String createGCCPreprocessorFlags (const StringPairArray& defs) { String s; for (int i = 0; i < defs.size(); ++i) { String def (defs.getAllKeys()[i]); const String value (defs.getAllValues()[i]); if (value.isNotEmpty()) def << "=" << value; s += " -D" + def; } return s; }
StringPairArray getResponseHeaders() const { StringPairArray responseHeaders; if (! isError()) { for (int i = 0; i < headerLines.size(); ++i) { const String& headersEntry = headerLines[i]; const String key (headersEntry.upToFirstOccurrenceOf (": ", false, false)); const String value (headersEntry.fromFirstOccurrenceOf (": ", false, false)); const String previousValue (responseHeaders [key]); responseHeaders.set (key, previousValue.isEmpty() ? value : (previousValue + "," + value)); } } return responseHeaders; }
bool SmugMug::deleteSubCategory(int subCategory) { StringPairArray params; params.set(("SubCategoryID"), String(subCategory)); XmlElement* n = smugMugRequest(("smugmug.subcategories.delete"), params); if (n) { if (n->getTagName() == ("rsp") && n->getStringAttribute(("stat")) == ("ok")) { delete n; return true; } delete n; } return false; }
bool SmugMug::deleteAlbum(SmugID album) { StringPairArray params; params.set(("AlbumID"), String(album.id)); XmlElement* n = smugMugRequest(("smugmug.albums.delete"), params); if (n) { if (n->getTagName() == ("rsp") && n->getStringAttribute(("stat")) == ("ok")) { delete n; return true; } delete n; } return false; }
bool SmugMug::deleteImage(SmugID image) { StringPairArray params; params.set(("ImageID"), String(image.id)); XmlElement* n = smugMugRequest(("smugmug.images.delete"), params); if (n) { if (n->getTagName() == ("rsp") && n->getStringAttribute(("stat")) == ("ok")) { delete n; return true; } delete n; } return false; }
int SmugMug::createCategory(const String& title) { int catId = -1; StringPairArray params; params.set(("Name"), title); XmlElement* n = smugMugRequest(("smugmug.categories.create"), params); if (n) { XmlElement* a = n->getChildByName(("Category")); if (a) catId = a->getIntAttribute(("id"), -1); delete n; } return catId; }
//============================================================================== StringPairArray parsePreprocessorDefs (const String& text) { StringPairArray result; String::CharPointerType s (text.getCharPointer()); while (! s.isEmpty()) { String token, value; s = s.findEndOfWhitespace(); while ((! s.isEmpty()) && *s != '=' && ! s.isWhitespace()) token << s.getAndAdvance(); s = s.findEndOfWhitespace(); if (*s == '=') { ++s; while ((! s.isEmpty()) && *s == ' ') ++s; while ((! s.isEmpty()) && ! s.isWhitespace()) { if (*s == ',') { ++s; break; } if (*s == '\\' && (s[1] == ' ' || s[1] == ',')) ++s; value << s.getAndAdvance(); } } if (token.isNotEmpty()) result.set (token, value); } return result; }
bool WebServicesExtractor::extractWebServiceInfo() { // start load forms static const char *sectionNames[] = { "HTML", "HTMLD", "SOAP", "INFO", "HELP", "ERROR", "RESULT", "OTX", NULL }; for (unsigned i = 0; sectionNames[i]; i++) { extractWebServiceInfo(sectionNames[i]); } return (results.ordinality() != 0); }
void addMetadataArg (const StringPairArray& metadata, const char* key, const char* lameFlag) { const String value (metadata.getValue (key, String::empty)); if (value.isNotEmpty()) { args.add (lameFlag); args.add (value); } }