массив массивов [][]

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@55421 954022d7-b5bf-4e40-9824-e11837661b57

Test/Applications/DocxFormatCodeGen/codegen/CodeGen.cs

@@ -24,7 +24,7 @@ namespace codegen
         public List<GenMember> aArrayTypes;
         public string sArrayTypesElementName;
         public string sArrayTypesEnumName;
-        public bool bInternal;
+        public bool bInternal;//отличает массив с типами
 
         public bool bToDo;
         public bool bToDoString;
@@ -51,7 +51,7 @@ namespace codegen
         public string sNamespace;
         public bool bIsEnum;
         public List<GenMember> aMembers = new List<GenMember>();
-        public bool bInternal;
+        public bool bInternal;//отличает enum типов
         public bool bIsRoot;
         public GenClass(string _sName, string _sNamespace)
         {
@@ -64,10 +64,8 @@ namespace codegen
     }
     class CodeGen
     {
-        Dictionary<string, bool> m_mapProcessedTypes = new Dictionary<string, bool>();
-        Dictionary<string, CodeTypeDeclaration> m_mapTypeNames = new Dictionary<string, CodeTypeDeclaration>();
-        Dictionary<string, bool> m_mapIgnoreTypes = new Dictionary<string, bool>();
-        int nItemsChoiceTypeCount = 0;
+        Dictionary<string, GenClass> m_mapGeneratedClasses = new Dictionary<string, GenClass>();
+        int m_nItemsChoiceTypeCount = 0;
         public void Start(string sDirIn, string sDirCppXmlOut, string sDirCppBinOut, string sDirJsBinOut, ValidationEventHandler oValidationEventHandler)
         {
             string sChartNamespace = "http://purl.oclc.org/ooxml/drawingml/chart";
@@ -109,6 +107,8 @@ namespace codegen
                 }
                 CodeGenerator.ValidateIdentifiers(ns);
 
+                //Microsoft.CSharp.CSharpCodeProvider oProvider;
+
                 //// output the C# code
                 //Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
 
@@ -122,8 +122,8 @@ namespace codegen
 
                 aGenClasses = FilterClasses(aGenClasses);
 
-                //(new CodegenCPP()).Process(sDirCppXmlOut, sDirCppBinOut, aGenClasses);
-                //(new CodegenJS()).Process(sDirJsBinOut, aGenClasses);
+                (new CodegenCPP()).Process(sDirCppXmlOut, sDirCppBinOut, aGenClasses);
+                (new CodegenJS()).Process(sDirJsBinOut, aGenClasses);
             }
         }
         List<GenClass> FilterClasses(List<GenClass> aInput)
@@ -262,6 +262,7 @@ namespace codegen
             InitMemberType(oGenMember, codeMemberProperty.Type.BaseType);
             if (null != codeMemberProperty.Type.ArrayElementType)
                 oGenMember.bIsArray = true;
+            List<GenMember> aWrappedMemebers = null;
             for (int i = 0; i < codeMemberProperty.CustomAttributes.Count; i++)
             {
                 CodeAttributeDeclaration attribute = codeMemberProperty.CustomAttributes[i];
@@ -328,6 +329,32 @@ namespace codegen
                         }
                     }
                 }
+                else if (attribute.Name == "System.Xml.Serialization.XmlArrayItemAttribute")
+                {
+                    GenMember oWrapMemeber = new GenMember(null);
+                    for (int j = 0; j < attribute.Arguments.Count; ++j)
+                    {
+                        CodeAttributeArgument oArg = attribute.Arguments[j];
+                        CodeExpression oCodeExpression = oArg.Value;
+                        if (oCodeExpression is CodePrimitiveExpression)
+                        {
+                            CodePrimitiveExpression oCodePrimitiveExpression = oCodeExpression as CodePrimitiveExpression;
+                            if ("" == oArg.Name)
+                                oWrapMemeber.sName = oCodePrimitiveExpression.Value.ToString();
+                        }
+                        else if (oCodeExpression is CodeTypeOfExpression)
+                        {
+                            CodeTypeOfExpression oTypeOfExpression = oCodeExpression as CodeTypeOfExpression;
+                            InitMemberType(oWrapMemeber, oTypeOfExpression.Type.BaseType);
+                        }
+                    }
+                    if (null != oWrapMemeber.sName)
+                    {
+                        if (null == aWrappedMemebers)
+                            aWrappedMemebers = new List<GenMember>();
+                        aWrappedMemebers.Add(oWrapMemeber);
+                    }
+                }
                 //todo не всегда прописан
                 //else if (attribute.Name == "System.Xml.Serialization.XmlChoiceIdentifierAttribute")
                 //{
