C++ Property::GetName方法代码示例

//----------------------------------------------------------------
bool PropertyList::ReadNode(wxXmlNode* node)
/**
 * \brief Read out a 'properties' xml element node or a 'property'
 * xml element node where type attribute is 'properties'.
 * See class description for structure of such an xml node.
 * \param node The 'properties' xml element node or 'property' node
 * with spezific a spezific type.
 * \return True on success; false otherwise.
 **/
{
    // Fehler abfangen
    if (unlikely(node == NULL)) {
        wxLogError(_T("[penv::PropertyList::ReadNode] Properties node is NULL."));
        return (false);
    }
    if (unlikely(node->GetType() != wxXML_ELEMENT_NODE)) {
        wxLogError(_T("[penv::PropertyList::ReadNode] Given properties node '%s' is not an element."), node->GetName().c_str());
        return (false);
    }
    if (node->GetName() != _T("properties") && (node->GetName() == _T("property") &&
        node->GetPropVal(_T("type"), wxEmptyString) != _T("properties")))
    {
        wxLogError(_T("[penv::PropertyList::ReadNode] Node must have the name 'properties' or 'property' with type set to 'properties'."));
        return (false);
    }
    // Alle Elemente in dem Node einlesen
    wxXmlNode* child = node->GetChildren();
    while (child != NULL)
    {
        // Nicht Element Knoten überspringen
        if (child->GetType() != wxXML_ELEMENT_NODE || child->GetName() != _T("property")) {
            child = child->GetNext();
            continue;
        }
        // Property erstellen und auslesen
        Property* prop = new Property();
        if (unlikely(!prop->ReadNode(child))) {
            // Wenn ein Fehler aufgetreten ist, dann eine Warning ausgeben
            // und nicht hinzufügen
            wxLogWarning(_T("[penv::PropertyList::ReadNode] Could not read property \"%s\"."), child->GetName().c_str());
        } else {
            // Überprüfen, ob das Property mit dem Namen schon in der
            // Liste existiert
            if (m_hashmap->find(prop->GetName()) != m_hashmap->end()) {
                wxLogWarning(_T("[penv::PropertyList::ReadNode] Property with the name \"%s\" already exists."), prop->GetName().c_str());
            } else {
                (*m_hashmap)[prop->GetName()] = prop;
            }
        }
        child = child->GetNext();
    }
    return (true);
}

//----------------------------------------------------------------
void PropertyList::SetProperty(const wxString& propname, const Property& prop)
/**
 * \brief Sets the property with the given name. If the property does
 * not exists the property will be created. If the property already exists
 * the property will be overridden.
 * \param propname The property name.
 * \param prop The property.
 **/
{
    Property* setprop = GetProperty(propname, true);
    if (setprop->GetType() != prop.GetType())
    {
        setprop->SetType(prop.GetType());
        setprop->SetName(prop.GetName());
    }
    switch (setprop->GetType())
    {
        case penvPT_Boolean:
            setprop->SetBoolean(prop.GetBoolean());
        break;
        case penvPT_Integer:
            setprop->SetInteger(prop.GetInteger());
        break;
        case penvPT_Double:
            setprop->SetDouble(prop.GetDouble());
        break;
        case penvPT_String:
            setprop->SetString(prop.GetString());
        break;
        case penvPT_Properties:
            setprop->SetPropertyList(prop.GetPropertyList());
        break;
        case penvPT_ArrayBoolean:
            NOT_IMPLEMENTED_YET();
        break;
        case penvPT_ArrayInteger:
            NOT_IMPLEMENTED_YET();
        break;
        case penvPT_ArrayDouble:
            NOT_IMPLEMENTED_YET();
        break;
        case penvPT_ArrayString:
            NOT_IMPLEMENTED_YET();
        break;
        default:
            wxString msg = wxString::Format(_T("Unknown type for property %s."), setprop->GetName().c_str());
        break;
    }
}

