void Message::annotationsChanged()
{
if (persistentContext) {
uint64_t id = persistentContext->getPersistenceId();
persistentContext = persistentContext->merge(getAnnotations());
persistentContext->setIngressCompletion(sharedState);
persistentContext->setPersistenceId(id);
}
}
qpid::types::Variant Message::getAnnotation(const std::string& key) const
{
const qpid::types::Variant::Map& a = getAnnotations();
qpid::types::Variant::Map::const_iterator i = a.find(key);
if (i != a.end()) return i->second;
//FIXME: modify Encoding interface to allow retrieval of
//annotations of different types from the message data as received
//off the wire
return qpid::types::Variant(getEncoding().getAnnotationAsString(key));
}
JavaObjectMethod* JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
JavaObjectMethod* ret = 0;
JavaString* str = 0;
JavaObject* pArr = 0;
JavaObject* eArr = 0;
JavaObject* retTy = 0;
ArraySInt8* ann = 0;
ArraySInt8* pmAnn = 0;
ArraySInt8* defAnn = 0;
llvm_gcroot(ret, 0);
llvm_gcroot(str, 0);
llvm_gcroot(pArr, 0);
llvm_gcroot(eArr, 0);
llvm_gcroot(retTy, 0);
llvm_gcroot(ann, 0);
llvm_gcroot(pmAnn, 0);
llvm_gcroot(defAnn, 0);
// TODO: check parameter types
Jnjvm* vm = JavaThread::get()->getJVM();
JnjvmClassLoader * classLoader = meth->classDef->classLoader;
UserClass* Meth = vm->upcalls->newMethod;
ret = (JavaObjectMethod*)Meth->doNew(vm);
str = vm->internalUTF8ToStr(meth->name);
pArr = meth->getParameterTypes(classLoader);
eArr = meth->getExceptionTypes(classLoader);
retTy = meth->getReturnType(classLoader);
JavaString ** sig = getSignature(meth);
ann = getAnnotations(meth);
pmAnn = getParamAnnotations(meth);
defAnn = getAnnotationDefault(meth);
JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
Cl, /* declaring class */
&str, /* name */
&pArr, /* parameter types */
&retTy, /* return type */
&eArr, /* exceptions */
meth->access, /* modifiers */
i, /* slot */
sig, /* signature */
&ann, /* annotations */
&pmAnn, /* parameter annotations */
&defAnn); /* default annotations */
return ret;
}
JavaObjectField* JavaObjectField::createFromInternalField(JavaField* field, int i) {
JavaObjectField* ret = 0;
JavaString* name = 0;
ArraySInt8* ann = 0;
llvm_gcroot(ret, 0);
llvm_gcroot(name, 0);
llvm_gcroot(ann, 0);
// TODO: check parameter types
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* Field = vm->upcalls->newField;
ret = (JavaObjectField*)Field->doNew(vm);
name = vm->internalUTF8ToStr(field->name);
//type->Class
JnjvmClassLoader* loader = field->classDef->classLoader;
UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
assert(fieldCl);
JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
JavaString** sig = getSignature(field);
ann = getAnnotations(field);
/* java.reflect.Field(
* Class declaringClass,
* String name,
* Class type,
* int modifiers,
* int slot,
* String signature,
* byte[] annotations)
*/
vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
Cl,
&name,
type,
field->access,
i,
sig,
&ann);
return ret;
}
JavaObjectConstructor* JavaObjectConstructor::createFromInternalConstructor(JavaMethod * cons, int i) {
JavaObjectConstructor* ret = 0;
JavaObject* pArr = 0;
JavaObject* eArr = 0;
ArraySInt8* ann = 0;
ArraySInt8* pmAnn = 0;
llvm_gcroot(ret, 0);
llvm_gcroot(pArr, 0);
llvm_gcroot(eArr, 0);
llvm_gcroot(ann, 0);
llvm_gcroot(pmAnn, 0);
Jnjvm* vm = JavaThread::get()->getJVM();
JnjvmClassLoader * classLoader = cons->classDef->classLoader;
UserClass* Cons = vm->upcalls->newConstructor;
pArr = cons->getParameterTypes(classLoader);
eArr = cons->getExceptionTypes(classLoader);
ret = (JavaObjectConstructor*)Cons->doNew(vm);
JavaObject* const* Cl = cons->classDef->getDelegateePtr();
JavaString ** sig = getSignature(cons);
ann = getAnnotations(cons);
pmAnn = getParamAnnotations(cons);
vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
Cl, /* declaringClass */
&pArr, /* parameterTypes */
&eArr, /* checkedExceptions */
cons->access, /* modifiers */
i, /* slot */
sig, /* String signature */
&ann, /* annotations */
&pmAnn /* parameterAnnotations */
);
return ret;
}
void Task::substitute (
const std::string& from,
const std::string& to,
bool global)
{
// Get the data to modify.
std::string description = get ("description");
std::map <std::string, std::string> annotations;
getAnnotations (annotations);
bool sensitive = context.config.getBoolean ("search.case.sensitive");
// Count the changes, so we know whether to proceed to annotations, after
// modifying description.
int changes = 0;
bool done = false;
// Regex support is optional.
if (context.config.getBoolean ("regex"))
{
// Create the regex.
RX rx (from, sensitive);
std::vector <int> start;
std::vector <int> end;
// Perform all subs on description.
if (rx.match (start, end, description))
{
int skew = 0;
for (unsigned int i = 0; i < start.size () && !done; ++i)
{
description.replace (start[i + skew], end[i] - start[i], to);
skew += to.length () - (end[i] - start[i]);
++changes;
if (!global)
done = true;
}
}
if (!done)
{
// Perform all subs on annotations.
std::map <std::string, std::string>::iterator it;
for (it = annotations.begin (); it != annotations.end () && !done; ++it)
{
start.clear ();
end.clear ();
if (rx.match (start, end, it->second))
{
int skew = 0;
for (unsigned int i = 0; i < start.size () && !done; ++i)
{
it->second.replace (start[i + skew], end[i] - start[i], to);
skew += to.length () - (end[i] - start[i]);
++changes;
if (!global)
done = true;
}
}
}
}
}
else
{
// Perform all subs on description.
int counter = 0;
std::string::size_type pos = 0;
int skew = 0;
while ((pos = ::find (description, from, pos, sensitive)) != std::string::npos && !done)
{
description.replace (pos + skew, from.length (), to);
skew += to.length () - from.length ();
pos += to.length ();
++changes;
if (!global)
done = true;
if (++counter > APPROACHING_INFINITY)
throw format (STRING_INFINITE_LOOP, APPROACHING_INFINITY);
}
if (!done)
{
// Perform all subs on annotations.
counter = 0;
std::map <std::string, std::string>::iterator i;
for (i = annotations.begin (); i != annotations.end () && !done; ++i)
{
pos = 0;
skew = 0;
while ((pos = ::find (i->second, from, pos, sensitive)) != std::string::npos && !done)
{
i->second.replace (pos + skew, from.length (), to);
skew += to.length () - from.length ();
pos += to.length ();
++changes;
if (!global)
done = true;
if (++counter > APPROACHING_INFINITY)
throw format (STRING_INFINITE_LOOP, APPROACHING_INFINITY);
}
}
}
}
if (changes)
{
set ("description", description);
setAnnotations (annotations);
recalc_urgency = true;
}
}
