void Slice::ChecksumVisitor::visitDictionary(const DictionaryPtr& p)
{
if (p->isLocal()) {
return;
}
ostringstream ostr;
ostr << "dictionary<" << typeToString(p->keyType()) << ", " << typeToString(p->valueType())
<< "> " << p->name() << endl;
updateMap(p->scoped(), ostr.str());
}
string
Slice::ObjCGenerator::outTypeToString(const TypePtr& type, bool optional, bool autoreleasing, bool reference)
{
if(!type)
{
return "void";
}
string s;
if(optional)
{
s = "id";
}
else
{
SequencePtr seq = SequencePtr::dynamicCast(type);
DictionaryPtr d = DictionaryPtr::dynamicCast(type);
if(isString(type))
{
s = "NSMutableString";
}
else if(seq)
{
string prefix = moduleName(findModule(seq));
s = prefix + "Mutable" + seq->name();
}
else if(d)
{
string prefix = moduleName(findModule(d));
s = prefix + "Mutable" + d->name();
}
else
{
s = typeToString(type);
}
if(mapsToPointerType(type))
{
s += "*";
}
}
if(autoreleasing && !isValueType(type))
{
s += " ICE_AUTORELEASING_QUALIFIER";
}
if(reference)
{
s += "*";
}
return s;
}
void
Slice::Ruby::CodeVisitor::visitDictionary(const DictionaryPtr& p)
{
//
// Emit the type information.
//
string name = fixIdent(p->name(), IdentToUpper);
string scoped = p->scoped();
_out << sp << nl << "if not defined?(" << getAbsolute(p, IdentToUpper, "T_") << ')';
_out.inc();
_out << nl << "T_" << name << " = ::Ice::__defineDictionary('" << scoped << "', ";
writeType(p->keyType());
_out << ", ";
writeType(p->valueType());
_out << ")";
_out.dec();
_out << nl << "end"; // if not defined?()
}
void
Slice::ObjCGenerator::writeOptMemberMarshalUnmarshalCode(Output &out, const TypePtr& type, const string& param,
bool marshal) const
{
string stream = marshal ? "os_" : "is_";
string optionalHelper;
string helper;
BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
if(builtin)
{
if(builtin->kind() == Builtin::KindObjectProxy)
{
optionalHelper = "ICEVarLengthOptionalHelper";
helper = "[ICEProxyHelper class]";
}
else
{
writeMarshalUnmarshalCode(out, type, param, marshal, false);
return;
}
}
ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
if(cl)
{
writeMarshalUnmarshalCode(out, type, param, marshal, false);
return;
}
EnumPtr en = EnumPtr::dynamicCast(type);
if(en)
{
writeMarshalUnmarshalCode(out, type, param, marshal, false);
return;
}
ProxyPtr prx = ProxyPtr::dynamicCast(type);
if(prx)
{
optionalHelper = "ICEVarLengthOptionalHelper";
helper = "objc_getClass(\"" + moduleName(findModule(prx->_class())) + prx->_class()->name() + "PrxHelper\")";
}
StructPtr st = StructPtr::dynamicCast(type);
if(st)
{
if(st->isVariableLength())
{
optionalHelper = "ICEVarLengthOptionalHelper";
}
else
{
optionalHelper = "ICEFixedLengthOptionalHelper";
}
helper = "[" + typeToString(st) + "Helper class]";
}
SequencePtr seq = SequencePtr::dynamicCast(type);
if(seq)
{
TypePtr element = seq->type();
if(element->isVariableLength())
{
optionalHelper = "ICEVarLengthOptionalHelper";
}
else if(element->minWireSize() == 1)
{
writeMarshalUnmarshalCode(out, type, param, marshal, false);
return;
}
else
{
optionalHelper = "ICEFixedSequenceOptionalHelper";
}
helper = "[" + moduleName(findModule(seq)) + seq->name() + "Helper class]";
}
DictionaryPtr d = DictionaryPtr::dynamicCast(type);
if(d)
{
if(d->keyType()->isVariableLength() || d->valueType()->isVariableLength())
{
optionalHelper = "ICEVarLengthOptionalHelper";
}
else
{
optionalHelper = "ICEFixedDictionaryOptionalHelper";
}
helper = "[" + moduleName(findModule(d)) + d->name() + "Helper class]";
}
out << nl;
if(marshal)
{
out << "[" << optionalHelper << " write:" << param << " stream:" << stream << " helper:" << helper << "];";
}
else
{
out << param << " = [" << optionalHelper << " readRetained:" << stream << " helper:" << helper << "];";
}
}