QVariant QPropertyModel::data(const QModelIndex& index, int role) const
{
    if( !index.isValid() )
        return QVariant();

    if( role != Qt::DisplayRole && role != Qt::ToolTipRole && role != Qt::StatusTipRole )
        return QVariant();

    Property* prop = GetProperty(index);

    if( role == Qt::ToolTipRole || role == Qt::StatusTipRole )
        return QVariant(prop->GetDescription());

    if( index.column() == PROPERTY_COLUMN )
    {
        if( IsComponent(index) )
            return QVariant(prop->GetComponentName(index.row()));
        else
            return QVariant(prop->GetName());
    }
    else
    {
        String str;

        if( IsComponent(index) )
            prop->GetComponentValueString(mEdited, GetComponentIndex(index), str);  
        else
            prop->GetValueString(mEdited, str);

        return QVariant(str.c_str());
    }
}

// }}}
// {{{ void Property::ParsePropertyElement(wxXmlNode *node)
void Property::ParsePropertyElement(wxXmlNode *node) {
	address = node->GetPropVal(wxT("address"), wxEmptyString);
	className = node->GetPropVal(wxT("classname"), wxEmptyString);
	constant = (node->GetPropVal(wxT("constant"), wxT("0")) == wxT("1"));
	fullName = node->GetPropVal(wxT("fullname"), wxEmptyString);
	hasChildren = (node->GetPropVal(wxT("children"), wxT("0")) == wxT("1"));
	key = node->GetPropVal(wxT("key"), wxEmptyString);
	name = node->GetPropVal(wxT("name"), wxEmptyString);
	size = StringToULong(node->GetPropVal(wxT("size"), wxT("0")));

	try {
		type = conn->TypemapGet().GetType(node->GetPropVal(wxT("type"), wxT("undefined")));
	}
	catch (Error e) {
		type = Type();
	}

	data = node->GetNodeContent();

	for (wxXmlNode *child = node->GetChildren(); child != NULL; child = child->GetNext()) {
		if (child->GetType() == wxXML_ELEMENT_NODE && child->GetName() == wxT("property")) {
			Property *prop = new Property(conn, context, depth, this);
			prop->ParsePropertyElement(child);
			children[prop->GetName()] = prop;
		}
	}
}

Mesh* ModelLoader::LoadMesh(BinaryReader &br)
{
    Mesh *mesh = new Mesh();
    mesh ->id = br.Read<int>();
    mesh->name = br.Read<std::string>();

    if (m_fileVersion > 0)
    {
        for (int i = 0; i < 16; i++)
            mesh->m_worldInverseMatrix.a[i] = br.Read<float>();

        mesh->m_worldMatrix = mesh->m_worldInverseMatrix.GetInversed();
    }

    int meshPartsCount = br.Read<int>();

    for (int i = 0; i < meshPartsCount; i++)
    {
        MeshPart *meshPart = LoadMeshPart(br);
        meshPart->mesh = mesh;
        mesh ->AddMeshPart(meshPart);
    }

    int propsCount = br.Read<int>();
    for (int i = 0; i < propsCount; i++)
    {
        Property *prop = LoadProperty(br);
        mesh->m_properties[prop->GetName()] = prop;
    }

    return mesh;
}

//----------------------------------------------------------------
wxXmlNode* PropertyList::WriteNode()
/**
* \brief Writes a 'properties' xml element node.
 * See class description for structure of such an xml node.
 * \return The 'properties' xml element node; or NULL on error.
 **/
{
    wxXmlNode* node = PenvHelper::CreateXmlNode(_T("properties"));
    PropertiesHashMap::iterator itr;
    for (itr = m_hashmap->begin(); itr != m_hashmap->end(); itr++)
    {
        Property* prop = itr->second;
        wxXmlNode* child = prop->WriteNode();
        if (child == NULL)
        {
            wxLogError(_T("[penv::PropertyList::WriteNode] Failed to write property '%s', skipping."), prop->GetName().c_str());
            continue;
        }
        PenvHelper::AddXmlChildNode(node, child);
    }
    return (node);
}