Esempio n. 1
0
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;
}
Esempio n. 2
0
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;
}
Esempio n. 4
0
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);
  }
}
Esempio n. 5
0
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);
}
Esempio n. 6
0
// 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;
    }
}
Esempio n. 7
0
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;
}
Esempio n. 8
0
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;
}
Esempio n. 9
0
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);
	//}
}