@@ -342,17 +369,82 @@ namespace codegen
                 return null;
             else
             {
+                if (oGenMember.bIsArray && null != aWrappedMemebers)
+                {
+                    //todo не проверен случай
+                    //[System.Xml.Serialization.XmlArrayItemAttribute("ahPolar", typeof(CT_PolarAdjustHandle), IsNullable=false)]
+                    //[System.Xml.Serialization.XmlArrayItemAttribute("ahXY", typeof(CT_XYAdjustHandle), IsNullable=false)]
+                    //public object[] ahLst {
+
+                    //создаем wrap class чтобы не работать с двумерными массивами
+                    string sNewName = Utils.GetClassName(oGenMember.sName);
+                    GenClass oNewGenClass = new GenClass(sNewName, oGenMember.sNamespace);
+                    if (null == oNewGenClass.sNamespace)
+                        oNewGenClass.sNamespace = oGenClass.sNamespace;
+                    //помещаем класс указанный в атрибутах в aMembers
+                    for (int i = 0; i < aWrappedMemebers.Count; ++i)
+                    {
+                        GenMember oWrappedMemeber = aWrappedMemebers[i];
+                        if (null == oWrappedMemeber.sType && null == oWrappedMemeber.oSystemType)
+                        {
+                            oWrappedMemeber.sType = oGenMember.sType;
+                            oWrappedMemeber.oSystemType = oGenMember.oSystemType;
+                        }
+                        oWrappedMemeber.bIsArray = true;
+                        oWrappedMemeber.sNamespace = oNewGenClass.sNamespace;
+                        oNewGenClass.aMembers.Add(oWrappedMemeber);
+                    }
+                    //проверяем нет ли такого типа
+                    bool bExist = false;
+                    bool bNeedCreate = true;
+                    GenClass oPrevGenClass;
+                    if (m_mapGeneratedClasses.TryGetValue(sNewName, out oPrevGenClass))
+                    {
+                        bExist = true;
+                        if (oNewGenClass.sName == oPrevGenClass.sName && oNewGenClass.sNamespace == oPrevGenClass.sNamespace && oNewGenClass.aMembers.Count == oPrevGenClass.aMembers.Count)
+                        {
+                            bNeedCreate = false;
+                            for (int i = 0; i < oNewGenClass.aMembers.Count; ++i)
+                            {
+                                GenMember oGenMember1 = oNewGenClass.aMembers[i];
+                                GenMember oGenMember2 = oPrevGenClass.aMembers[i];
+                                if (oGenMember1.sName != oGenMember2.sName || oGenMember1.sType != oGenMember2.sType || oGenMember1.oSystemType != oGenMember2.oSystemType)
+                                    bNeedCreate = true;
+                            }
+                        }
+                    }
+                    if(bNeedCreate)
+                    {
+                        if (bExist)
+                        {
+                            int nCount = 1;
+                            GenClass oTemp;
+                            while (m_mapGeneratedClasses.TryGetValue(sNewName = Utils.GetClassName(oGenMember.sName + nCount), out oTemp))
+                                nCount++;
+                            oNewGenClass.sName = sNewName;
+                        }
+                        aGenClasses.Add(oNewGenClass);
+                        m_mapGeneratedClasses[oNewGenClass.sName] = oNewGenClass;
+                    }
+                    //меняем oGenMember, чтобы он ссылался на oNewGenClass
+                    if (codeMemberProperty.Type.ArrayElementType.ArrayRank > 0)
+                        oGenMember.bIsArray = true;
+                    else
+                        oGenMember.bIsArray = false;
+                    oGenMember.oSystemType = null;
+                    oGenMember.sType = oNewGenClass.sName;
+                }
                 if (oGenMember.bIsArray && null != oGenMember.aArrayTypes)
                 {
                     //добавляем enum для member и дополнительный массив для типов
-                    GenClass oNewEnum = new GenClass("ItemsChoiceType" + nItemsChoiceTypeCount++, oGenClass.sNamespace);
+                    GenClass oNewEnum = new GenClass(Utils.gc_sItemsChoiceType + m_nItemsChoiceTypeCount++, oGenClass.sNamespace);
                     oNewEnum.bInternal = true;
                     oNewEnum.bIsEnum = true;
                     for (int i = 0; i < oGenMember.aArrayTypes.Count; ++i)
                     {
                         oNewEnum.aMembers.Add(new GenMember(oGenMember.aArrayTypes[i].sName));
                     }
-                    GenMember oNewPairArray = new GenMember("ItemsElementName" + nItemsElementName++);
+                    GenMember oNewPairArray = new GenMember(Utils.gc_sItemsElementName + nItemsElementName++);
                     oNewPairArray.bInternal = true;
                     oNewPairArray.bIsArray = true;
                     oNewPairArray.sType = oNewEnum.sName;

Test/Applications/DocxFormatCodeGen/codegen/CodegenCPP.cs

@@ -128,10 +128,12 @@ namespace codegen
                     GenMember member = oGenClass.aMembers[i];
                     if (0 != i)
                         m_oDocxSerH.Append(",\r\n");
-                    m_oDocxSerH.AppendFormat("{0} = {1}", Utils.GetEnumElemName(oGenClass.sName, member.sName), i + 1);
+                    m_oDocxSerH.AppendFormat("{0} = {1}", Utils.GetEnumElemName(oGenClass.sName, member.sName), i);
                 }
                 m_oDocxSerH.AppendFormat("\r\n}};\r\n");
                 //.cpp
+                if (!oGenClass.bInternal)
+                {
                     m_oDocxSerCPP.AppendFormat("bool {0}{1}(CString& val, {2}& eOut)\r\n{{\r\n", gc_sEnumFromXmlPrefix, oGenClass.sName, oGenClass.sName);
                     if (oGenClass.aMembers.Count > 0)
                     {
@@ -170,6 +172,7 @@ namespace codegen
                         m_oDocxSerCPP.AppendFormat("return false;\r\n");
                     m_oDocxSerCPP.AppendFormat("}}\r\n");
                 }
+            }
             else
             {
                 m_oDocxTypesH.AppendFormat("{0},\r\n", gc_sTypePattern + oGenClass.sName.ToLower());
@@ -761,10 +764,13 @@ namespace codegen
             for (int i = 0; i < oGenClass.aMembers.Count; ++i)
             {
                 GenMember oGenMember = oGenClass.aMembers[i];
-                if (!oGenMember.bInternal && null != oGenMember.aArrayTypes)
+                if (!oGenMember.bInternal)
+                {
+                    if (null != oGenMember.aArrayTypes)
                         ProcessArrayTypesToBin(sb, oGenClass, oGenMember);
                 }
             }
+        }
         void ProcessArrayTypesToBin(StringBuilder sb, GenClass oGenClass, GenMember oGenMember)
         {
             sb.AppendFormat("void {0}::toBin({1} eType, void* pVal){{\r\n", Utils.gc_sBinaryChartWriter, oGenMember.sArrayTypesEnumName);

Test/Applications/DocxFormatCodeGen/codegen/CodegenJS.cs

@@ -39,7 +39,12 @@ namespace codegen
             for (int i = 0; i < aClasses.Count; ++i)
                 ProcessToBin(oJsSer, aClasses[i]);
             //FromBin
-            ProcessFromBin(oJsSer, aEnums, aClasses);
+            oJsSer.AppendFormat("function {0}(stream){{\r\n", Utils.gc_sBinaryChartReader);
+            oJsSer.AppendFormat("this.stream = stream;\r\n");
+            oJsSer.AppendFormat("this.bcr = new Binary_CommonReader(this.stream);\r\n");
+            oJsSer.AppendFormat("}}\r\n");
+            for (int i = 0; i < aClasses.Count; ++i)
+                ProcessFromBin(oJsSer, aClasses[i]);
             File.WriteAllText(Path.Combine(sOutputDir, sFileJs), oJsSer.ToString());
         }
         public void ProcessEnums(StringBuilder sb, List<GenClass> aGenClasses)
@@ -50,7 +55,7 @@ namespace codegen
                 for (int j = 0; j < oGenClass.aMembers.Count; ++j)
                 {
                     GenMember oGenMember = oGenClass.aMembers[j];
-                    if(!oGenMember.bInternal)
+                    if (!oGenMember.bInternal)
                         sb.AppendFormat("var {0} = {1};\r\n", Utils.GetEnumElemName(oGenClass.sName, oGenMember.sName), j);
                 }
                 sb.AppendFormat("\r\n");
@@ -80,15 +85,8 @@ namespace codegen
                 sb.AppendFormat("\r\n");
             }
         }
