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;
}

Expression::Pointer
StandardElementHandler::Create(ExpressionConverter* converter, IConfigurationElement::Pointer element)
{
    std::string name = element->GetName();
    if (ExpressionTagNames::INSTANCEOF == name) {
        Expression::Pointer result(new InstanceofExpression(element));
        return result;
    } else if (ExpressionTagNames::TEST == name) {
        Expression::Pointer result(new TestExpression(element));
        return result;
    } else if (ExpressionTagNames::OR == name) {
        CompositeExpression::Pointer result(new OrExpression());
        this->ProcessChildren(converter, element, result);
        return result;
    } else if (ExpressionTagNames::AND == name) {
        CompositeExpression::Pointer result(new AndExpression());
        this->ProcessChildren(converter, element, result);
        return result;
    } else if (ExpressionTagNames::NOT == name) {
        IConfigurationElement::vector children(element->GetChildren());
        Expression::Pointer result(new NotExpression(converter->Perform(children[0])));
        return result;
    } else if (ExpressionTagNames::WITH == name) {
        CompositeExpression::Pointer result(new WithExpression(element));
        this->ProcessChildren(converter, element, result);
        return result;
    } else if (ExpressionTagNames::ADAPT == name) {
        CompositeExpression::Pointer result(new AdaptExpression(element));
        this->ProcessChildren(converter, element, result);
        return result;
    } else if (ExpressionTagNames::ITERATE == name) {
        CompositeExpression::Pointer result(new IterateExpression(element));
        this->ProcessChildren(converter, element, result);
        return result;
    } else if (ExpressionTagNames::COUNT == name) {
        Expression::Pointer result(new CountExpression(element));
        return result;
    } else if (ExpressionTagNames::SYSTEM_TEST == name) {
        Expression::Pointer result(new SystemTestExpression(element));
        return result;
    } else if (ExpressionTagNames::RESOLVE == name) {
        CompositeExpression::Pointer result(new ResolveExpression(element));
        this->ProcessChildren(converter, element, result);
        return result;
    } else if (ExpressionTagNames::ENABLEMENT == name) {
        CompositeExpression::Pointer result(new EnablementExpression(element));
        this->ProcessChildren(converter, element, result);
        return result;
    } else if (ExpressionTagNames::EQUALS == name) {
        Expression::Pointer result(new EqualsExpression(element));
        return result;
    } else if (ExpressionTagNames::REFERENCE == name) {
        Expression::Pointer result(new ReferenceExpression(element));
        return result;
    }
    return Expression::Pointer();
}

SmartPointer<Expression> RegistryPersistence::ReadWhenElement(
    const SmartPointer<IConfigurationElement>& parentElement,
    const QString& whenElementName, const QString& id,
    QList<SmartPointer<IStatus> >& warningsToLog)
{
  // Check to see if we have an when expression.
  const QList<IConfigurationElement::Pointer> whenElements = parentElement
      ->GetChildren(whenElementName);
  Expression::Pointer whenExpression;
  if (!whenElements.isEmpty())
  {
    // Check if we have too many when elements.
    if (whenElements.size() > 1)
    {
      // There should only be one when element
      AddWarning(warningsToLog,
                 "There should only be one when element", parentElement,
                 id, "whenElementName", whenElementName);
      return ERROR_EXPRESSION;
    }

    const IConfigurationElement::Pointer whenElement = whenElements.front();
    const QList<IConfigurationElement::Pointer> expressionElements = whenElement->GetChildren();
    if (!expressionElements.isEmpty())
    {
      // Check if we have too many expression elements
      if (expressionElements.size() > 1)
      {
        // There should only be one expression element
        AddWarning(warningsToLog, "There should only be one expression element", parentElement,
                   id, "whenElementName", whenElementName);
        return ERROR_EXPRESSION;
      }

      // Convert the activeWhen element into an expression.
      const ElementHandler::Pointer elementHandler = ElementHandler::GetDefault();
      ExpressionConverter* const converter = ExpressionConverter::GetDefault();
      const IConfigurationElement::Pointer expressionElement = expressionElements.front();
      try
      {
        whenExpression = elementHandler->Create(converter, expressionElement);
      }
      catch (const CoreException& /*e*/)
      {
        // There when expression could not be created.
        AddWarning(warningsToLog, "Problem creating when element",
                   parentElement, id, "whenElementName", whenElementName);
        return ERROR_EXPRESSION;
      }
    }
  }

  return whenExpression;
}

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);
}

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);
}

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;
}

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());
  }
}

bool PerspectiveExtensionReader::ProcessExtension(
    IConfigurationElement::Pointer element)
{
  IConfigurationElement::vector children = element->GetChildren();
  for (unsigned int nX = 0; nX < children.size(); nX++)
  {
    IConfigurationElement::Pointer child = children[nX];
    std::string type = child->GetName();
    if (this->IncludeTag(type))
    {
      bool result = false;
      if (type == WorkbenchRegistryConstants::TAG_ACTION_SET)
      {
        result = this->ProcessActionSet(child);
      }
      else if (type == WorkbenchRegistryConstants::TAG_VIEW)
      {
        result = this->ProcessView(child);
      }
      else if (type == WorkbenchRegistryConstants::TAG_VIEW_SHORTCUT)
      {
        result = this->ProcessViewShortcut(child);
      }
//      else if (type == IorkbenchRegistryConstants::TAG_NEW_WIZARD_SHORTCUT)
//      {
//        result = processWizardShortcut(child);
//      }
      else if (type == WorkbenchRegistryConstants::TAG_PERSP_SHORTCUT)
      {
        result = this->ProcessPerspectiveShortcut(child);
      }
      else if (type == WorkbenchRegistryConstants::TAG_SHOW_IN_PART)
      {
        result = this->ProcessShowInPart(child);
      }
      if (!result)
      {
        WorkbenchPlugin::Log("Unable to process element: " + //$NON-NLS-1$
            type + " in perspective extension: " + //$NON-NLS-1$
            element->GetDeclaringExtension()->GetUniqueIdentifier());
      }
    }
  }
  return true;
}

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;
  }
}

  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;
  }

std::string RegistryReader::GetDescription(IConfigurationElement::Pointer configElement)
{
  IConfigurationElement::vector children(configElement->GetChildren(WorkbenchRegistryConstants::TAG_DESCRIPTION));
  if (children.size() >= 1)
  {
    return children[0]->GetValue();
  }
  return "";//$NON-NLS-1$
}

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;
}

 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);
   }
 }

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);
}

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

bool PerspectiveExtensionReader::ReadElement(
    IConfigurationElement::Pointer element)
{
  std::string type = element->GetName();
  if (type == WorkbenchRegistryConstants::TAG_PERSPECTIVE_EXTENSION)
  {
    std::string id;
    element->GetAttribute(WorkbenchRegistryConstants::ATT_TARGET_ID, id);
    if (targetID == id || "*" == id)
    { //$NON-NLS-1$
//      if (tracker != null)
//      {
//        tracker.registerObject(element.getDeclaringExtension(),
//            new DirtyPerspectiveMarker(id), IExtensionTracker.REF_STRONG);
//      }
      return this->ProcessExtension(element);
    }
    return true;
  }
  return false;
}