C++ (Cpp) ObjectTag Exemples

Exemple #1

ObjectTag ObjectTag::fromString(const QString& str) {
  QStringList l = str.split(tagSeparator);
  if (l.isEmpty()) {
    return invalidTag;
  }

  QString t = l.last();
  l.pop_back();
  return ObjectTag(t, l);
}

Exemple #2

Fichier : basicplugin.cpp Projet : Kst-plot/kst-subversion-archive

DataObjectPtr BasicPlugin::makeDuplicate() const {
#if 0
  BasicPluginPtr plugin = kst_cast<BasicPlugin>(DataObject::createPlugin(propertyString()));

  // use same inputs
  for (VectorMap::ConstIterator iter = _inputVectors.begin(); iter != _inputVectors.end(); ++iter) {
    plugin->inputVectors().insert(iter.key(), iter.value());
  }
  for (ScalarMap::ConstIterator iter = _inputScalars.begin(); iter != _inputScalars.end(); ++iter) {
    plugin->inputScalars().insert(iter.key(), iter.value());
  }
  for (StringMap::ConstIterator iter = _inputStrings.begin(); iter != _inputStrings.end(); ++iter) {
    plugin->inputStrings().insert(iter.key(), iter.value());
  }

  // create new outputs
  for (VectorMap::ConstIterator iter = outputVectors().begin(); iter != outputVectors().end(); ++iter) {
    KstWriteLocker blockVectorUpdates(&vectorList.lock());
    VectorPtr v = new Vector(ObjectTag(iter.value()->tag().tag() + "'", iter.value()->tag().context()), 0, plugin.data()); // FIXME: unique tag generation
    plugin->outputVectors().insert(iter.key(), v);
  }
  for (ScalarMap::ConstIterator iter = outputScalars().begin(); iter != outputScalars().end(); ++iter) {
    ScalarPtr s = new Scalar(ObjectTag(iter.value()->tag().tag() + "'", iter.value()->tag().context()), plugin.data()); // FIXME: unique tag generation
    plugin->outputScalars().insert(iter.key(), s);
  }
  for (StringMap::ConstIterator iter = outputStrings().begin(); iter != outputStrings().end(); ++iter) {
    StringPtr s = new String(ObjectTag(iter.value()->tag().tag() + "'", iter.value()->tag().context()), plugin.data()); // FIXME: unique tag generation
    plugin->outputStrings().insert(iter.key(), s);
  }

  // set the same plugin
  plugin->setTagName(ObjectTag(tag().tag() + "'", tag().context())); // FIXME: unique tag generation method
  map.insert(this, DataObjectPtr(plugin));
  return DataObjectPtr(plugin);
#endif
  // FIXME: implement this
  return 0L;
}

Exemple #3

namespace Kst {

/** Tag globals */
const QChar ObjectTag::tagSeparator = QChar('/');
const QChar ObjectTag::tagSeparatorReplacement = QChar('_');

const QStringList ObjectTag::globalTagContext = QStringList();
const QStringList ObjectTag::constantTagContext = QStringList("CONSTANTS");
const QStringList ObjectTag::orphanTagContext = QStringList();

const ObjectTag ObjectTag::invalidTag = ObjectTag(QString::null, ObjectTag::globalTagContext);


ObjectTag::ObjectTag()
  : _minDisplayComponents(0), _uniqueDisplayComponents(UINT_MAX) {
}


ObjectTag::ObjectTag(const QString& name, const QStringList& context,
                           unsigned int minDisplayComponents)
  : _name(cleanTagComponent(name)),
    _context(context),
    _minDisplayComponents(minDisplayComponents),
    _uniqueDisplayComponents(UINT_MAX) {
}


ObjectTag::ObjectTag(const QString& name, const ObjectTag& contextTag,
                           bool alwaysShowContext)
  : _uniqueDisplayComponents(UINT_MAX) {

  _name = cleanTagComponent(name);
  _context = contextTag.fullTag();
  _minDisplayComponents = 1 + (alwaysShowContext ? qMax(contextTag._minDisplayComponents, (unsigned int)1) : 0);
}


ObjectTag::ObjectTag(const QStringList &fullTag)
  : _minDisplayComponents(1), _uniqueDisplayComponents(UINT_MAX) {

  if (fullTag.isEmpty()) {
    _minDisplayComponents = 0;
  } else {
    QStringList context = fullTag;
    _name = cleanTagComponent(context.last());
    context.pop_back();
    _context = context;
  }
}


QString ObjectTag::name() const {
  return _name;
}


QStringList ObjectTag::fullTag() const {
  QStringList ft(_context);
  if (!_name.isEmpty()) {
    ft << _name;
  }
  return ft;
}


QStringList ObjectTag::context() const {
  return _context;
}


unsigned int ObjectTag::components() const {
  if (!isValid()) {
    return 0;
  } else {
    return 1 + _context.count();
  }
}


void ObjectTag::setName(const QString& name) {
  _name = cleanTagComponent(name);
  _uniqueDisplayComponents = UINT_MAX;
}


void ObjectTag::setContext(const QStringList& context) {
  _context = context;
  _uniqueDisplayComponents = UINT_MAX;
}


void ObjectTag::setTag(const QString& name, const QStringList& context) {
  setName(name);
  setContext(context);
}


bool ObjectTag::isValid() const {
  return !_name.isEmpty();
}


QString ObjectTag::tagString() const {
  return fullTag().join(tagSeparator);
}


void ObjectTag::setUniqueDisplayComponents(unsigned int n) {
  _uniqueDisplayComponents = n;
}


unsigned int ObjectTag::uniqueDisplayComponents() const {
  return _uniqueDisplayComponents;
}


void ObjectTag::setMinDisplayComponents(unsigned int n) {
  _minDisplayComponents = n;
}


QStringList ObjectTag::displayFullTag() const {
  QStringList out_tag = _context + QStringList(_name);
  int componentsToDisplay = qMin(qMax(_uniqueDisplayComponents, _minDisplayComponents), components());
  while (out_tag.count() > componentsToDisplay) {
    out_tag.pop_front();
  }
  return out_tag;
}


QString ObjectTag::displayString() const {
  return displayFullTag().join(tagSeparator);
}


ObjectTag ObjectTag::fromString(const QString& str) {
  QStringList l = str.split(tagSeparator);
  if (l.isEmpty()) {
    return invalidTag;
  }

  QString t = l.last();
  l.pop_back();
  return ObjectTag(t, l);
}


bool ObjectTag::operator==(const ObjectTag& tag) const {
  return (_name == tag._name && _context == tag._context);
}


bool ObjectTag::operator!=(const ObjectTag& tag) const {
  return (_name != tag._name || _context != tag._context);
}


QString ObjectTag::cleanTagComponent(const QString& component) {
  if (component.contains(tagSeparator)) {
    QString s = component;
    s.replace(tagSeparator, tagSeparatorReplacement);
//        kstdWarning() << "cleaning tag component containing " << tagSeparator << ":\"" << component << "\" -> \"" << s << "\"" << endl;
    return s;
  } else {
    return component;
  }
}


uint qHash(const ObjectTag& tag) {
  // FIXME: better hash function
//  return qHash(tag._name) + qHash(tag._context);
  return qHash(tag.name());
}


}