/*
* Copyright 2006 Sony Computer Entertainment Inc.
*
* Licensed under the MIT Open Source License, for details please see license.txt or the website
* http://www.opensource.org/licenses/mit-license.php
*
*/
#include <list>
#include <vector>
#include <sstream>
#include <algorithm>
#include <dae/daeSIDResolver.h>
#include <dae/daeIDRef.h>
#include <dae/daeAtomicType.h>
#include <dae/daeMetaAttribute.h>
#include <dae/daeMetaElement.h>
#include <dae/daeURI.h>
#include <dom/domTypes.h>
#include <dom/domConstants.h>
#include <dae/daeDocument.h>
#include <dae/daeDatabase.h>
#include <dae/daeUtils.h>
#include <dom/domSource.h>
using namespace std;
namespace {
template<typename T>
T nextIter(const T& iter) {
T next = iter;
return ++next;
}
template<typename T>
T moveIter(const T& iter, int n) {
T result = iter;
advance(result, n);
return result;
}
// Implements a breadth-first sid search by starting at the container element and
// traversing downward through the element tree.
daeElement* findSidTopDown(daeElement* container, const string& sid, const string& profile) {
if (!container)
return NULL;
vector<daeElement*> elts, matchingElts;
elts.push_back(container);
for (size_t i = 0; i < elts.size(); i++) {
daeElement* elt = elts[i];
// Bail if we're looking for an element in a different profile
if (!profile.empty()) {
if (strcmp(elt->getElementName(), COLLADA_ELEMENT_TECHNIQUE_COMMON) == 0)
continue;
if (strcmp(elt->getElementName(), COLLADA_ELEMENT_TECHNIQUE) == 0 &&
profile != elt->getAttribute("profile"))
continue;
}
// See if this is a matching element
if (elt->getAttribute("sid") == sid)
return elt;
else {
// Add the children to the list of elements to check
daeElementRefArray children;
elt->getChildren(children);
for (size_t j = 0; j < children.getCount(); j++)
elts.push_back(children[j]);
}
}
return NULL;
}
// Returns the distance between an element and an ancestor of the element. If 'container
// isn't an ancestor of 'elt', or if 'elt' is in a profile that doesn't match 'profile'
// UINT_MAX is returned.
unsigned int computeDistance(daeElement* container, daeElement* elt, const string& profile) {
if (!container || !elt)
return UINT_MAX;
unsigned int distance = 0;
do {
// Bail if we're looking for an element in a different profile
if (!profile.empty()) {
if (strcmp(elt->getElementName(), COLLADA_ELEMENT_TECHNIQUE_COMMON) == 0)
return UINT_MAX;
if (strcmp(elt->getElementName(), COLLADA_ELEMENT_TECHNIQUE) == 0 &&
profile != elt->getAttribute("profile"))
return UINT_MAX;
}
if (elt == container)
return distance;
distance++;
} while ((elt = elt->getParentElement()) != NULL);
return UINT_MAX;
}
// Implements a breadth-first sid search by using the database to find all elements
// matching 'sid', then finding the element closest to 'container'.
daeElement* findSidBottomUp(daeElement* container, const string& sid, const string& profile) {
if (!container || !container->getDocument())
return NULL;
// Get the elements with a matching sid
vector<daeElement*> elts;
container->getDocument()->getDAE()->getDatabase()->sidLookup(sid, elts, container->getDocument());
// Compute the distance from each matching element to the container element
unsigned int minDistance = UINT_MAX;
daeElement* closestElt = NULL;
for (size_t i = 0; i < elts.size(); i++) {
unsigned int distance = computeDistance(container, elts[i], profile);
if (distance < minDistance) {
minDistance = distance;
closestElt = elts[i];
}
}
return closestElt;
}
daeElement* findID(daeElement* elt, const string& id, const string& profile) {
return elt ? elt->getDAE()->getDatabase()->idLookup(id, elt->getDocument()) : NULL;
}
void buildString(const list<string>::iterator& begin,
const list<string>::iterator& end,
string& result) {
ostringstream stream;
for (list<string>::iterator iter = begin; iter != end; iter++)
stream << *iter;
result = stream.str();
}
// Finds an element with a matching ID or sid (depending on the 'finder' function)
// passed in. First it tries to resolve the whole ID/sid, then it tries to resolve
// successively smaller parts. For example, consider this sid ref: "my.sid.ref".
// First this function will try to resolve "my.sid.ref" entirely, then if that
// fails it'll try to resolve "my.sid.", "my.sid", "my.", and "my", in that order.
// The part that wasn't matched is returned in the 'remainingPart' parameter.
daeElement* findWithDots(daeElement* container,
const string& s,
const string& profile,
daeElement* (*finder)(daeElement*, const string&, const string&),
list<string>& remainingPart) {
remainingPart.clear();
// First see if the whole thing resolves correctly
if (daeElement* result = finder(container, s, profile))
return result;
// It didn't resolve. Let's tokenize it by '.'s and see if we can resolve a
// portion of it.
cdom::tokenize(s, ".", remainingPart, true);
if (remainingPart.size() == 1)
return NULL; // There were no '.'s, so the result won't be any different
list<string>::iterator iter = moveIter(remainingPart.end(), -1);
for (int i = int(remainingPart.size())-1; i >= 1; i--, iter--) {
string substr;
buildString(remainingPart.begin(), iter, substr);
if (daeElement* result = finder(container, substr, profile)) {
// Remove the part we matched against from the list
remainingPart.erase(remainingPart.begin(), iter);
return result;
}
}
remainingPart.clear();
return NULL;
}
daeSidRef::resolveData resolveImpl(const daeSidRef& sidRef) {
if (sidRef.sidRef.empty() || !sidRef.refElt)
return daeSidRef::resolveData();
daeSidRef::resolveData result;
string separators = "/()";
list<string> tokens;
cdom::tokenize(sidRef.sidRef, separators, /* out */ tokens, true);
list<string>::iterator tok = tokens.begin();
// The first token should be either an ID or a '.' to indicate
// that we should start the search from the container element.
if (tok == tokens.end())
return daeSidRef::resolveData();
list<string> remainingPart;
if (*tok == ".") {
result.elt = sidRef.refElt;
tok++;
} else {
// Try to resolve it as an ID
result.elt = findWithDots(sidRef.refElt, *tok, sidRef.profile, findID, remainingPart);
if (result.elt) {
if (!remainingPart.empty()) {
// Insert the "remaining part" from the ID resolve into our list of tokens
tokens.erase(tokens.begin());
tokens.splice(tokens.begin(), remainingPart);
tok = tokens.begin();
} else
tok++;
}
}
if (!result.elt)
return daeSidRef::resolveData();
// Next we have an optional list of SIDs, each one separated by "/". Once we hit one of "()",
// we know we're done with the SID section.
for (; tok != tokens.end() && *tok == "/"; tok++) {
tok++; // Read the '/'
if (tok == tokens.end())
return daeSidRef::resolveData();
// Find the element matching the SID
result.elt = findWithDots(result.elt, *tok, sidRef.profile, findSidTopDown, remainingPart);
if (!result.elt)
return daeSidRef::resolveData();
if (!remainingPart.empty()) {
list<string>::iterator tmp = tok;
tok--;
tokens.splice(tmp, remainingPart);
tokens.erase(tmp);
}
}
// Now we want to parse the member selection tokens. It can either be
// (a) '.' followed by a string representing the member to access
// (b) '(x)' where x is a number, optionally followed by another '(x)'
// Anything else is an error.
string member;
bool haveArrayIndex1 = false, haveArrayIndex2 = false;
int arrayIndex1 = -1, arrayIndex2 = -1;
if (tok != tokens.end()) {
if (*tok == ".") {
tok++;
if (tok == tokens.end())
return daeSidRef::resolveData();
member = *tok;
tok++;
}
else if (*tok == "(") {
tok++;
if (tok == tokens.end())
return daeSidRef::resolveData();
istringstream stream(*tok);
stream >> arrayIndex1;
haveArrayIndex1 = true;
if (!stream.good() && !stream.eof())
return daeSidRef::resolveData();
tok++;
if (tok == tokens.end() || *tok != ")")
return daeSidRef::resolveData();
tok++;
if (tok != tokens.end() && *tok == "(") {
tok++;
if (tok == tokens.end())
return daeSidRef::resolveData();
stream.clear();
stream.str(*tok);
stream >> arrayIndex2;
haveArrayIndex2 = true;
if (!stream.good() && !stream.eof())
return daeSidRef::resolveData();
tok++;
if (tok == tokens.end() || *tok != ")")
return daeSidRef::resolveData();
tok++;
}
}
}
// We shouldn't have any tokens left. If we do it's an error.
if (tok != tokens.end())
return daeSidRef::resolveData();
// At this point we've parsed a correctly formatted SID reference. The only thing left is to resolve
// the member selection portion of the SID ref. First, see if the resolved element has a float array we
// can use.
if (result.elt->typeID() == domSource::ID()) {
if (domFloat_array* floatArray = ((domSource*)result.elt)->getFloat_array())
result.array = (daeDoubleArray*)floatArray->getCharDataObject()->get(floatArray);
}
else
{
daeMetaAttribute *ma = result.elt->getCharDataObject();
if ( ma != NULL ) {
if ( ma->isArrayAttribute() && ma->getType()->getTypeEnum() == daeAtomicType::DoubleType ) {
result.array = (daeDoubleArray*)ma->get( result.elt );
}
}
}
if( result.array ) {
// We have an array to use for indexing. Let's see if the SID ref uses member selection.
if (!member.empty()) {
// Do member lookup based on the constants defined in the COMMON profile
if (member == "ANGLE") {
result.scalar = &(result.array->get(3));
} else if (member.length() == 1) {
switch(member[0]) {
case 'X':
case 'R':
case 'U':
case 'S':
result.scalar = &(result.array->get(0));
break;
case 'Y':
case 'G':
case 'V':
case 'T':
result.scalar = &(result.array->get(1));
break;
case 'Z':
case 'B':
case 'P':
result.scalar = &(result.array->get(2));
break;
case 'W':
case 'A':
case 'Q':
result.scalar = &(result.array->get(3));
break;
};
}
} else if (haveArrayIndex1) {
// Use the indices to lookup a value in the array
if (haveArrayIndex2 && result.array->getCount() == 16) {
// We're doing a matrix lookup. Make sure the index is valid.
int i = arrayIndex1*4 + arrayIndex2;
if (i >= 0 && i < int(result.array->getCount()))
result.scalar = &(result.array->get(i));
} else {
// Vector lookup. Make sure the index is valid.
if (arrayIndex1 >= 0 && arrayIndex1 < int(result.array->getCount()))
result.scalar = &(result.array->get(arrayIndex1));
}
}
}
// If we tried to do member selection but we couldn't resolve it to a doublePtr, fail.
if ((!member.empty() || haveArrayIndex1) && result.scalar == NULL)
return daeSidRef::resolveData();
// SID resolution was successful.
return result;
}
} // namespace {
daeSidRef::resolveData::resolveData() : elt(NULL), array(NULL), scalar(NULL) { }
daeSidRef::resolveData::resolveData(daeElement* elt, daeDoubleArray* array, daeDouble* scalar)
: elt(elt),
array(array),
scalar(scalar) { }
daeSidRef::daeSidRef() : refElt(NULL) { }
daeSidRef::daeSidRef(const string& sidRef, daeElement* referenceElt, const string& profile)
: sidRef(sidRef),
refElt(referenceElt),
profile(profile) { }
bool daeSidRef::operator<(const daeSidRef& other) const {
if (refElt != other.refElt)
return refElt < other.refElt;
if (sidRef != other.sidRef)
return sidRef < other.sidRef;
return profile < other.profile;
}
daeSidRef::resolveData daeSidRef::resolve() {
if (!refElt)
return daeSidRef::resolveData();
// First check the cache
daeSidRef::resolveData result = refElt->getDAE()->getSidRefCache().lookup(*this);
if (result.elt)
return result;
// Try to resolve as an effect-style sid ref by prepending "./" to the sid ref.
// If that fails, try resolving as an animation-style sid ref, where the first part is an ID.
result = resolveImpl(daeSidRef(string("./") + sidRef, refElt, profile));
if (!result.elt)
result = resolveImpl(*this);
if (result.elt) // Add the result to the cache
refElt->getDAE()->getSidRefCache().add(*this, result);
return result;
}
daeSIDResolver::daeSIDResolver( daeElement *container, daeString target, daeString profile )
: container(NULL)
{
setContainer(container);
setTarget(target);
setProfile(profile);
}
daeString daeSIDResolver::getTarget() const {
return target.empty() ? NULL : target.c_str();
}
void daeSIDResolver::setTarget( daeString t )
{
target = t ? t : "";
}
daeString daeSIDResolver::getProfile() const {
return profile.empty() ? NULL : profile.c_str();
}
void daeSIDResolver::setProfile( daeString p )
{
profile = p ? p : "";
}
daeElement* daeSIDResolver::getContainer() const {
return container;
}
void daeSIDResolver::setContainer(daeElement* element)
{
container = element;
}
daeSIDResolver::ResolveState daeSIDResolver::getState() const {
if (target.empty())
return target_empty;
daeSidRef::resolveData result = daeSidRef(target, container, profile).resolve();
if (!result.elt)
return sid_failed_not_found;
if (result.scalar)
return sid_success_double;
if (result.array)
return sid_success_array;
return sid_success_element;
}
daeElement* daeSIDResolver::getElement()
{
return daeSidRef(target, container, profile).resolve().elt;
}
daeDoubleArray *daeSIDResolver::getDoubleArray()
{
return daeSidRef(target, container, profile).resolve().array;
}
daeDouble *daeSIDResolver::getDouble()
{
return daeSidRef(target, container, profile).resolve().scalar;
}
daeSidRefCache::daeSidRefCache() : hitCount(0), missCount(0) { }
daeSidRef::resolveData daeSidRefCache::lookup(const daeSidRef& sidRef) {
map<daeSidRef, daeSidRef::resolveData>::iterator iter = lookupTable.find(sidRef);
if (iter != lookupTable.end()) {
hitCount++;
return iter->second;
}
missCount++;
return daeSidRef::resolveData();
}
void daeSidRefCache::add(const daeSidRef& sidRef, const daeSidRef::resolveData& result) {
lookupTable[sidRef] = result;
}
void daeSidRefCache::clear() {
lookupTable.clear();
hitCount = missCount = 0;
}
bool daeSidRefCache::empty() {
return lookupTable.empty();
}
int daeSidRefCache::misses() {
return missCount;
}
int daeSidRefCache::hits() {
return hitCount;
}