C++ ZTuple::GetString方法代码示例

static ZRef<ZTBQueryNode> sNodeFromTuple(const ZTuple& iTuple)
	{
	string nodeKind = iTuple.GetString("Kind");
	if (false)
		{}
	else if (nodeKind == "All")
		{
		return new ZTBQueryNode_All;
		}
	else if (nodeKind == "Combo")
		{
		vector<ZTBQuery::SortSpec> theSort;
		const vector<ZTupleValue>& vectorSort = iTuple.GetVector("Sort");
		for (vector<ZTupleValue>::const_iterator i = vectorSort.begin(); i != vectorSort.end(); ++i)
			{
			const ZTuple& temp = (*i).GetTuple();
			theSort.push_back(ZTBQuery::SortSpec(
				temp.GetString("PropName"), temp.GetBool("Ascending"), temp.GetInt32("Strength")));
			}

		const vector<ZTupleValue>& sourceSect = iTuple.GetVector("Intersections");
		vector<ZTBQueryNode_Combo::Intersection> theIntersections;
		for (vector<ZTupleValue>::const_iterator i = sourceSect.begin(); i != sourceSect.end(); ++i)
			theIntersections.push_back(ZTBQueryNode_Combo::Intersection((*i).GetTuple()));

		return new ZTBQueryNode_Combo(theSort, theIntersections);
		}
	else if (nodeKind == "Difference")
		{
		ZRef<ZTBQueryNode> leftNode = sNodeFromTuple(iTuple.GetTuple("LeftNode"));
		ZRef<ZTBQueryNode> rightNode = sNodeFromTuple(iTuple.GetTuple("RightNode"));
		return new ZTBQueryNode_Difference(leftNode, rightNode);
		}
	else if (nodeKind == "First")
		{
		string propName = iTuple.GetString("PropName");
		ZRef<ZTBQueryNode> sourceNode = sNodeFromTuple(iTuple.GetTuple("SourceNode"));
		return new ZTBQueryNode_First(propName, sourceNode);
		}
	else if (nodeKind == "ID_Constant")
		{
		vector<uint64> theIDs;
		iTuple.GetVector_T("IDs", back_inserter(theIDs), uint64());
		return new ZTBQueryNode_ID_Constant(theIDs, true);
		}
	else if (nodeKind == "ID_FromSource")
		{
		ZRef<ZTBQueryNode> sourceNode = sNodeFromTuple(iTuple.GetTuple("SourceNode"));
		string sourcePropName = iTuple.GetString("SourcePropName");
		return new ZTBQueryNode_ID_FromSource(sourceNode, sourcePropName);
		}
	else if (nodeKind == "Property")
		{
		string propName = iTuple.GetString("PropName");
		ZRef<ZTBQueryNode> sourceNode = sNodeFromTuple(iTuple.GetTuple("SourceNode"));
		return new ZTBQueryNode_Property(propName, sourceNode);
		}
	throw runtime_error(string("ZTBQuery, sNodeFromTuple, unknown nodeKind: " + nodeKind));
	}

bool ZUITextEngine::MenuMessage(const ZMessage& inMessage)
	{
	switch (inMessage.GetInt32("menuCommand"))
		{
		case mcCopy:
		case mcCut:
			{
			size_t selectStart, selectLength;
			this->GetSelection(selectStart, selectLength);
			if (selectLength != 0)
				{
				if (inMessage.GetInt32("menuCommand") == mcCopy || this->IsRangeEditable(selectStart, selectLength))
					{
					ZTuple theTuple = this->GetTuple(selectStart, selectLength);
					ZClipboard::sSet(theTuple);
					if (inMessage.GetInt32("menuCommand") == mcCut)
						this->DeleteText(selectStart, selectLength);
					}
				}
			return true;
			break;
			}
		case mcClear:
			{
			size_t selectStart, selectLength;
			this->GetSelection(selectStart, selectLength);
			if (selectLength != 0 && this->IsRangeEditable(selectStart, selectLength))
				{
				this->DeleteText(selectStart, selectLength);
				return true;
				}
			return true;
			break;
			}
		case mcPaste:
			{
			size_t selectStart, selectLength;
			this->GetSelection(selectStart, selectLength);
			if (this->IsRangeEditable(selectStart, selectLength))
				{
				ZTuple theTuple = ZClipboard::sGet();
				if (theTuple.Has("text/plain"))
					{
					this->ReplaceSelection(theTuple.GetString("text/plain"));
					return true;
					}
				}
			return true;
			break;
			}
		case mcSelectAll:
			{
			this->SetSelection(0, this->GetTextLength());
			return true;
			}
		}
	return false;
	}

static bool sGetStringAt(const ZTuple& iTuple, const string& iName, string& oString)
	{
	if (iTuple.GetString(iName, oString))
		return true;

	const vector<ZTupleValue>& theVector = iTuple.GetVector(iName);
	if (!theVector.empty())
		return theVector[0].GetString(oString);

	return false;
	}

