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; } }