コード例 #1
0
        private static void CheckNullAndWrite(SimpleTypeWriter simpleTypeWriter, object value)
        {
            var isNull = value == null;
            simpleTypeWriter.Write(isNull);
            if (isNull) return;

            simpleTypeWriter.Write(value, true);
        }
コード例 #2
0
 private byte[] WriteSimpleDefContext(SimpleDefContext simpleDefContext)
 {
     using (var simpleTypeWriter = new SimpleTypeWriter(_simpleTypeHelper, _encoding))
     {
         simpleTypeWriter.Write(DefMark.SimpleType);
         simpleTypeWriter.Write(simpleDefContext.SimpleTypeDef.Value, true);
         return simpleTypeWriter.ToArray();
     }
 }
コード例 #3
0
        private static void WriteTypeInfos(SimpleTypeWriter simpleTypeWriter, SimpleList<TypeInfo> typeInfos)
        {
            simpleTypeWriter.Write(typeInfos.Count);
            foreach (var typeInfo in typeInfos)
            {
                simpleTypeWriter.Write(typeInfo.Id);
                simpleTypeWriter.Write(typeInfo.TypeName);
                simpleTypeWriter.Write(typeInfo.IsEnumerable);

                if (typeInfo.IsEnumerable) continue;

                var propertyNames = typeInfo.PropertyNames;
                simpleTypeWriter.Write(propertyNames.Count.CastObj<byte>());
                foreach (var propertyName in propertyNames)
                    simpleTypeWriter.Write(propertyName);
            }
        }
コード例 #4
0
 private byte[] WriteComplexDefContext(ComplexDefContext complexDefContext)
 {
     using (var simpleTypeWriter = new SimpleTypeWriter(_simpleTypeHelper, _encoding))
     {
         simpleTypeWriter.Write(DefMark.ComplexType);
         WriteTypeInfos(simpleTypeWriter, complexDefContext.TypeInfos);
         WriteComplexTypeDefs(simpleTypeWriter, complexDefContext.ComplexTypeDefs);
         return simpleTypeWriter.ToArray();
     }
 }
コード例 #5
0
        private static void WriteComplexTypeDefs(SimpleTypeWriter simpleTypeWriter, SimpleList<ComplexTypeDef> complexTypeDefs)
        {
            simpleTypeWriter.Write(complexTypeDefs.Count);
            foreach (var complexTypeDef in complexTypeDefs)
            {
                var type = complexTypeDef.GetTypeOfObj();
                if (type.IsTypeOf<ArrayDef>())
                {
                    #region ArrayDef

                    var arrayDef = complexTypeDef.CastObj<ArrayDef>();
                    simpleTypeWriter.Write(ComplexTypeMark.Array);
                    simpleTypeWriter.Write(arrayDef.Id);
                    simpleTypeWriter.Write(arrayDef.TypeInfoId);

                    var items = arrayDef.Items;
                    simpleTypeWriter.Write(items.Count);
                    foreach (var item in items)
                        CheckNullAndWrite(simpleTypeWriter, item);

                    var indicies = arrayDef.Indicies;
                    simpleTypeWriter.Write(Convert.ToByte(indicies.Count));
                    foreach (var indicy in indicies)
                        simpleTypeWriter.Write(indicy);

                    #endregion
                }
                else if (type.IsTypeOf<ListDef>())
                {
                    #region ListDef

                    var listDef = complexTypeDef.CastObj<ListDef>();
                    simpleTypeWriter.Write(ComplexTypeMark.List);
                    simpleTypeWriter.Write(listDef.Id);
                    simpleTypeWriter.Write(listDef.TypeInfoId);

                    var items = listDef.Items;
                    simpleTypeWriter.Write(items.Count);
                    foreach (var item in items)
                        CheckNullAndWrite(simpleTypeWriter, item);

                    #endregion
                }
                else if (type.IsTypeOf<DictionaryDef>())
                {
                    #region DictionaryDef

                    var dictionaryDef = complexTypeDef.CastObj<DictionaryDef>();
                    simpleTypeWriter.Write(ComplexTypeMark.Dictionary);
                    simpleTypeWriter.Write(dictionaryDef.Id);
                    simpleTypeWriter.Write(dictionaryDef.TypeInfoId);

                    var keys = dictionaryDef.Keys;
                    simpleTypeWriter.Write(keys.Count);
                    foreach (var key in keys)
                        CheckNullAndWrite(simpleTypeWriter, key);

                    var values = dictionaryDef.Values;
                    simpleTypeWriter.Write(values.Count);
                    foreach (var value in values)
                        CheckNullAndWrite(simpleTypeWriter, value);

                    #endregion
                }
                else if (type.IsTypeOf<UserDefinedDef>())
                {
                    #region UserDefinedDef

                    var userDefinedDef = complexTypeDef.CastObj<UserDefinedDef>();
                    simpleTypeWriter.Write(ComplexTypeMark.UserDefined);
                    simpleTypeWriter.Write(userDefinedDef.Id);
                    simpleTypeWriter.Write(userDefinedDef.TypeInfoId);

                    var names = userDefinedDef.Names;
                    simpleTypeWriter.Write(Convert.ToByte(names.Count));
                    foreach (var index in names)
                        simpleTypeWriter.Write(index);

                    var values = userDefinedDef.Values;
                    simpleTypeWriter.Write(Convert.ToByte(values.Count));
                    foreach (var value in values)
                        CheckNullAndWrite(simpleTypeWriter, value);

                    #endregion
                }
                else throw new UnknownImplementationException(typeof(ComplexTypeDef), type);
            }
        }