C++ PropertyValue类代码示例

void PropertyNode::setStr( const std::string &name, const std::string &val ) const{
	PropertyValue *property = getPropertyRecursively( name );
	if (!property) {
		throw std::runtime_error( "Value not exists: " + name );
	}
	return property->setStr(val);
}

bool _IgnoreActorsToProp(const ClassDefinition *pClass, PCTSTR pszProp, PropertyValue& value)
{
    const SendParam *pSendParam;
    bool fRet = _FindSelfSendParamInInit(pClass, SCIMETHOD_IGNOREACTORS, &pSendParam);
    if (fRet)
    {
        // See what the value is.
        if (pSendParam->HasValue())
        {
            fRet = _GetFirstSimpleValueInCodeSegmentArray(pSendParam->GetSelectorParams(), value);
        }
        if (!fRet)
        {
            // "ignoreActors()"
            // No params means yes, ignore actors.
            value.SetValue(1);
            fRet = true;
        }
    }
    else
    {
        // We didn't find any call to ignoreActors.  By default actors are not ignored.
        // (Actually, it would depend on bit $4000 of the signal property technically)
        value.SetValue(0);
        fRet = true;
    }
    return fRet;
}

void shallowCopyDataBack(const std::vector<unsigned int> & stateful_prop_ids, MaterialProperties & data, MaterialProperties & data_from)
{
  for (unsigned int i=0; i<stateful_prop_ids.size(); ++i)
  {
    PropertyValue * prop = data[i];                                 // do the look-up just once (OPT)
    PropertyValue * prop_from = data_from[stateful_prop_ids[i]];    // do the look-up just once (OPT)
    if (prop != NULL && prop_from != NULL)
      prop->swap(prop_from);
  }
}

/**
 * Shallow copy the material properties
 * @param stateful_prop_ids List of IDs with properties to shallow copy
 * @param data Destination data
 * @param data_from Source data
 */
void
shallowCopyData(const std::vector<unsigned int> & stateful_prop_ids,
                MaterialProperties & data,
                MaterialProperties & data_from)
{
  for (unsigned int i = 0; i < stateful_prop_ids.size(); ++i)
  {
    if (i >= data_from.size() || stateful_prop_ids[i] >= data.size())
      continue;
    PropertyValue * prop = data[stateful_prop_ids[i]]; // do the look-up just once (OPT)
    PropertyValue * prop_from = data_from[i];          // do the look-up just once (OPT)
    if (prop != nullptr && prop_from != nullptr)
      prop->swap(prop_from);
  }
}

void
FramePropertyTable::Set(nsIFrame* aFrame, const FramePropertyDescriptor* aProperty,
                        void* aValue)
{
  NS_ASSERTION(aFrame, "Null frame?");
  NS_ASSERTION(aProperty, "Null property?");

  if (mLastFrame != aFrame || !mLastEntry) {
    mLastFrame = aFrame;
    mLastEntry = mEntries.PutEntry(aFrame);
  }
  Entry* entry = mLastEntry;

  if (!entry->mProp.IsArray()) {
    if (!entry->mProp.mProperty) {
      // Empty entry, so we can just store our property in the empty slot
      entry->mProp.mProperty = aProperty;
      entry->mProp.mValue = aValue;
      return;
    }
    if (entry->mProp.mProperty == aProperty) {
      // Just overwrite the current value
      entry->mProp.DestroyValueFor(aFrame);
      entry->mProp.mValue = aValue;
      return;
    }

    // We need to expand the single current entry to an array
    PropertyValue current = entry->mProp;
    entry->mProp.mProperty = nullptr;
    static_assert(sizeof(nsTArray<PropertyValue>) <= sizeof(void *),
                  "Property array must fit entirely within entry->mProp.mValue");
    new (&entry->mProp.mValue) nsTArray<PropertyValue>(4);
    entry->mProp.ToArray()->AppendElement(current);
  }

  nsTArray<PropertyValue>* array = entry->mProp.ToArray();
  nsTArray<PropertyValue>::index_type index =
    array->IndexOf(aProperty, 0, PropertyComparator());
  if (index != nsTArray<PropertyValue>::NoIndex) {
    PropertyValue* pv = &array->ElementAt(index);
    pv->DestroyValueFor(aFrame);
    pv->mValue = aValue;
    return;
  }

  array->AppendElement(PropertyValue(aProperty, aValue));
}

