Added array mapping for sequences to Icicle.

2 files changed, 190 insertions, 12 deletions

diff --git a/cpp/src/Slice/CsUtil.cpp b/cpp/src/Slice/CsUtil.cpp
index 4a29dc6cb94..58f33144159 100755
--- a/cpp/src/Slice/CsUtil.cpp
+++ b/cpp/src/Slice/CsUtil.cpp
@@ -172,6 +172,12 @@ Slice::CsGenerator::typeToString(const TypePtr& type)
         return fixId(proxy->_class()->scoped() + "Prx");
     }
 
+    SequencePtr seq = SequencePtr::dynamicCast(type);
+    if(seq && seq->hasMetaData("cs:array"))
+    {
+	return typeToString(seq->type()) + "[]";
+    }
+
     ContainedPtr contained = ContainedPtr::dynamicCast(type);
     if(contained)
     {
@@ -487,10 +493,10 @@ Slice::CsGenerator::writeMarshalUnmarshalCode(Output &out,
 
 void
 Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
-                                                        const SequencePtr& seq,
-                                                        const string& param,
-                                                        bool marshal,
-							bool isSeq)
+                                                      const SequencePtr& seq,
+                                                      const string& param,
+                                                      bool marshal,
+						      bool isSeq)
 {
     string stream = marshal ? "__os" : "__is";
 
@@ -560,14 +566,28 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
 	    {
 		string typeS = typeToString(type);
 		typeS[0] = toupper(typeS[0]);
+		bool isArray = seq->hasMetaData("cs:array");
 		if(marshal)
 		{
-		    out << nl << stream << ".write" << typeS << "Seq(" << param << ".ToArray());";
+		    out << nl << stream << ".write" << typeS << "Seq(" << param;
+		    if(!isArray)
+		    {
+		        out << ".ToArray()";
+		    }
+		    out << ");";
 		}
 		else
 		{
-		    out << nl << param << startAssign << "new " << fixId(seq->scoped()) << "(" << stream
-		        << ".read" << typeS << "Seq())" << endAssign << ";";
+		    out << nl << param << startAssign;
+		    if(!isArray)
+		    {
+			out << "new " << fixId(seq->scoped()) << "(" << stream << ".read" << typeS << "Seq())";
+		    }
+		    else
+		    {
+		        out << stream << ".read" << typeS << "Seq()";
+		    }
+		    out << endAssign << ";";
 		}
 		break;
 	    }
@@ -673,3 +693,143 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
 
     return;
 }