-        public void ProcessFromBin(StringBuilder sb, List<GenClass> aEnums, List<GenClass> aClasses)
+        public void ProcessFromBin(StringBuilder sb, GenClass oGenClass)
         {
-            sb.AppendFormat("function {0}(stream){{\r\n", Utils.gc_sBinaryChartReader);
-            sb.AppendFormat("this.stream = stream;\r\n");
-            sb.AppendFormat("this.bcr = new Binary_CommonReader(this.stream);\r\n");
-            sb.AppendFormat("}}\r\n");
-            for (int i = 0; i < aClasses.Count; ++i)
-            {
-                GenClass oGenClass = aClasses[i];
             if (oGenClass.bIsRoot)
             {
                 sb.AppendFormat("{0}.prototype.ExternalRead{1} = function(length, val){{\r\n", Utils.gc_sBinaryChartReader, oGenClass.sName);
@@ -124,7 +122,6 @@ namespace codegen
             }
             sb.AppendFormat("else\r\nres = c_oSerConstants.ReadUnknown;\r\nreturn res;\r\n}}\r\n", oGenClass.sName);
         }
-        }
         int ProcessMemberFromBin(StringBuilder sb, string sVal, GenClass oGenClass, GenMember oGenMember, GenMember oGenMemberContainer, int nCounter)
         {
             if (0 != nCounter)

Test/Applications/DocxFormatCodeGen/codegen/Program.cs

@@ -9,9 +9,9 @@ namespace codegen
     class Program
     {
         static string sDirIn = @"..\..\Resource\";
-        static string sDirCppXmlOut = @"D:\Subversion\AVS\Sources\TeamlabOffice\trunk\ServerComponents\Common\DocxFormat\Source\XlsxFormat\Chart\";
-        static string sDirCppBinOut = @"D:\Subversion\AVS\Sources\TeamlabOffice\trunk\ServerComponents\XlsxSerializerCom\Reader\";
-        static string sDirJsBinOut = @"D:\Subversion\AVS\Sources\TeamlabOffice\trunk\OfficeWeb\Common\";
+        static string sDirCppXmlOut = @"..\..\gen\";
+        static string sDirCppBinOut = @"..\..\gen\";
+        static string sDirJsBinOut = @"..\..\gen\";
         static void Main(string[] args)
         {
             (new codegen.CodeGen()).Start(sDirIn, sDirCppXmlOut, sDirCppBinOut, sDirJsBinOut, ValidationCallback);

Test/Applications/DocxFormatCodeGen/codegen/Resource/chart20070802.xsd

 <?xml version="1.0" encoding="utf-8"?>
-<xsd:schema targetNamespace="http://schemas.microsoft.com/office/drawing/2007/8/2/chart" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/office/drawing/2007/8/2/chart" blockDefault="#all" xmlns:cdr="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing" xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart">
+<xsd:schema targetNamespace="http://schemas.microsoft.com/office/drawing/2007/8/2/chart" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:a="http://purl.oclc.org/ooxml/drawingml/main" xmlns:r="http://purl.oclc.org/ooxml/officeDocument/relationships" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/office/drawing/2007/8/2/chart" blockDefault="#all" xmlns:cdr="http://purl.oclc.org/ooxml/drawingml/chartDrawing" xmlns:c="http://purl.oclc.org/ooxml/drawingml/chart">
   <xsd:simpleType name="ST_Style">
     <xsd:restriction base="xsd:unsignedByte">
       <xsd:minInclusive value="101"/>

Test/Applications/DocxFormatCodeGen/codegen/Utils.cs

@@ -12,6 +12,8 @@ namespace codegen
         public static string gc_sFilePrefix = "//Generated code\r\n";
         public static string gc_sMemberPrefix = "m_";
         public static string gc_sSerToBinEnumPrefix = "c_oSer";
+        public static string gc_sItemsChoiceType = "ItemsChoiceType";
+        public static string gc_sItemsElementName = "ItemsElementName";
         public static string GetEnumElemName(string sEnumName, string sElemName)
         {
             return sEnumName.ToLower() + sElemName.ToUpper();
@@ -24,5 +26,9 @@ namespace codegen
         {
             return gc_sMemberPrefix + sElemName;
         }
+        public static string GetClassName(string sElemName)
+        {
+            return "CT_" + sElemName;
+        }
     }
 }