C++ Pointer::GetAttribute方法代码示例

IterateExpression::IterateExpression(
    const IConfigurationElement::Pointer& configElement)
{
  QString opValue = configElement->GetAttribute(ATT_OPERATOR);
  this->InitializeOperatorValue(opValue);
  this->InitializeEmptyResultValue(configElement->GetAttribute(ATT_IF_EMPTY));
}

SystemTestExpression::SystemTestExpression(const IConfigurationElement::Pointer& element)
{
  fProperty = element->GetAttribute(ATT_PROPERTY);
  Expressions::CheckAttribute(ATT_PROPERTY, fProperty);
  fExpectedValue = element->GetAttribute(ATT_VALUE);
  Expressions::CheckAttribute(ATT_VALUE, fExpectedValue);
}

SystemTestExpression::SystemTestExpression(IConfigurationElement::Pointer element)
{
  bool result = element->GetAttribute(ATT_PROPERTY, fProperty);
  Expressions::CheckAttribute(ATT_PROPERTY, result);
  result = element->GetAttribute(ATT_VALUE, fExpectedValue);
  Expressions::CheckAttribute(ATT_VALUE, result);
}

bool PerspectiveRegistryReader::ReadElement(const IConfigurationElement::Pointer &element)
{
  if (element->GetName() == WorkbenchRegistryConstants::TAG_PERSPECTIVE)
  {
    try
    {
      QString id = element->GetAttribute(WorkbenchRegistryConstants::ATT_ID);
      PerspectiveDescriptor::Pointer desc(
          new PerspectiveDescriptor(id, element));
      QList<berry::IConfigurationElement::Pointer> childs = element->GetChildren("description");
      if (!childs.isEmpty())
      {
        desc->SetDescription(childs[0]->GetValue());
      }
      registry->AddPerspective(desc);
    }
    catch (const CoreException& e)
    {
      // log an error since its not safe to open a dialog here
      WorkbenchPlugin::Log("Unable to create layout descriptor.", e);//$NON-NLS-1$
    }
    return true;
  }

  return false;
}

TestExpression::TestExpression(const IConfigurationElement::Pointer& element)
{
  QString property = element->GetAttribute(ATT_PROPERTY);
  int pos = property.lastIndexOf(PROP_SEP);
  if (pos == -1)
  {
    IStatus::Pointer status(new ExpressionStatus(
                              ExpressionStatus::NO_NAMESPACE_PROVIDED,
                              "The property attribute of the test expression must be qualified by a name space.",
                              BERRY_STATUS_LOC));
    throw CoreException(status);
  }
  fNamespace = property.left(pos);
  fProperty = property.mid(pos + 1);
  fArgs = Expressions::GetArguments(element, ATT_ARGS);
  fExpectedValue = Expressions::ConvertArgument(element->GetAttribute(ATT_VALUE));
  fForcePluginActivation = Expressions::GetOptionalBooleanAttribute(element, ATT_FORCE_PLUGIN_ACTIVATION);
}

void PartSite::SetConfigurationElement(
    IConfigurationElement::Pointer configElement)
{

  // Get extension ID.
  configElement->GetAttribute("id", extensionID); //$NON-NLS-1$

  // Get plugin ID.
  pluginID = configElement->GetContributor();

  // Get extension name.
  std::string name;
  configElement->GetAttribute("name", name); //$NON-NLS-1$
  if (name != "")
  {
    extensionName = name;
  }
}

 void
 Expressions::GetArguments(std::vector<Object::Pointer>& args, IConfigurationElement::Pointer element, const std::string& attributeName)
 {
   std::string value;
   if (element->GetAttribute(attributeName, value))
   {
     ParseArguments(args, value);
   }
 }

  bool
  Expressions::GetOptionalBooleanAttribute(IConfigurationElement::Pointer element, const std::string& attributeName)
  {
    std::string value;
    if (element->GetAttribute(attributeName, value))
      return Poco::toLower<std::string>(value) == "true";

    return false;
  }

bool PerspectiveExtensionReader::ProcessPerspectiveShortcut(
    IConfigurationElement::Pointer element)
{
  std::string id;
  if (element->GetAttribute(WorkbenchRegistryConstants::ATT_ID, id))
  {
    pageLayout->AddPerspectiveShortcut(id);
  }
  return true;
}