void ZUITextEngine::HandleDrop(ZPoint inPoint, ZDrop& inDrop)
	{
	if (!this->AcceptsDragDrop(inDrop))
		return;
	if (inDrop.GetDragSource() == this)
		{
		size_t dragOffset = this->PointToOffset(this->FromHost(inPoint));
		size_t selectStart, selectLength;
		this->GetSelection(selectStart, selectLength);

		if (dragOffset < selectStart)
			{
			string selectedText = this->GetText(selectStart, selectLength);
			this->DeleteText(selectStart, selectLength);
			this->InsertText(dragOffset, selectedText);
			this->SetSelection(dragOffset, selectLength);
			}
		else if (dragOffset > selectStart+selectLength)
			{
			string selectedText = this->GetText(selectStart, selectLength);
			this->DeleteText(selectStart, selectLength);
			this->InsertText(dragOffset-selectLength, selectedText);
			this->SetSelection(dragOffset-selectLength, selectLength);
			}				
		}
	else
		{
		size_t dragOffset = this->PointToOffset(inPoint);
		if (!this->IsRangeEditable(dragOffset, 0))
			return;
		for (size_t currentTupleIndex = 0; currentTupleIndex < inDrop.CountTuples(); ++currentTupleIndex)
			{
			ZTuple currentTuple = inDrop.GetTuple(currentTupleIndex);
			if (currentTuple.Has("text/plain"))
				{
				string droppedString = currentTuple.GetString("text/plain");
				this->InsertText(dragOffset, droppedString);
				this->SetSelection(dragOffset, droppedString.size());
				// Return now, so we only drop text from the first tuple that had any
				return;
				}
			}
		}
	}

bool ZTBSpec::Criterion::Matches(const ZTuple& iTuple) const
	{
	ZTuple::const_iterator propIter = iTuple.IteratorOf(this->GetPropName());
	if (propIter == iTuple.end())
		{
		// iTuple does not have a property named fPropName. For
		// 'Lacks' and 'LacksOfType' relationships that means
		// we match iTuple, for all other relationships we don't.
		return this->GetComparator().fRel == eRel_Lacks
			|| this->GetComparator().fRel == eRel_LacksOfType;
		}

	switch (this->GetComparator().fRel)
		{
		case eRel_Has:
			{
			return true;
			}
		case eRel_HasOfType:
			{
			return iTuple.TypeOf(propIter) == this->GetTupleValue().GetType();
			}
		case eRel_Lacks:
			{
			// iTuple has a property named fPropName,
			// so it doesn't lack a property named fPropName.
			return false;
			}
		case eRel_LacksOfType:
			{
			return iTuple.TypeOf(propIter) != this->GetTupleValue().GetType();			
			}
		case eRel_VectorContains:
			{
			if (iTuple.TypeOf(propIter) != eZType_Vector)
				return false;

			const vector<ZTupleValue>& theVector = iTuple.GetVector(propIter);
			for (vector<ZTupleValue>::const_iterator i = theVector.begin();
				i != theVector.end(); ++i)
				{
				if (*i == this->GetTupleValue())
					return true;
#if 0 //##
				if ((*i).TypeOf() == this->GetTupleValue().TypeOf())
					{
					if ((*i).UncheckedEqual(this->GetTupleValue()))
						return true;
					}
#endif
				}
			return false;			
			}
		case eRel_StringContains:
			{
			string pattern;
			if (!this->GetTupleValue().GetString(pattern) || pattern.empty())
				return true;

			string target;
			if (!iTuple.GetString(propIter, target) || target.empty())
				return false;

			if (!fRep->fTextCollator)
				{
				fRep->fTextCollator =
					ZTextCollator(this->GetComparator().fStrength);
				}

			return fRep->fTextCollator.Contains(pattern, target);
			}
		case eRel_Regex:
			{
			#if ZCONFIG_API_Enabled(Regex)
				string target;
				if (!iTuple.GetString(propIter, target) || target.empty())
					return false;

				if (!fRep->fRegex)
					{
					fRep->fRegex =
						ZRegex(this->GetTupleValue().GetString(), this->GetComparator().fStrength);
					}

				if (!fRep->fRegex)
					return false;

				return fRep->fRegex.Matches(target);
			#else
				return false;
			#endif
			}
		default:
			{
			const ZTupleValue& leftValue = iTuple.GetValue(propIter);
			ZType leftType = leftValue.TypeOf();
			ZType rightType = this->GetTupleValue().TypeOf();
			if (this->GetComparator().fRel == eRel_Equal)
				{
				if (leftType != rightType)
//.........这里部分代码省略.........

ZTBSpec::Criterion::Rep::Rep(const ZTuple& iTuple)
:	fPropName(iTuple.GetString("PropName")),
	fComparator(sRelFromString(iTuple.GetString("Rel")), iTuple.GetInt32("Strength")),
	fTupleValue(iTuple.GetValue("Value"))
	{}