string
Slice::ObjCGenerator::getParamName(const ContainedPtr& param, bool internal)
{
if(internal)
{
return "iceP_" + param->name();
}
else
{
return fixId(param->name());
}
}
string
Slice::Ruby::getAbsolute(const ContainedPtr& cont, IdentStyle style, const string& prefix)
{
string scope = fixIdent(cont->scope(), IdentToUpper);
if(prefix.empty())
{
return scope + fixIdent(cont->name(), style);
}
else
{
return scope + prefix + fixIdent(cont->name(), style);
}
}
string
Slice::ObjCGenerator::getFactoryMethod(const ContainedPtr& p, bool deprecated)
{
ClassDefPtr def = ClassDefPtr::dynamicCast(p);
if(def && def->declaration()->isLocal())
{
deprecated = false; // Local classes don't have this issue since they were added after this fix.
}
//
// If deprecated is true, we return uDPConnectionInfo for a class
// named UDPConnectionInfo, return udpConnectionInfo otherwise.
//
string name = fixId(p->name());
if(name.empty())
{
return name;
}
else if(deprecated || name.size() < 2 || !isupper(*(name.begin() + 1)))
{
*name.begin() = tolower(*name.begin());
}
else
{
for(string::iterator p = name.begin(); p != name.end() && isalpha(*p); ++p)
{
if(p != name.end() - 1 && isalpha(*(p + 1)) && !isupper(*(p + 1)))
{
break;
}
*p = tolower(*p);
}
}
return name;
}
string
CodeVisitor::getName(const ContainedPtr& p, const string& suffix)
{
if(_ns)
{
return fixIdent(p->name() + suffix);
}
else
{
return getAbsolute(p, false, "", suffix);
}
}
string
Slice::ObjCGenerator::getParamId(const ContainedPtr& param)
{
string n;
if(ParamDeclPtr::dynamicCast(param) && param->findMetaData("objc:param:", n))
{
return lookupParamIdKwd(n.substr(11));
}
else
{
return lookupParamIdKwd(param->name());
}
}
void
Slice::ObjCGenerator::writeMarshalUnmarshalCode(Output &out, const TypePtr& type, const string& param,
bool marshal, bool autoreleased) const
{
string stream = marshal ? "os_" : "is_";
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
string name;
if(builtin->kind() == Builtin::KindObject)
{
if(marshal)
{
out << nl << "[" << stream << " writeObject:" << param << "];";
}
else
{
if(autoreleased)
{
out << nl << "[" << stream << " readObject:&" << param << "];";
}
else
{
out << nl << "[" << stream << " newObject:&" << param << "];";
}
}
}
else if(builtin->kind() == Builtin::KindObjectProxy)
{
if(marshal)
{
out << nl << "[" << stream << " writeProxy:" << param << "];";
}
else
{
if(autoreleased)
{
out << nl << param << " = [" << stream << " readProxy:[ICEObjectPrx class]];";
}
else
{
out << nl << param << " = [" << stream << " newProxy:[ICEObjectPrx class]];";
}
}
}
else
{
if(marshal)
{
out << nl << "[" << stream << " write" << getBuiltinName(builtin) << ":" << param << "];";
}
else
{
if(autoreleased || isValueType(builtin))
{
out << nl << param << " = [" << stream << " read" << getBuiltinName(builtin) << "];";
}
else
{
out << nl << param << " = [" << stream << " new" << getBuiltinName(builtin) << "];";
}
}
}
return;
}
ProxyPtr prx = ProxyPtr::dynamicCast(type);
if(prx)
{
if(marshal)
{
out << nl << "[" << stream << " writeProxy:(id<ICEObjectPrx>)" << param << "];";
}
else
{
string name = moduleName(findModule(prx->_class())) + prx->_class()->name() + "Prx";
out << nl << param << " = (id<" << name << ">)[" << stream;
if(autoreleased)
{
out << " readProxy:";
}
else
{
out << " newProxy:";
}
//
// We use objc_getClass to get the proxy class instead of [name class]. This is to avoid
// a warning if the proxy is forward declared.
//
if(prx->_class()->definition())
{
out << "[" << name << " class]];";
}
else
{
out << "objc_getClass(\"" << name << "\")];";
}
}
return;
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
if(marshal)
{
// Cast avoids warning for forward-declared classes.
out << nl << "[" << stream << " writeObject:(ICEObject*)" << param << "];";
}
else
{
if(autoreleased)
{
out << nl << "[" << stream << " " << "readObject:(ICEObject**)&" << param;
}
else
{
out << nl << "[" << stream << " " << "newObject:(ICEObject**)&" << param;
}
if(cl->isInterface())
{
out << "];";
}
else
{
string name = moduleName(findModule(cl)) + cl->name();
if(cl->definition())
{
out << " expectedType:[" << name << " class]];";
}
else
{
out << " expectedType:objc_getClass(\"" << name << "\")];";
}
}
}
return;
}
EnumPtr en = EnumPtr::dynamicCast(type);
if(en)
{
if(marshal)
{
out << nl << "[" << stream << " writeEnumerator:" << param << " min:" << en->minValue()
<< " max:" << en->maxValue() << "];";
}
else
{
out << nl << param << " = " << "[" << stream << " readEnumerator:" << en->minValue()
<< " max:" << en->maxValue() << "];";
}
return;
}
ContainedPtr c = ContainedPtr::dynamicCast(type);
assert(c);
string name = moduleName(findModule(c)) + c->name() + "Helper";
if(marshal)
{
out << nl << "[" + name << " write:" << param << " stream:" << stream << "];";
}
else
{
if(StructPtr::dynamicCast(type))
{
if(autoreleased)
{
out << nl << param << " = [" << name << " read:" << stream << " value:" << param << "];";
}
else
{
out << nl << param << " = [" << name << " readRetained:" << stream << " value:" << param << "];";
}
}
else
{
if(autoreleased)
{
out << nl << param << " = [" << name << " read:" << stream << "];";
}
else
{
out << nl << param << " = [" << name << " readRetained:" << stream << "];";
}
}
}
}
string
Slice::ObjCGenerator::fixName(const ContainedPtr& cont, int baseTypes, bool mangleCasts)
{
return moduleName(findModule(cont, baseTypes, mangleCasts)) + cont->name();
}
string
Slice::ObjCGenerator::fixId(const ContainedPtr& cont, int baseTypes, bool mangleCasts)
{
return fixId(cont->name(), baseTypes, mangleCasts);
}
string
Slice::JsGenerator::fixId(const ContainedPtr& cont, bool mangleCasts)
{
return fixId(cont->name(), mangleCasts);
}
string
Slice::JsGenerator::fixId(const ContainedPtr& cont)
{
return fixId(cont->name());
}
string
Slice::PHP::getAbsolute(const ContainedPtr& cont, bool ns, const string& prefix, const string& suffix)
{
return scopedToName(cont->scope() + prefix + cont->name() + suffix, ns);
}