+
+void
+Slice::CsGenerator::validateMetaData(const UnitPtr& unit)
+{
+    MetaDataVisitor visitor;
+    unit->visit(&visitor);
+}
+
+bool
+Slice::CsGenerator::MetaDataVisitor::visitModuleStart(const ModulePtr& p)
+{
+    validate(p);
+    return false;
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::visitClassDecl(const ClassDeclPtr& p)
+{
+    validate(p);
+}
+
+bool
+Slice::CsGenerator::MetaDataVisitor::visitClassDefStart(const ClassDefPtr& p)
+{
+    validate(p);
+    return false;
+}
+
+bool
+Slice::CsGenerator::MetaDataVisitor::visitExceptionStart(const ExceptionPtr& p)
+{
+    validate(p);
+    return false;
+}
+
+bool
+Slice::CsGenerator::MetaDataVisitor::visitStructStart(const StructPtr& p)
+{
+    validate(p);
+    return false;
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::visitOperation(const OperationPtr& p)
+{
+    validate(p);
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::visitParamDecl(const ParamDeclPtr& p)
+{
+    validate(p);
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::visitDataMember(const DataMemberPtr& p)
+{
+    validate(p);
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::visitSequence(const SequencePtr& p)
+{
+    validate(p);
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::visitDictionary(const DictionaryPtr& p)
+{
+    validate(p);
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::visitEnum(const EnumPtr& p)
+{
+    validate(p);
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::visitConst(const ConstPtr& p)
+{
+    validate(p);
+}
+
+void
+Slice::CsGenerator::MetaDataVisitor::validate(const ContainedPtr& cont)
+{
+    DefinitionContextPtr dc = cont->definitionContext();
+    assert(dc);
+    StringList globalMetaData = dc->getMetaData();
+    string file = dc->filename();
+
+    StringList localMetaData = cont->getMetaData();
+
+    StringList::const_iterator p;
+    static const string prefix = "cs:";
+
+    for(p = globalMetaData.begin(); p != globalMetaData.end(); ++p)
+    {
+        string s = *p;
+        if(_history.count(s) == 0)
+        {
+            if(s.find(prefix) == 0)
+            {
+		cout << file << ": warning: ignoring invalid global metadata `" << s << "'" << endl;
+            }
+            _history.insert(s);
+        }
+    }
+
+    for(p = localMetaData.begin(); p != localMetaData.end(); ++p)
+    {
+	string s = *p;
+        if(_history.count(s) == 0)
+        {
+	    bool valid = true;
+            if(s.find(prefix) == 0)
+            {
+	    	if(SequencePtr::dynamicCast(cont))
+		{
+		    if(s.substr(prefix.size()) != "array")
+		    {
+			cerr << "2" << endl;
+			valid = false;
+		    }
+		}
+		else
+		{
+		    cerr << "3" << endl;
+		    valid = false;
+		}
+            }
+	    if(!valid)
+	    {
+		cout << file << ": warning: ignoring invalid metadata `" << s << "'" << endl;
+	    }
+            _history.insert(s);
+        }
+    }
+}
diff --git a/cpp/src/slice2cs/Gen.cpp b/cpp/src/slice2cs/Gen.cpp
index 269352b25dc..b58ffb965dd 100755
--- a/cpp/src/slice2cs/Gen.cpp
+++ b/cpp/src/slice2cs/Gen.cpp
@@ -154,16 +154,14 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
     }
     _out << eb << ";";
 
-    _out << sp << nl << "private static readonly Ice.StringSeq __idSeq = new Ice.StringSeq(__ids);";
-
     _out << sp << nl << "public override bool ice_isA(string s, Ice.Current __current)";
     _out << sb;
     _out << nl << "return _System.Array.BinarySearch(__ids, s, _System.Collections.Comparer.DefaultInvariant) >= 0;";
     _out << eb;
 
-    _out << sp << nl << "public override Ice.StringSeq ice_ids(Ice.Current __current)";
+    _out << sp << nl << "public override string[] ice_ids(Ice.Current __current)";
     _out << sb;
-    _out << nl << "return __idSeq;";
+    _out << nl << "return __ids;";
     _out << eb;
 
     _out << sp << nl << "public override string ice_id(Ice.Current __current)";
@@ -550,6 +548,9 @@ Slice::Gen::operator!() const
 void
 Slice::Gen::generate(const UnitPtr& p)
 {
+
+    CsGenerator::validateMetaData(p);
+
     TypesVisitor typesVisitor(_out);
     p->visit(&typesVisitor);
 
@@ -1059,6 +1060,14 @@ Slice::Gen::TypesVisitor::visitOperation(const OperationPtr& p)
 void
 Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
 {
+    //
+    // No need to generate anything if the sequence is mapped as an array.
+    //
+    if(p->hasMetaData("cs:array"))
+    {
+        return;
+    }
+
     string name = fixId(p->name());
     string s = typeToString(p->type());
     bool isValue = isValueType(p->type());
@@ -2527,7 +2536,16 @@ Slice::Gen::HelperVisitor::visitSequence(const SequencePtr& p)
 
     _out << sp << nl << "public static " << typeS << " read(IceInternal.BasicStream __is)";
     _out << sb;
-    _out << nl << typeS << " __v = new " << typeS << "();";
+    bool isArray = p->hasMetaData("cs:array");
+    _out << nl << typeS << " __v";
+    if(!isArray)
+    {
+        _out << " = new " << typeS << "();";
+    }
+    else
+    {
+        _out << ";";
+    }
     writeSequenceMarshalUnmarshalCode(_out, p, "__v", false, false);
     _out << nl << "return __v;";
     _out << eb;