const Hashtable*
LocaleUtility::getAvailableLocaleNames(const UnicodeString& bundleID)
{
// LocaleUtility_cache is a hash-of-hashes. The top-level keys
// are path strings ('bundleID') passed to
// ures_openAvailableLocales. The top-level values are
// second-level hashes. The second-level keys are result strings
// from ures_openAvailableLocales. The second-level values are
// garbage ((void*)1 or other random pointer).
UErrorCode status = U_ZERO_ERROR;
umtx_initOnce(LocaleUtilityInitOnce, locale_utility_init, status);
Hashtable *cache = LocaleUtility_cache;
if (cache == NULL) {
// Catastrophic failure.
return NULL;
}
Hashtable* htp;
umtx_lock(NULL);
htp = (Hashtable*) cache->get(bundleID);
umtx_unlock(NULL);
if (htp == NULL) {
htp = new Hashtable(status);
if (htp && U_SUCCESS(status)) {
CharString cbundleID;
cbundleID.appendInvariantChars(bundleID, status);
const char* path = cbundleID.isEmpty() ? NULL : cbundleID.data();
UEnumeration *uenum = ures_openAvailableLocales(path, &status);
for (;;) {
const UChar* id = uenum_unext(uenum, NULL, &status);
if (id == NULL) {
break;
}
htp->put(UnicodeString(id), (void*)htp, status);
}
uenum_close(uenum);
if (U_FAILURE(status)) {
delete htp;
return NULL;
}
umtx_lock(NULL);
Hashtable *t = static_cast<Hashtable *>(cache->get(bundleID));
if (t != NULL) {
// Another thread raced through this code, creating the cache entry first.
// Discard ours and return theirs.
umtx_unlock(NULL);
delete htp;
htp = t;
} else {
cache->put(bundleID, (void*)htp, status);
umtx_unlock(NULL);
}
}
}
return htp;
}
static size_t curlHeaderCallback(void *ptr, size_t size, size_t nmemb, void *opaque)
{
Hashtable<String,String>* pHeaders = (Hashtable<String,String>*)opaque;
size_t nBytes = size*nmemb;
String strHeader((const char *)ptr, nBytes);
RAWTRACE1("Received header: %s", strHeader.c_str());
int nSep = strHeader.find(':');
if (nSep > 0 )
{
String strName = String_trim(strHeader.substr(0, nSep));
String lName;
std::transform(strName.begin(), strName.end(), std::back_inserter(lName), &::tolower);
String strValue = String_trim(strHeader.substr(nSep+1, strHeader.length() - (nSep+3) ));
if ( pHeaders->containsKey(lName) )
{
strValue += ";" + pHeaders->get( lName );
pHeaders->put( lName, strValue );
}
else
pHeaders->put(lName, strValue);
}
return nBytes;
}
static super_t known_wins(int depth, board_t board) {
check_board(board);
symmetry_t symmetry;
superstandardize(board).get(board,symmetry);
superinfo_t info = known.get(tuple(depth,board));
GEODE_ASSERT(!~info.known);
return transform_super(symmetry.inverse(),info.wins);
}
void
TimeUnitFormat::checkConsistency(UTimeUnitFormatStyle style, const char* key, UErrorCode& err) {
if (U_FAILURE(err)) {
return;
}
// there should be patterns for each plural rule in each time unit.
// For each time unit,
// for each plural rule, following is unit pattern fall-back rule:
// ( for example: "one" hour )
// look for its unit pattern in its locale tree.
// if pattern is not found in its own locale, such as de_DE,
// look for the pattern in its parent, such as de,
// keep looking till found or till root.
// if the pattern is not found in root either,
// fallback to plural count "other",
// look for the pattern of "other" in the locale tree:
// "de_DE" to "de" to "root".
// If not found, fall back to value of
// static variable DEFAULT_PATTERN_FOR_xxx, such as "{0} h".
//
// Following is consistency check to create pattern for each
// plural rule in each time unit using above fall-back rule.
//
StringEnumeration* keywords = getPluralRules().getKeywords(err);
if (U_SUCCESS(err)) {
const UnicodeString* pluralCount;
while ((pluralCount = keywords->snext(err)) != NULL) {
if ( U_SUCCESS(err) ) {
for (int32_t i = 0; i < TimeUnit::UTIMEUNIT_FIELD_COUNT; ++i) {
// for each time unit,
// get all the patterns for each plural rule in this locale.
Hashtable* countToPatterns = fTimeUnitToCountToPatterns[i];
if ( countToPatterns == NULL ) {
countToPatterns = initHash(err);
if (U_FAILURE(err)) {
delete countToPatterns;
return;
}
fTimeUnitToCountToPatterns[i] = countToPatterns;
}
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(*pluralCount);
if( formatters == NULL || formatters[style] == NULL ) {
// look through parents
const char* localeName = getLocaleID(err);
CharString pluralCountChars;
pluralCountChars.appendInvariantChars(*pluralCount, err);
searchInLocaleChain(style, key, localeName,
(TimeUnit::UTimeUnitFields)i,
*pluralCount, pluralCountChars.data(),
countToPatterns, err);
}
}
}
}
}
delete keywords;
}
void printGlobalMetadata() {
cout << endl;
cout << "Reading global metadata" << endl;
Hashtable meta = reader->getGlobalMetadata();
StringArray keys = MetadataTools::keys(meta);
for (int i=0; i<keys.length(); i++) {
Object value = meta.get(keys[i]);
cout << keys[i] << ": " << value << endl;
}
}
int32_t TransliteratorRegistry::countAvailableVariants(const UnicodeString& source,
const UnicodeString& target) const {
Hashtable *targets = (Hashtable*) specDAG.get(source);
if (targets == 0) {
return 0;
}
UVector *variants = (UVector*) targets->get(target);
// variants may be 0 if the source/target are invalid
return (variants == 0) ? 0 : variants->size();
}
UBool
SelectFormat::operator==(const Format& other) const {
if( this == &other){
return TRUE;
}
if( other.getDynamicClassID() != SelectFormat::getStaticClassID() ){
return FALSE;
}
SelectFormat* fmt = (SelectFormat*)&other;
Hashtable* hashOther = fmt->parsedValuesHash;
if ( parsedValuesHash == NULL && hashOther == NULL)
return TRUE;
if ( parsedValuesHash == NULL || hashOther == NULL)
return FALSE;
if ( hashOther->count() != parsedValuesHash->count() ){
return FALSE;
}
const UHashElement* elem = NULL;
int32_t pos = -1;
while ((elem = hashOther->nextElement(pos)) != NULL) {
const UHashTok otherKeyTok = elem->key;
UnicodeString* otherKey = (UnicodeString*)otherKeyTok.pointer;
const UHashTok otherKeyToVal = elem->value;
UnicodeString* otherValue = (UnicodeString*)otherKeyToVal.pointer;
UnicodeString* thisElemValue = (UnicodeString*)parsedValuesHash->get(*otherKey);
if ( thisElemValue == NULL ){
return FALSE;
}
if ( *thisElemValue != *otherValue){
return FALSE;
}
}
pos = -1;
while ((elem = parsedValuesHash->nextElement(pos)) != NULL) {
const UHashTok thisKeyTok = elem->key;
UnicodeString* thisKey = (UnicodeString*)thisKeyTok.pointer;
const UHashTok thisKeyToVal = elem->value;
UnicodeString* thisValue = (UnicodeString*)thisKeyToVal.pointer;
UnicodeString* otherElemValue = (UnicodeString*)hashOther->get(*thisKey);
if ( otherElemValue == NULL ){
return FALSE;
}
if ( *otherElemValue != *thisValue){
return FALSE;
}
}
return TRUE;
}
UnicodeString&
CollatorInfo::getDisplayName(const Locale& displayLocale, UnicodeString& name) const {
if (displayNames) {
UnicodeString* val = (UnicodeString*)displayNames->get(displayLocale.getName());
if (val) {
name = *val;
return name;
}
}
return locale.getDisplayName(displayLocale, name);
}
bool rhom_method_name_isreserved(const String& strName)
{
static Hashtable<String,int> reserved_names;
if ( reserved_names.size() == 0 )
{
reserved_names.put("object",1);
reserved_names.put("source_id",1);
reserved_names.put("update_type",1);
reserved_names.put("attrib_type",1);
reserved_names.put("set_notification",1);
reserved_names.put("clear_notification",1);
}
return reserved_names.get(strName) != 0;
}
int main() {
Hashtable<int, int> hashtable;
for (int i = 0; i < 100; i++) {
hashtable.set(string("k") + to_string(i), i);
}
for (int i = 0; i < 100; i++) {
hashtable.set(string("k") + to_string(i), 100);
}
for (int i = 0; i < 100; i++) {
cout << i << ": " << hashtable.get(string("k") + to_string(i)) << endl;
}
return 0;
}
void printOriginalMetadata() {
cout << endl;
int seriesCount = reader->getSeriesCount();
if (seriesCount > 1) {
cout << "Reading series #" << series << " metadata" << endl;
}
else {
cout << "Reading series metadata" << endl;
}
Hashtable meta = reader->getSeriesMetadata();
StringArray keys = MetadataTools::keys(meta);
for (int i=0; i<keys.length(); i++) {
Object value = meta.get(keys[i]);
cout << keys[i] << ": " << value << endl;
}
}
/**
* Register a source-target/variant in the specDAG. Variant may be
* empty, but source and target must not be. If variant is empty then
* the special variant NO_VARIANT is stored in slot zero of the
* UVector of variants.
*/
void TransliteratorRegistry::registerSTV(const UnicodeString& source,
const UnicodeString& target,
const UnicodeString& variant) {
// assert(source.length() > 0);
// assert(target.length() > 0);
UErrorCode status = U_ZERO_ERROR;
Hashtable *targets = (Hashtable*) specDAG.get(source);
if (targets == 0) {
targets = new Hashtable(TRUE, status);
if (U_FAILURE(status) || targets == 0) {
return;
}
targets->setValueDeleter(uprv_deleteUObject);
specDAG.put(source, targets, status);
}
UVector *variants = (UVector*) targets->get(target);
if (variants == 0) {
variants = new UVector(uprv_deleteUObject,
uhash_compareCaselessUnicodeString, status);
if (variants == 0) {
return;
}
targets->put(target, variants, status);
}
// assert(NO_VARIANT == "");
// We add the variant string. If it is the special "no variant"
// string, that is, the empty string, we add it at position zero.
if (!variants->contains((void*) &variant)) {
UnicodeString *tempus; // Used for null pointer check.
if (variant.length() > 0) {
tempus = new UnicodeString(variant);
if (tempus != NULL) {
variants->addElement(tempus, status);
}
} else {
tempus = new UnicodeString(); // = NO_VARIANT
if (tempus != NULL) {
variants->insertElementAt(tempus, 0, status);
}
}
}
}
/**
* Remove a source-target/variant from the specDAG.
*/
void TransliteratorRegistry::removeSTV(const UnicodeString& source,
const UnicodeString& target,
const UnicodeString& variant) {
// assert(source.length() > 0);
// assert(target.length() > 0);
// UErrorCode status = U_ZERO_ERROR;
Hashtable *targets = (Hashtable*) specDAG.get(source);
if (targets == 0) {
return; // should never happen for valid s-t/v
}
UVector *variants = (UVector*) targets->get(target);
if (variants == 0) {
return; // should never happen for valid s-t/v
}
variants->removeElement((void*) &variant);
if (variants->size() == 0) {
targets->remove(target); // should delete variants
if (targets->count() == 0) {
specDAG.remove(source); // should delete targets
}
}
}
UnicodeString& TransliteratorRegistry::getAvailableVariant(int32_t index,
const UnicodeString& source,
const UnicodeString& target,
UnicodeString& result) const {
Hashtable *targets = (Hashtable*) specDAG.get(source);
if (targets == 0) {
result.truncate(0); // invalid source
return result;
}
UVector *variants = (UVector*) targets->get(target);
if (variants == 0) {
result.truncate(0); // invalid target
return result;
}
UnicodeString *v = (UnicodeString*) variants->elementAt(index);
if (v == 0) {
result.truncate(0); // invalid index
} else {
result = *v;
}
return result;
}
UnicodeString&
TimeUnitFormat::format(const Formattable& obj, UnicodeString& toAppendTo,
FieldPosition& pos, UErrorCode& status) const {
if (U_FAILURE(status)) {
return toAppendTo;
}
if (obj.getType() == Formattable::kObject) {
const UObject* formatObj = obj.getObject();
const TimeUnitAmount* amount = dynamic_cast<const TimeUnitAmount*>(formatObj);
if (amount != NULL){
Hashtable* countToPattern = fTimeUnitToCountToPatterns[amount->getTimeUnitField()];
double number;
const Formattable& amtNumber = amount->getNumber();
if (amtNumber.getType() == Formattable::kDouble) {
number = amtNumber.getDouble();
} else if (amtNumber.getType() == Formattable::kLong) {
number = amtNumber.getLong();
} else {
status = U_ILLEGAL_ARGUMENT_ERROR;
return toAppendTo;
}
UnicodeString count = fPluralRules->select(number);
#ifdef TMUTFMT_DEBUG
char result[1000];
count.extract(0, count.length(), result, "UTF-8");
std::cout << "number: " << number << "; format plural count: " << result << "\n";
#endif
MessageFormat* pattern = ((MessageFormat**)countToPattern->get(count))[fStyle];
Formattable formattable[1];
formattable[0].setDouble(number);
return pattern->format(formattable, 1, toAppendTo, pos, status);
}
}
status = U_ILLEGAL_ARGUMENT_ERROR;
return toAppendTo;
}
rho::net::CNetResponseWrapper CNetRequestWrapper::pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders,bool overwriteFile,bool createFolders, bool* pFileExistsFlag )
{
if (!overwriteFile && common::CRhoFile::isFileExist(strFilePath.c_str())) {
LOGC(WARNING,"Net") + "pullFile: " + strFilePath + " already exists, won't download since overwrite flag is not set";
if ( pFileExistsFlag != 0 ) {
*pFileExistsFlag = true;
}
return m_pReqImpl->createEmptyNetResponse();
}
if ( pFileExistsFlag != 0 ) {
*pFileExistsFlag = false;
}
if ( createFolders ) {
String targetDir = common::CFilePath(strFilePath).getFolderName();
if ( !common::CRhoFile::isDirectory(targetDir.c_str()) ) {
common::CRhoFile::recursiveCreateDir(targetDir.c_str(), "");
}
}
String tmpfilename = strFilePath + ".rhodownload";
String modfilename = strFilePath + ".modtime";
common::CRhoFile tmpFile;
common::CRhoFile::EOpenModes openMode = common::CRhoFile::OpenForWrite;
//don't request headers of will overwrite anyway
if (!overwriteFile) {
Hashtable<String, String> h;
::getNetRequest().doRequest("HEAD", strUrl, "", oSession, &h );
if ( h.containsKey("last-modified") )
{
if ( common::CRhoFile::isFileExist(modfilename.c_str()) ) {
String modDate;
common::CRhoFile fModDate;
if ( fModDate.open(modfilename.c_str(), common::CRhoFile::OpenReadOnly)) {
fModDate.readString(modDate);
if (modDate == h.get("last-modified")) {
openMode = common::CRhoFile::OpenForAppend;
}
}
} else {
common::CRhoFile fModDate;
if ( fModDate.open(modfilename.c_str(), common::CRhoFile::OpenForWrite) ) {
const String& modDate = h.get("last-modified");
fModDate.write((void*)modDate.c_str(), modDate.length());
}
}
}
}
if ( !tmpFile.open(tmpfilename.c_str(),openMode) )
{
LOGC(ERROR, "Net") + "pullFile: cannot create file :" + tmpfilename;
return m_pReqImpl->createEmptyNetResponse();
}
INetResponse* pResp = m_pReqImpl->pullFile( strUrl, tmpFile, oSession, pHeaders );
tmpFile.close();
if ( (pResp->getRespCode() == 200) || (pResp->getRespCode() == 206) )
{
common::CRhoFile::deleteFile(strFilePath.c_str());
if ( common::CRhoFile::renameFile( tmpfilename.c_str(), strFilePath.c_str() ) != 0 )
{
LOGC(ERROR, "Net") + "pullFile: cannot rename file :" + tmpfilename + " to " + strFilePath;
return m_pReqImpl->createEmptyNetResponse();
}
common::CRhoFile::deleteFile(modfilename.c_str());
}
return pResp;
}
void
TimeUnitFormat::readFromCurrentLocale(UTimeUnitFormatStyle style, const char* key,
const UVector& pluralCounts, UErrorCode& err) {
if (U_FAILURE(err)) {
return;
}
// fill timeUnitToCountToPatterns from resource file
// err is used to indicate wrong status except missing resource.
// status is an error code used in resource lookup.
// status does not affect "err".
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *rb, *unitsRes;
rb = ures_open(U_ICUDATA_UNIT, getLocaleID(status), &status);
unitsRes = ures_getByKey(rb, key, NULL, &status);
unitsRes = ures_getByKey(unitsRes, "duration", unitsRes, &status);
if (U_FAILURE(status)) {
ures_close(unitsRes);
ures_close(rb);
return;
}
int32_t size = ures_getSize(unitsRes);
for ( int32_t index = 0; index < size; ++index) {
// resource of one time unit
UResourceBundle* oneTimeUnit = ures_getByIndex(unitsRes, index,
NULL, &status);
if (U_SUCCESS(status)) {
const char* timeUnitName = ures_getKey(oneTimeUnit);
if (timeUnitName == NULL) {
ures_close(oneTimeUnit);
continue;
}
UResourceBundle* countsToPatternRB = ures_getByKey(unitsRes,
timeUnitName,
NULL, &status);
if (countsToPatternRB == NULL || U_FAILURE(status)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
continue;
}
TimeUnit::UTimeUnitFields timeUnitField = TimeUnit::UTIMEUNIT_FIELD_COUNT;
if ( uprv_strcmp(timeUnitName, gTimeUnitYear) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_YEAR;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitMonth) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_MONTH;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitDay) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_DAY;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitHour) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_HOUR;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitMinute) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_MINUTE;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitSecond) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_SECOND;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitWeek) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_WEEK;
} else {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
continue;
}
Hashtable* countToPatterns = fTimeUnitToCountToPatterns[timeUnitField];
if (countToPatterns == NULL) {
countToPatterns = initHash(err);
if (U_FAILURE(err)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
delete countToPatterns;
break;
}
}
int32_t count = ures_getSize(countsToPatternRB);
const char* pluralCount;
for ( int32_t pluralIndex = 0; pluralIndex < count; ++pluralIndex) {
// resource of count to pattern
UnicodeString pattern =
ures_getNextUnicodeString(countsToPatternRB, &pluralCount, &status);
if (U_FAILURE(status)) {
continue;
}
UnicodeString pluralCountUniStr(pluralCount, -1, US_INV);
if (!pluralCounts.contains(&pluralCountUniStr)) {
continue;
}
MessageFormat* messageFormat = new MessageFormat(pattern, getLocale(err), err);
if ( U_SUCCESS(err) ) {
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(pluralCountUniStr);
if (formatters == NULL) {
formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*));
formatters[UTMUTFMT_FULL_STYLE] = NULL;
formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
countToPatterns->put(pluralCountUniStr, formatters, err);
if (U_FAILURE(err)) {
uprv_free(formatters);
}
}
if (U_SUCCESS(err)) {
//delete formatters[style];
formatters[style] = messageFormat;
}
}
if (U_FAILURE(err)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
ures_close(unitsRes);
ures_close(rb);
delete messageFormat;
delete countToPatterns;
return;
}
}
if (fTimeUnitToCountToPatterns[timeUnitField] == NULL) {
fTimeUnitToCountToPatterns[timeUnitField] = countToPatterns;
}
ures_close(countsToPatternRB);
}
ures_close(oneTimeUnit);
}
ures_close(unitsRes);
ures_close(rb);
}
void
TimeUnitFormat::readFromCurrentLocale(EStyle style, const char* key, UErrorCode& err) {
if (U_FAILURE(err)) {
return;
}
// fill timeUnitToCountToPatterns from resource file
// err is used to indicate wrong status except missing resource.
// status is an error code used in resource lookup.
// status does not affect "err".
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *rb, *unitsRes;
rb = ures_open(NULL, fLocale.getName(), &status);
unitsRes = ures_getByKey(rb, key, NULL, &status);
if (U_FAILURE(status)) {
ures_close(unitsRes);
ures_close(rb);
return;
}
int32_t size = ures_getSize(unitsRes);
for ( int32_t index = 0; index < size; ++index) {
// resource of one time unit
UResourceBundle* oneTimeUnit = ures_getByIndex(unitsRes, index,
NULL, &status);
if (U_SUCCESS(status)) {
const char* timeUnitName = ures_getKey(oneTimeUnit);
if (timeUnitName == NULL) {
ures_close(oneTimeUnit);
continue;
}
UResourceBundle* countsToPatternRB = ures_getByKey(unitsRes,
timeUnitName,
NULL, &status);
if (countsToPatternRB == NULL || U_FAILURE(status)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
continue;
}
TimeUnit::UTimeUnitFields timeUnitField = TimeUnit::UTIMEUNIT_FIELD_COUNT;
if ( uprv_strcmp(timeUnitName, gTimeUnitYear) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_YEAR;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitMonth) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_MONTH;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitDay) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_DAY;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitHour) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_HOUR;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitMinute) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_MINUTE;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitSecond) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_SECOND;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitWeek) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_WEEK;
} else {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
continue;
}
Hashtable* countToPatterns = fTimeUnitToCountToPatterns[timeUnitField];
if (countToPatterns == NULL) {
countToPatterns = initHash(err);
if (U_FAILURE(err)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
delete countToPatterns;
break;
}
}
int32_t count = ures_getSize(countsToPatternRB);
const UChar* pattern;
const char* pluralCount;
int32_t ptLength;
for ( int32_t pluralIndex = 0; pluralIndex < count; ++pluralIndex) {
// resource of count to pattern
pattern = ures_getNextString(countsToPatternRB, &ptLength,
&pluralCount, &status);
if (U_FAILURE(status)) {
continue;
}
MessageFormat* messageFormat = new MessageFormat(pattern, fLocale, err);
if ( U_SUCCESS(err) ) {
if (fNumberFormat != NULL) {
messageFormat->setFormat(0, *fNumberFormat);
}
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(pluralCount);
if (formatters == NULL) {
formatters = (MessageFormat**)uprv_malloc(kTotal*sizeof(MessageFormat*));
formatters[kFull] = NULL;
formatters[kAbbreviate] = NULL;
countToPatterns->put(pluralCount, formatters, err);
if (U_FAILURE(err)) {
uprv_free(formatters);
}
}
if (U_SUCCESS(err)) {
//delete formatters[style];
formatters[style] = messageFormat;
}
}
if (U_FAILURE(err)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
ures_close(unitsRes);
ures_close(rb);
delete messageFormat;
delete countToPatterns;
return;
}
}
if (fTimeUnitToCountToPatterns[timeUnitField] == NULL) {
fTimeUnitToCountToPatterns[timeUnitField] = countToPatterns;
}
ures_close(countsToPatternRB);
}
ures_close(oneTimeUnit);
}
ures_close(unitsRes);
ures_close(rb);
}
void DDaceXMLHandler::startElement(const std::string& name,
const Hashtable& attributes)
{
try
{
if (samplerTypes_.containsKey(name))
{
samplerParams_ = attributes;
samplerName_ = name;
int samples = atoi(attributes.get("samples"));
pts_.resize(samples);
results_.resize(samples);
status_.resize(samples);
// give default values to elements of status_
for(int j=0; j < samples; j++)
status_[j] = DDaceRunNotStarted;
}
else if (name == "Variable")
{
varNames_.append(attributes.get("name"));
if (attributes.containsKey("distribution")
&& attributes.get("distribution") != "uniform")
{
std::string distType = attributes.get("distribution");
if (distType == "normal")
{
if (attributes.containsKey("mean")
&& attributes.containsKey("sigma"))
{
double mean = atof(attributes.get("mean"));
double sigma = atof(attributes.get("sigma"));
double nDev = atof(attributes.get("cutoff"));
varDist_.append(NormalDistribution(Mean(mean),
StdDeviation(sigma),
nDev));
}
else if (attributes.containsKey("upper") && attributes.containsKey("lower"))
{
double lower = atof(attributes.get("lower"));
double upper = atof(attributes.get("upper"));
if (attributes.containsKey("nDev"))
{
double nDev = atof(attributes.get("cutoff"));
varDist_.append(NormalDistribution(lower, upper, nDev));
}
else
{
varDist_.append(NormalDistribution(lower, upper));
}
}
else
{
ExceptionBase::raise("invalid xml specification of normally distributed variable");
}
}
else
{
ExceptionBase::raise("unrecognized xml specification of distribution type");
}
}
else if ( samplerName_ == "UserInputSampler" )
{
// no distribution information required for UserInputSampler
}
else /* uniform distribution */
{
double lower = atof(attributes.get("lower"));
double upper = atof(attributes.get("upper"));
varDist_.append(UniformDistribution(lower, upper));
}
}
else if (name == "Archive")
{
archiveFilename_ = attributes.get("name");
}
else if (name == "Output")
{
outputNames_.append(attributes.get("name"));
}
else if (name == "Sample")
{
currentTag_ = atoi(attributes.get("tag"));
}
else if (name == "SamplePoint")
{
isSamplePt_ = true;
charStr_ = "";
}
else if (name == "SampleResult")
{
isArchiveFile_ = true;
if (currentTag_ == -1)
ExceptionBase::raise("Index tag corresponding to current "
"sample is -1.");
String statusString = attributes.get("status");
if (statusString == "Run OK")
status_[currentTag_] = DDaceRunOK;
else if (statusString == "Run failed")
status_[currentTag_] = DDaceRunFailed;
else if (statusString == "Post processing failed")
status_[currentTag_] = DDacePostProcFailed;
else if (statusString == "Run not started")
status_[currentTag_] = DDaceRunNotStarted;
else if (statusString == "Run pending")
status_[currentTag_] = DDaceRunPending;
else
ExceptionBase::raise("unrecognized sample status inside "
"SampleResult for "
"DDaceXMLHandler::startElement()");
isSampleResult_ = true;
charStr_= "";
}
}
catch(ExceptionBase& e)
{
e.trace("in DDaceXMLHandler::startElement( tag = " + name + ")");
}
}
Nested<EV> exact_split_polygons(Nested<const EV> polys, const int depth) {
IntervalScope scope;
RawArray<const EV> X = polys.flat;
// We index segments by the index of their first point in X. For convenience, we make an array to keep track of wraparounds.
Array<int> next = (arange(X.size())+1).copy();
for (int i=0;i<polys.size();i++) {
GEODE_ASSERT(polys.size(i)>=3,"Degenerate polygons are not allowed");
next[polys.offsets[i+1]-1] = polys.offsets[i];
}
// Compute all nontrivial intersections between segments
struct Pairs {
const BoxTree<EV>& tree;
RawArray<const int> next;
RawArray<const EV> X;
Array<Vector<int,2>> pairs;
Pairs(const BoxTree<EV>& tree, RawArray<const int> next, RawArray<const EV> X)
: tree(tree), next(next), X(X) {}
bool cull(const int n) const { return false; }
bool cull(const int n0, const int box1) const { return false; }
void leaf(const int n) const { assert(tree.prims(n).size()==1); }
void leaf(const int n0, const int n1) {
assert(tree.prims(n0).size()==1 && tree.prims(n1).size()==1);
const int i0 = tree.prims(n0)[0], i1 = next[i0],
j0 = tree.prims(n1)[0], j1 = next[j0];
if (!(i0==j0 || i0==j1 || i1==j0 || i1==j1)) {
const auto a0 = Perturbed2(i0,X[i0]), a1 = Perturbed2(i1,X[i1]),
b0 = Perturbed2(j0,X[j0]), b1 = Perturbed2(j1,X[j1]);
if (segments_intersect(a0,a1,b0,b1))
pairs.append(vec(i0,j0));
}
}
};
const auto tree = new_<BoxTree<EV>>(segment_boxes(next,X),1);
Pairs pairs(tree,next,X);
double_traverse(*tree,pairs);
// Group intersections by segment. Each pair is added twice: once for each order.
Array<int> counts(X.size());
for (auto pair : pairs.pairs) {
counts[pair.x]++;
counts[pair.y]++;
}
Nested<int> others(counts,uninit);
for (auto pair : pairs.pairs) {
others(pair.x,--counts[pair.x]) = pair.y;
others(pair.y,--counts[pair.y]) = pair.x;
}
pairs.pairs.clean_memory();
counts.clean_memory();
// Walk all original polygons, recording which subsegments occur in the final result
Hashtable<Vector<int,2>,int> graph; // If (i,j) -> k, the output contains the portion of segment j from ij to jk
for (const int p : range(polys.size())) {
const auto poly = range(polys.offsets[p],polys.offsets[p+1]);
// Compute the depth of the first point in the polygon by firing a ray along the positive x axis.
struct Depth {
const BoxTree<EV>& tree;
RawArray<const int> next;
RawArray<const EV> X;
const Perturbed2 start;
int depth;
Depth(const BoxTree<EV>& tree, RawArray<const int> next, RawArray<const EV> X, const int prev, const int i)
: tree(tree), next(next), X(X)
, start(i,X[i])
// If we intersect no other segments, the depth depends on the orientation of direction = (1,0) relative to segments prev and i
, depth(-!local_outwards_x_axis(Perturbed2(prev,X[prev]),start,Perturbed2(next[i],X[next[i]]))) {}
bool cull(const int n) const {
const auto box = tree.boxes(n);
return box.max.x<start.value().x || box.max.y<start.value().y || box.min.y>start.value().y;
}
void leaf(const int n) {
assert(tree.prims(n).size()==1);
const int i0 = tree.prims(n)[0], i1 = next[i0];
if (start.seed()!=i0 && start.seed()!=i1) {
const auto a0 = Perturbed2(i0,X[i0]),
a1 = Perturbed2(i1,X[i1]);
const bool above0 = upwards(start,a0),
above1 = upwards(start,a1);
if (above0!=above1 && above1==triangle_oriented(a0,a1,start))
depth += above1 ? 1 : -1;
}
}
};
Depth ray(tree,next,X,poly.back(),poly[0]);
single_traverse(*tree,ray);
// Walk around the polygon, recording all subsegments at the desired depth
int delta = ray.depth-depth;
int prev = poly.back();
for (const int i : poly) {
const int j = next[i];
const Vector<Perturbed2,2> segment(Perturbed2(i,X[i]),Perturbed2(j,X[j]));
const auto other = others[i];
// Sort intersections along this segment
if (other.size() > 1) {
struct PairOrder {
RawArray<const int> next;
RawArray<const EV> X;
const Vector<Perturbed2,2> segment;
PairOrder(RawArray<const int> next, RawArray<const EV> X, const Vector<Perturbed2,2>& segment)
: next(next), X(X), segment(segment) {}
bool operator()(const int j, const int k) const {
if (j==k)
return false;
const int jn = next[j],
kn = next[k];
return segment_intersections_ordered(segment.x,segment.y,
Perturbed2(j,X[j]),Perturbed2(jn,X[jn]),
Perturbed2(k,X[k]),Perturbed2(kn,X[kn]));
}
};
sort(other,PairOrder(next,X,segment));
}
// Walk through each intersection of this segment, updating delta as we go and remembering the subsegment if it has the right depth
for (const int o : other) {
if (!delta)
graph.set(vec(prev,i),o);
const int on = next[o];
delta += segment_directions_oriented(segment.x,segment.y,Perturbed2(o,X[o]),Perturbed2(on,X[on])) ? -1 : 1;
prev = o;
}
if (!delta)
graph.set(vec(prev,i),next[i]);
// Advance to the next segment
prev = i;
}
}
// Walk the graph to produce output polygons
Hashtable<Vector<int,2>> seen;
Nested<EV,false> output;
for (const auto& start : graph)
if (seen.set(start.x)) {
auto ij = start.x;
for (;;) {
const int i = ij.x, j = ij.y, in = next[i], jn = next[j];
output.flat.append(j==next[i] ? X[j] : segment_segment_intersection(Perturbed2(i,X[i]),Perturbed2(in,X[in]),Perturbed2(j,X[j]),Perturbed2(jn,X[jn])));
ij = vec(j,graph.get(ij));
if (ij == start.x)
break;
seen.set(ij);
}
output.offsets.append(output.flat.size());
}
return output;
}
const Hashtable *
LocaleUtility::getAvailableLocaleNames(const UnicodeString & bundleID)
{
// LocaleUtility_cache is a hash-of-hashes. The top-level keys
// are path strings ('bundleID') passed to
// ures_openAvailableLocales. The top-level values are
// second-level hashes. The second-level keys are result strings
// from ures_openAvailableLocales. The second-level values are
// garbage ((void*)1 or other random pointer).
UErrorCode status = U_ZERO_ERROR;
Hashtable * cache;
umtx_lock(NULL);
cache = LocaleUtility_cache;
umtx_unlock(NULL);
if (cache == NULL)
{
cache = new Hashtable(status);
if (cache == NULL || U_FAILURE(status))
{
return NULL; // catastrophic failure; e.g. out of memory
}
cache->setValueDeleter(uhash_deleteHashtable);
Hashtable * h; // set this to final LocaleUtility_cache value
umtx_lock(NULL);
h = LocaleUtility_cache;
if (h == NULL)
{
LocaleUtility_cache = h = cache;
cache = NULL;
ucln_common_registerCleanup(UCLN_COMMON_SERVICE, service_cleanup);
}
umtx_unlock(NULL);
if (cache != NULL)
{
delete cache;
}
cache = h;
}
U_ASSERT(cache != NULL);
Hashtable * htp;
umtx_lock(NULL);
htp = (Hashtable *) cache->get(bundleID);
umtx_unlock(NULL);
if (htp == NULL)
{
htp = new Hashtable(status);
if (htp && U_SUCCESS(status))
{
CharString cbundleID;
cbundleID.appendInvariantChars(bundleID, status);
const char * path = cbundleID.isEmpty() ? NULL : cbundleID.data();
UEnumeration * uenum = ures_openAvailableLocales(path, &status);
for (;;)
{
const UChar * id = uenum_unext(uenum, NULL, &status);
if (id == NULL)
{
break;
}
htp->put(UnicodeString(id), (void *)htp, status);
}
uenum_close(uenum);
if (U_FAILURE(status))
{
delete htp;
return NULL;
}
umtx_lock(NULL);
cache->put(bundleID, (void *)htp, status);
umtx_unlock(NULL);
}
}
return htp;
}
