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