bool _AddToPicToProp(const ClassDefinition *pClass, PCTSTR pszProp, PropertyValue& value)
{
    const SendParam *pSendParam;
    // This only depends on whether we found an addToPic call
    value.SetValue(_FindSelfSendParamInInit(pClass, SCIMETHOD_ADDTOPIC, &pSendParam) ? 1 : 0);
    return true;
}

  void
  NotifConfig::load()
  throw (NotifConfig::GeneralConfigError)
  {
    string filename = get_storage_filename();

    fstream file(filename.c_str(), ios::in);

    if (!file.good())
    {
      string msg = "cannot open config file '";
      msg.append(filename + "' for loading");
      throw NotifConfig::GeneralConfigError(msg);
    }

    string line,head,tail;
    int n;
    getline(file, line);
    while (!file.eof())
    {
      if (line == "")
        continue;
      n = line.find(" ");
      head = line.substr(0, n);
      tail = line.substr(n + 1);
      try
      {
        PropertyValue * value = find(head);
        value->from_string(tail);
      }
      catch (PropertyNotFound & e)
      {
        string msg = "cannot load config from disk: key '";
        msg.append(e.property_name + "' not found");
        throw GeneralConfigError(msg);
      }
      catch (PropertyValue::InvalidStringFormat & e)
      {
        string msg = "cannot load config from disk: key '";
        msg.append(head + "' cannot be correctly interpreted");
        throw GeneralConfigError(msg);
      }
      getline(file,line);
    }
    file.close();
  }

static void setValue(void *dst, valuetype_t dstType, PropertyValue const &pvalue)
{
    switch (dstType)
    {
    case DDVT_FIXED:
        *((fixed_t *) dst) = pvalue.asFixed();
        break;
    case DDVT_FLOAT:
        *(  (float *) dst) = pvalue.asFloat();
        break;
    case DDVT_DOUBLE:
        *( (double *) dst) = pvalue.asDouble();
        break;
    case DDVT_BYTE:
        *(   (byte *) dst) = pvalue.asByte();
        break;
    case DDVT_INT:
        *(    (int *) dst) = pvalue.asInt32();
        break;
    case DDVT_SHORT:
        *(  (short *) dst) = pvalue.asInt16();
        break;
    case DDVT_ANGLE:
        *((angle_t *) dst) = pvalue.asAngle();
        break;
    default:
        throw Error("setValue", QString("Unknown value type %d").arg(dstType));
    }
}

void Portal::SetProp(PropertyKey key, PropertyValue value)
{
  Trigger::SetProp(key, value);
  switch (key)
  {
  case PROP_DEST_ID:
    m_destId = value.GetInt();
  }
}

int main()
{
   {
	  testcallback tcb;
	  string p("/a/bb/ccc/dddd/eeeee/ffffff");
	  cout << " print #1" << endl;
	  mgr.print();
	  
	  PropertyValue * p1 = mgr.addLeaf("/test/wholenumber");
	  p1->set(17);
	  PropertyValue * p2;
	  (p2 = mgr.addLeaf("/lesser/floatno"))->set(-0.334f);
	  PropertyValue * p3;
	  (p3 = mgr.addLeaf("/dict/text/str"))->set(string("laber"));
	  //PropertyValue * nd =
	                        mgr.addLeaf("/i/am/notdefined");
	  PropertyValue * p4;
	  (p4 = mgr.addLeaf("/logical/notlogic/MisterBoole"))->set(true);
	  cout << " print #2" << endl;
	  mgr.print();
	  p1->registerOnChange(&tcb);
	  p1->set(99);
	  
	  cout << " print #3" << endl;
	  mgr.print();
//	  PropertyValue * r0 = 
                            mgr.get("/this/does/not/exist");
	  PropertyValue * r1 = mgr.get("/test/wholenumber");
	  PropertyValue * notdef = mgr.get("/i/am/notdefined");
	  notdef->set(false);
	  cout << "getPath test: " << p1->getPath() << endl;
	  cout << "\\\\\\\\\\\\\\" << "comparing p1 and r1: p1=" << &p1 << "  r1=" << r1 << endl;
	  r1->set(23);
	  PropertyValue * r3 = mgr.get("/dict/text/str");
	  r3->set(string("unit TESTING in progress..."));
	  
	  mgr.run();

	  cout << " print #4" << endl;
	  mgr.print();
   }
   
   exit(0);
}

