NS_IMETHODIMP
nsCategoryManager::DeleteCategoryEntry( const char *aCategoryName,
const char *aEntryName,
bool aDontPersist)
{
NS_ENSURE_ARG_POINTER(aCategoryName);
NS_ENSURE_ARG_POINTER(aEntryName);
/*
Note: no errors are reported since failure to delete
probably won't hurt you, and returning errors seriously
inconveniences JS clients
*/
CategoryNode* category;
{
MutexAutoLock lock(mLock);
category = get_category(aCategoryName);
}
if (category) {
category->DeleteLeaf(aEntryName);
NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID,
aCategoryName, aEntryName);
}
return NS_OK;
}
CategoryEnumerator*
CategoryEnumerator::Create(nsClassHashtable<nsDepCharHashKey, CategoryNode>&
aTable)
{
auto* enumObj = new CategoryEnumerator();
if (!enumObj) {
return nullptr;
}
enumObj->mArray = new const char* [aTable.Count()];
if (!enumObj->mArray) {
delete enumObj;
return nullptr;
}
for (auto iter = aTable.Iter(); !iter.Done(); iter.Next()) {
// if a category has no entries, we pretend it doesn't exist
CategoryNode* aNode = iter.UserData();
if (aNode->Count()) {
const char* str = iter.Key();
enumObj->mArray[enumObj->mCount++] = str;
}
}
return enumObj;
}
NS_IMETHODIMP
nsCategoryManager::AddCategoryEntry( const char *aCategoryName,
const char *aEntryName,
const char *aValue,
PRBool aPersist,
PRBool aReplace,
char **_retval )
{
NS_ENSURE_ARG_POINTER(aCategoryName);
NS_ENSURE_ARG_POINTER(aEntryName);
NS_ENSURE_ARG_POINTER(aValue);
// Before we can insert a new entry, we'll need to
// find the |CategoryNode| to put it in...
CategoryNode* category;
{
MutexAutoLock lock(mLock);
category = get_category(aCategoryName);
if (!category) {
// That category doesn't exist yet; let's make it.
category = CategoryNode::Create(&mArena);
char* categoryName = ArenaStrdup(aCategoryName, &mArena);
mTable.Put(categoryName, category);
}
}
if (!category)
return NS_ERROR_OUT_OF_MEMORY;
// We will need the return value of AddLeaf even if the called doesn't want it
char *oldEntry = nsnull;
nsresult rv = category->AddLeaf(aEntryName,
aValue,
aPersist,
aReplace,
&oldEntry,
&mArena);
if (NS_SUCCEEDED(rv)) {
if (oldEntry) {
NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID,
aCategoryName, oldEntry);
}
NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID,
aCategoryName, aEntryName);
if (_retval)
*_retval = oldEntry;
else if (oldEntry)
nsMemory::Free(oldEntry);
}
return rv;
}
void
nsCategoryManager::AddCategoryEntry(const char *aCategoryName,
const char *aEntryName,
const char *aValue,
bool aReplace,
char** aOldValue)
{
if (aOldValue)
*aOldValue = NULL;
// Before we can insert a new entry, we'll need to
// find the |CategoryNode| to put it in...
CategoryNode* category;
{
MutexAutoLock lock(mLock);
category = get_category(aCategoryName);
if (!category) {
// That category doesn't exist yet; let's make it.
category = CategoryNode::Create(&mArena);
char* categoryName = ArenaStrdup(aCategoryName, &mArena);
mTable.Put(categoryName, category);
}
}
if (!category)
return;
// We will need the return value of AddLeaf even if the called doesn't want it
char *oldEntry = nsnull;
nsresult rv = category->AddLeaf(aEntryName,
aValue,
aReplace,
&oldEntry,
&mArena);
if (NS_SUCCEEDED(rv)) {
if (oldEntry) {
NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID,
aCategoryName, oldEntry);
}
NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID,
aCategoryName, aEntryName);
if (aOldValue)
*aOldValue = oldEntry;
else
NS_Free(oldEntry);
}
}
NS_IMETHODIMP
nsCategoryManager::EnumerateCategory( const char *aCategoryName,
nsISimpleEnumerator **_retval )
{
NS_ENSURE_ARG_POINTER(aCategoryName);
NS_ENSURE_ARG_POINTER(_retval);
CategoryNode* category;
{
MutexAutoLock lock(mLock);
category = get_category(aCategoryName);
}
if (!category) {
return NS_NewEmptyEnumerator(_retval);
}
return category->Enumerate(_retval);
}
// if the last token parsed is a user-defined modifier or
// opobject type, update its id
void opScanner::UserDefined() {
opList<opToken>::iterator start = Tokens.Begin();
opList<opToken>::iterator end = Tokens.End();
while (start != end) {
if (start->Id == T_ID) {
opString Value = start->Value;
// If this is a registered category, change the id.
if (DialectTracker::GetCategory(Value)) start->Id = T_OPOBJECT;
// If this is a registered enumeration, change the id.
else if (DialectTracker::GetEnumeration(Value))
start->Id = T_OPENUM;
else {
CategoryNode* classcategory =
DialectTracker::GetAltClassPrefix(Value);
CategoryNode* structcategory =
DialectTracker::GetAltStructPrefix(Value);
EnumerationNode* enumeration =
DialectTracker::GetAltEnumerationPrefix(Value);
// Registered class prefix?
if (classcategory && FixAltPrefix<T_CLASS, T_OPOBJECT>(
start, classcategory->GetName())) {
// do nothing
}
// Registered struct prefix?
else if (structcategory &&
FixAltPrefix<T_STRUCT, T_OPOBJECT>(
start, structcategory->GetName())) {
// do nothing
}
// Registered enum prefix?
else if (enumeration && FixAltPrefix<T_ENUM, T_OPENUM>(
start, enumeration->GetName())) {
// do nothing
}
}
}
++start;
}
}
NS_IMETHODIMP
nsCategoryManager::DeleteCategory( const char *aCategoryName )
{
NS_ENSURE_ARG_POINTER(aCategoryName);
// the categories are arena-allocated, so we don't
// actually delete them. We just remove all of the
// leaf nodes.
CategoryNode* category;
{
MutexAutoLock lock(mLock);
category = get_category(aCategoryName);
}
if (category) {
category->Clear();
NotifyObservers(NS_XPCOM_CATEGORY_CLEARED_OBSERVER_ID,
aCategoryName, nsnull);
}
return NS_OK;
}
NS_IMETHODIMP
nsCategoryManager::GetCategoryEntry( const char *aCategoryName,
const char *aEntryName,
char **_retval )
{
NS_ENSURE_ARG_POINTER(aCategoryName);
NS_ENSURE_ARG_POINTER(aEntryName);
NS_ENSURE_ARG_POINTER(_retval);
nsresult status = NS_ERROR_NOT_AVAILABLE;
CategoryNode* category;
{
MutexAutoLock lock(mLock);
category = get_category(aCategoryName);
}
if (category) {
status = category->GetLeaf(aEntryName, _retval);
}
return status;
}
void bimWorld::GraphFactory::AddGroups(CategoryNode child, YZ::Component* com, osg::Group* tree)
{
auto category = child.Value();
//if (!YZ::isValid(category))
//{
// // <没找到对应属性值>
// assert(false);
//}
std::string categoryValue = com->getStrValue(category);
//osg::ref_ptr<osg::Group> treeChild = new osg::Group();
std::vector<bimWorld::MultiStringKey> keys;
if (!child.getCategoryKey(keys))
{
assert(false);
return;
}
for(auto strKeyIter = keys.begin(); strKeyIter!=keys.end(); strKeyIter++)
{
auto strKey = *strKeyIter;
bimWorld::MultiStringKey subValueKey;
bimWorld::MultiStringKey tempParentStrKey;
auto base = tree;
for(auto strIter = strKey.begin(); strIter!=strKey.end(); strIter++)
{
auto str = *strIter;
// order
// 1f
// \|/
// 1f->管道
std::string categoryValue = com->getStrValue(str);
subValueKey.push_back(categoryValue);
tempParentStrKey.push_back(str);
if (!m_queryMap[tempParentStrKey][subValueKey])
{
osg::ref_ptr<osg::Group> group = new osg::Group();
group->setUserValue(NODE_HIGHLIGHTED, false);
group->setName(subValueKey.toString());
m_queryMap[tempParentStrKey][subValueKey] = group;
base->addChild(group);
base = group;
}
else
{
base = m_queryMap[tempParentStrKey][subValueKey];
}
}
base->addChild(com);
}
//treeChild->setName(categoryValue);
//if (lastChild)
//{
// treeChild->addChild(lastChild);
//}
//if (child.Parents().size() > 0)
//{
// for each (auto parent in child.Parents())
// {
// AddGroups(parent, com, treeChild);
// }
//}
//else
//{
// m_host->_ViewerData()->getModelRoot()->addChild(treeChild);
//}
}