QSharedPointer<ctkPlugin> WorkbenchPlugin::GetBundleForExecutableExtension(
    const IConfigurationElement::Pointer& element, const QString& extensionName)
{
  // this code is derived heavily from
  // ConfigurationElement.createExecutableExtension.
  QString prop;
  QString executable;
  QString contributorName;
  int i = 0;

  if (!extensionName.isNull())
    prop = element->GetAttribute(extensionName);
  else
  {
    // property not specified, try as element value
    prop = element->GetValue();
    if (!prop.isNull())
    {
      prop = prop.trimmed();
      if (prop.isEmpty())
        prop = QString();
    }
  }

  if (prop.isNull())
  {
    // property not defined, try as a child element
    QList<IConfigurationElement::Pointer> exec(element->GetChildren(extensionName));
    if (!exec.isEmpty())
      contributorName = exec[0]->GetAttribute("plugin");
  }
  else
  {
    // simple property or element value, parse it into its components
    i = prop.indexOf(':');
    if (i != -1)
      executable = prop.left(i).trimmed();
    else
      executable = prop;

    i = executable.indexOf('/');
    if (i != -1)
      contributorName = executable.left(i).trimmed();
  }

  if (contributorName.isNull())
    contributorName = element->GetContributor()->GetName();

  return Platform::GetPlugin(contributorName);
}

IBundle::Pointer WorkbenchPlugin::GetBundleForExecutableExtension(
    IConfigurationElement::Pointer element, const std::string& extensionName)
{
  // this code is derived heavily from
  // ConfigurationElement.createExecutableExtension.
  std::string prop;
  std::string executable;
  std::string contributorName;
  std::string::size_type i;

  if (extensionName != "")
    element->GetAttribute(extensionName, prop);
  else
  {
    // property not specified, try as element value
    prop = element->GetValue();
    if (prop != "")
    {
      Poco::trimInPlace(prop);
    }
  }

  if (prop == "")
  {
    // property not defined, try as a child element
    IConfigurationElement::vector exec(element->GetChildren(extensionName));
    if (exec.size() != 0)
      exec[0]->GetAttribute("plugin", contributorName); //$NON-NLS-1$
  }
  else
  {
    // simple property or element value, parse it into its components
    i = prop.find_first_of(':');
    if (i != std::string::npos)
      executable = Poco::trim(prop.substr(0, i));
    else
      executable = prop;

    i = executable.find_first_of('/');
    if (i != std::string::npos)
      contributorName = Poco::trim(executable.substr(0, i));

  }

  if (contributorName == "")
    contributorName = element->GetContributor();

  return Platform::GetBundle(contributorName);
}

bool WorkbenchPlugin::HasExecutableExtension(
    const IConfigurationElement::Pointer& element, const QString& extensionName)
{
  if (!element->GetAttribute(extensionName).isNull()) return true;

  QString elementText = element->GetValue();
  if (!elementText.isEmpty()) return true;

  QList<IConfigurationElement::Pointer> children(element->GetChildren(extensionName));
  if (children.size() == 1)
  {
    if (!(children[0]->GetAttribute(WorkbenchRegistryConstants::ATT_CLASS).isNull()))
      return true;
  }
  return false;
}

void RegistryReader::LogError(IConfigurationElement::Pointer element,
    const std::string& text)
{
  const IExtension* extension = element->GetDeclaringExtension();
  std::string buf = "Plugin " + extension->GetNamespace() + ", extension "
      + extension->GetExtensionPointIdentifier();
  // look for an ID if available - this should help debugging
  std::string id;
  if (element->GetAttribute("id", id))
  {
    buf.append(", id ");
    buf.append(id);
  }
  buf.append(": " + text);
  WorkbenchPlugin::Log(buf);
}

IntroDescriptor::IntroDescriptor(IConfigurationElement::Pointer configElement)
    throw (CoreException) :
  element(configElement)
{
  std::string val;
  if (!configElement->GetAttribute(WorkbenchRegistryConstants::ATT_CLASS, val))
  {
    //TODO IStatus
    /*
    throw CoreException(new Status(IStatus.ERROR,
        configElement .getNamespace(), 0,
        "Invalid extension (Missing class name): " + getId(), //$NON-NLS-1$
        null));
        */
    throw CoreException(configElement->GetContributor() + ": Invalid extension (Missing className): " + GetId());
  }
}

std::string RegistryReader::GetClassValue(
    IConfigurationElement::Pointer configElement,
    const std::string& classAttributeName)
{
  std::string className;
  if (configElement->GetAttribute(classAttributeName, className))
  {
    return className;
  }
  IConfigurationElement::vector candidateChildren(configElement->GetChildren(classAttributeName));
  if (candidateChildren.size() == 0)
  {
    return "";
  }

  candidateChildren[0]->GetAttribute(WorkbenchRegistryConstants::ATT_CLASS, className);
  return className;
}