Variant GetDPByExpExpression::Evaluate(Expressive::EvalContext* context)
{
	Object* obj = m_object->Evaluate(context);
	DependencyObject* depObj = dynamic_cast<DependencyObject*>(obj);
	if (depObj == NULL)
	{
		VERIFY(0);
	}
	Variant propertyRef = m_exp->Evaluate(context);

	PropertyValue* pProperty;

	if (propertyRef.IsString())
		pProperty = depObj->GetProperty(depObj->GetClass()->GetLocalProperty(propertyRef.ToString()));
	else if (propertyRef.IsInt())
		pProperty = depObj->GetProperty(depObj->GetClass()->GetLocalProperty((int)propertyRef));
	else
		throw new Exception("property not found");

	return pProperty->GetComputedValue();
}

bool _PriorityClassToProp(const ClassDefinition *pClass, PCTSTR pszProp, PropertyValue& value)
{
    const SendParam *pSendParam;
    bool fRet = _FindSelfSendParamInInit(pClass, SCIMETHOD_SETPRI, &pSendParam);
    if (fRet)
    {
        // See what the value is.
        if (pSendParam->HasValue())
        {
            fRet = _GetFirstSimpleValueInCodeSegmentArray(pSendParam->GetSelectorParams(), value);
        }
    }
    if (!fRet)
    {
        // We didn't find anything.  The default value for priority tends to be zero, but that isn't
        // accurate.  It depends on the signal property.
        // Instead we'll use -1 as a sentinel value indicating "default priority".
        value.SetValue((WORD)-1);
        fRet = true;
    }
    return fRet;
}

std::vector<FontStack> Parser::fontStacks() const {
    std::set<FontStack> result;

    for (const auto& layer : layers) {
        if (layer->is<SymbolLayer>()) {
            PropertyValue<FontStack> textFont = layer->as<SymbolLayer>()->getTextFont();
            if (textFont.isUndefined()) {
                result.insert({"Open Sans Regular", "Arial Unicode MS Regular"});
            } else if (textFont.isConstant()) {
                result.insert(textFont.asConstant());
            } else if (textFont.isFunction()) {
                for (const auto& stop : textFont.asFunction().getStops()) {
                    result.insert(stop.second);
                }
            }
        }
    }

    return std::vector<FontStack>(result.begin(), result.end());
}

std::vector<FontStack> Parser::fontStacks() const {
    std::set<FontStack> optional;

    for (const auto& layer : layers) {
        if (layer->is<SymbolLayer>()) {
            PropertyValue<FontStack> textFont = layer->as<SymbolLayer>()->getTextFont();
            if (textFont.isUndefined()) {
                optional.insert({"Open Sans Regular", "Arial Unicode MS Regular"});
            } else if (textFont.isConstant()) {
                optional.insert(textFont.asConstant());
            } else if (textFont.isCameraFunction()) {
                textFont.asCameraFunction().stops.match(
                    [&] (const auto& stops) {
                        for (const auto& stop : stops.stops) {
                            optional.insert(stop.second);
                        }
                    }
                );
            }
        }
    }

    return std::vector<FontStack>(optional.begin(), optional.end());
}

float evaluate(PropertyValue<float> value, float zoom) {
    return value.evaluate(PropertyEvaluator<float>(PropertyEvaluationParameters(zoom), 0));
}