void ZTS_Umbrella::pTranslate_LocalToGlobal(size_t iChildIndex, ZTuple& ioTuple)
{
for (ZTuple::const_iterator i = ioTuple.begin(), theEnd = ioTuple.end();
i != theEnd; ++i)
{
switch (ioTuple.TypeOf(i))
{
case eZType_ID:
{
uint64 globalID = this->pLocalToGlobal(iChildIndex, ioTuple.GetID(i));
ioTuple.SetID(i, globalID);
break;
}
case eZType_Tuple:
{
this->pTranslate_LocalToGlobal(iChildIndex, ioTuple.GetMutableTuple(i));
break;
}
case eZType_Vector:
{
vector<ZTupleValue>& theVector = ioTuple.GetMutableVector(i);
for (vector<ZTupleValue>::iterator j = theVector.begin(); j != theVector.end(); ++j)
{
if (eZType_ID == (*j).TypeOf())
{
uint64 globalID = this->pLocalToGlobal(iChildIndex, ioTuple.GetID(i));
(*j).SetID(globalID);
}
}
}
}
}
}
bool ZWebDAV::sHandle_PROPFIND(const ZTrail& iPrefix, ZNode iRoot, const ZStreamR& iStreamR, const ZStreamW& iStreamW, const ZTuple& iHeader, const ZTrail& iTrail, const ZTuple& iParam)
{
int depth = sGetDepth(iHeader);
ZRef<ZStrimmerR> theStrimmerR = sMakeStrimmer(iHeader, iStreamR);
const ZStrimR& theStrimR = theStrimmerR->GetStrimR();
ZHTTP::Response r;
r.Set("Date", sAsString_WebDAV(ZTime::sNow()));
ZNode theNode = iRoot.Trail(iTrail);
if (!theNode.Exists())
{
theStrimR.SkipAll();
r.Set("Content-Length", 0);
r.SetResult(404);
r.Send(iStreamW);
}
else
{
ZTuple t = sReadTuple(theStrimR);
ZTuple results;
if (t.Empty() || t.Has("D:allprop"))
{
sHandle_PROPFIND_All(iPrefix, iRoot, theNode, depth, results);
}
else
{
ZTuple propT = t.GetTuple("D:prop");
vector<string> thePropNames;
for (ZTuple::const_iterator i = propT.begin(); i != propT.end(); ++i)
thePropNames.push_back(propT.NameOf(i));
sHandle_PROPFIND_Some(iPrefix, iRoot, theNode, depth, thePropNames, results);
}
if (const ZLog::S& s = ZLog::S(ZLog::eDebug, "ZWebDAV"))
{
s << "PropFind Request:" << t << "\n";
s << "PropFind Results:" << results << "\n";
}
r.SetResult(207, "Multi-Status");
r.Set("Content-Type", "text/xml; charset=\"utf-8\"");
r.Set("Transfer-Encoding", "chunked");
r.Send(iStreamW);
ZHTTP::StreamW_Chunked chunkedStream(iStreamW);
ZStrimW_StreamUTF8 theStrimW(chunkedStream);
ZStrimW_ML s(false, theStrimW);
s.PI("xml");
s.Attr("version", "1.0");
s.Attr("encoding", "utf-8");
s.Begin("D:multistatus");
s.Attr("xmlns:D", "DAV:");
sWriteAsXML(s, results);
s.End("D:multistatus");
}
return true;
}
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)
{
return false;
}
else
{
if (leftType == eZType_String && this->GetComparator().fStrength != 0)
{
// We're doing string compares where the strength is non zero and
// so we need to use a collator to do the comparison.
if (!fRep->fTextCollator)
{
fRep->fTextCollator =
ZTextCollator(this->GetComparator().fStrength);
}
return fRep->fTextCollator.Equals(
leftValue.GetString(), this->GetTupleValue().GetString());
}
else
{
// The type matches, so do the appropriate comparison.
// return leftValue.pUncheckedEqual(this->GetTupleValue());
return leftValue == this->GetTupleValue();
}
}
}
else
{
int compare;
if (leftType != rightType)
{
compare = int(leftType) - int(rightType);
}
else
{
if (leftType == eZType_String && this->GetComparator().fStrength != 0)
{
// We're doing string compares where the strength is non zero and
// so we need to use a collator to do the comparison.
if (!fRep->fTextCollator)
{
fRep->fTextCollator =
ZTextCollator(this->GetComparator().fStrength);
}
compare = fRep->fTextCollator.Compare(
leftValue.GetString(), this->GetTupleValue().GetString());
}
else
{
// The type matches, so do the appropriate comparison.
// compare = leftValue.pUncheckedCompare(this->GetTupleValue());
compare = leftValue.Compare(this->GetTupleValue());
}
}
switch (this->GetComparator().fRel)
{
case eRel_Less: return compare < 0;
case eRel_LessEqual: return compare <= 0;
case eRel_GreaterEqual: return compare >= 0;
case eRel_Greater: return compare > 0;
}
}
}
}
// Can't get here.
ZUnimplemented();
return false;
}
static void sWriteAsXML(ZStrimW_ML& s, const ZTuple& iTuple)
{
for (ZTuple::const_iterator i = iTuple.begin(); i != iTuple.end(); ++i)
sWriteAsXML(s, iTuple.NameOf(i), iTuple.GetValue(i));
}
static void sToStrim_Tuple(const ZStrimW& s, const ZTuple& iTuple,
size_t iLevel, const ZUtil_Tuple::Options& iOptions, bool iMayNeedInitialLF)
{
if (iTuple.Empty())
{
// We've got an empty tuple.
s.Write("{}");
return;
}
const ZTuple::const_iterator theBegin = iTuple.begin();
const ZTuple::const_iterator theEnd = iTuple.end();
bool needsIndentation = false;
if (iOptions.DoIndentation())
{
for (ZTuple::const_iterator i = theBegin; i != theEnd; ++i)
{
if (sIsComplex(iOptions, iTuple.GetValue(i)))
{
needsIndentation = true;
break;
}
}
}
if (needsIndentation)
{
if (iMayNeedInitialLF)
{
// We're going to be indenting, but need to start
// a fresh line to have our { and contents line up.
sWriteLFIndent(s, iLevel, iOptions);
}
s.Write("{");
for (ZTuple::const_iterator i = theBegin; i != theEnd; ++i)
{
sWriteLFIndent(s, iLevel, iOptions);
ZUtil_Tuple::sWrite_PropName(s, iTuple.NameOf(i));
s << " = ";
sToStrim_TupleValue(s, iTuple.GetValue(i), iLevel + 1, iOptions, true);
s.Write(";");
}
sWriteLFIndent(s, iLevel, iOptions);
s.Write("}");
}
else
{
s.Write("{");
for (ZTuple::const_iterator i = theBegin; i != theEnd; ++i)
{
s.Write(" ");
ZUtil_Tuple::sWrite_PropName(s, iTuple.NameOf(i));
s << " = ";
sToStrim_TupleValue(s, iTuple.GetValue(i), iLevel + 1, iOptions, true);
s.Write(";");
}
s.Write(" }");
}
}
