예제 #1
0
        public void HandleWrite(TypeHandlingContext context)
        {
            var valueType    = context.Type.GetGenericUnderlyingType(_listTypeElement);
            var valueHandler = TypeHandlers.All.First(h => h.CanHandle(context.WithType(valueType)));

            var exists = context.Variables.Declare("exists");
            var index  = context.Variables.Declare("index");

            context.Builder.AppendFormat("var {0} = {1} != null;", exists, context.TypeOwnerName);
            TypeHandlers.Boolean.HandleWrite(new TypeHandlingContext(context)
            {
                TypeOwnerName = exists,
            });
            context.Builder.AppendFormat("if({0})", exists);
            context.Builder.Append("{");
            TypeHandlers.Int32.HandleWrite(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("{0}.Count", context.TypeOwnerName)
            });
            context.Builder.AppendFormat("for(Int32 {0} = 0; {0} < {1}.Count; {0}++)", index, context.TypeOwnerName);
            context.Builder.Append("{");
            valueHandler.HandleWrite(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("{0}[{1}]", context.TypeOwnerName, index)
            });
            context.Builder.Append("}");
            context.Builder.Append("}");

            context.Variables.Dispose("index");
        }
        public void HandleGetSize(TypeHandlingContext context)
        {
            IType valueType = context.Type.GetNullableUnderlyingType();

            if (valueType == null)
            {
                throw new NotSupportedException();
            }

            var valueHandlingContext = new TypeHandlingContext(context)
            {
                Type          = valueType,
                TypeName      = valueType.GetPresentableName(context.PresentationLanguage),
                TypeOwnerName = String.Format("{0}.Value", context.TypeOwnerName),
            };
            ITypeHandler valueHandler = TypeHandlers.All.FirstOrDefault(h => h.CanHandle(valueHandlingContext));

            if (valueHandler == null)
            {
                throw new NotSupportedException();
            }

            context.Builder.AppendFormat("{0} += sizeof(Boolean);", context.GetSizeVariableName());
            valueHandler.HandleGetSize(context);
        }
        public void HandleWrite(TypeHandlingContext context)
        {
            IType valueType = context.Type.GetNullableUnderlyingType();

            if (valueType == null)
            {
                throw new NotSupportedException();
            }

            var valueHandlingContext = new TypeHandlingContext(context)
            {
                Type          = valueType,
                TypeName      = valueType.GetPresentableName(context.PresentationLanguage),
                TypeOwnerName = String.Format("{0}.Value", context.TypeOwnerName)
            };

            ITypeHandler valueHandler = TypeHandlers.All.FirstOrDefault(h => h.CanHandle(valueHandlingContext));

            if (valueHandler == null)
            {
                throw new NotSupportedException();
            }

            context.Builder.AppendFormat("tmp = BitConverter.GetBytes({0}.HasValue);", context.TypeOwnerName);
            context.Builder.Append("Array.Copy(tmp, 0, bytes, index, tmp.Length);");
            context.Builder.Append("index += tmp.Length;");
            context.Builder.AppendFormat("if({0}.HasValue)", context.TypeOwnerName).Append("{");
            valueHandler.HandleWrite(valueHandlingContext);
            context.Builder.Append("}");
        }
예제 #4
0
        public bool CanHandle(TypeHandlingContext context)
        {
            var classType = context.Type.GetClassType();

            if (classType != null)
            {
                if (classType.Constructors.Any(c => c.Parameters.Count == 0))
                {
                    var generators = MethodGenerators.All;
                    var found      = new Boolean[generators.Length];

                    foreach (var method in classType.Methods)
                    {
                        for (Int32 i = 0, c = generators.Length; i < c; i++)
                        {
                            if (!found[i])
                            {
                                found[i] = generators[i].IsGenerationTarget(method);
                            }
                        }
                    }

                    if (found.All(any => any))
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
 public void HandleRead(TypeHandlingContext context)
 {
     context.Builder.Append("tmp = new Byte[16];");
     context.Builder.Append("Array.Copy(bytes, index, tmp, 0, tmp.Length);");
     context.Builder.AppendFormat("{0} = new Guid(tmp);", context.TypeOwnerName);
     context.Builder.Append("index += 16;");
 }
        public void HandleRead(TypeHandlingContext context)
        {
            IType type = context.Type;

            IType valueType = type.GetNullableUnderlyingType();

            if (valueType == null)
            {
                throw new NotSupportedException();
            }

            var valueHandlingContext = new TypeHandlingContext(context)
            {
                Type          = valueType,
                TypeName      = valueType.GetPresentableName(context.PresentationLanguage),
                TypeOwnerName = String.Format("{0}", context.TypeOwnerName)
            };

            ITypeHandler valueHandler = TypeHandlers.All.FirstOrDefault(h => h.CanHandle(valueHandlingContext));

            if (valueHandler == null)
            {
                throw new NotSupportedException();
            }

            context.Builder.Append("if(BitConverter.ToBoolean(bytes, index)){");
            context.Builder.Append("index += sizeof(Boolean);");
            valueHandler.HandleRead(valueHandlingContext);
            context.Builder.Append("}");
            context.Builder.Append("else{");
            context.Builder.Append("index += sizeof(Boolean);");
            context.Builder.Append("}");
        }
예제 #7
0
        public void HandleRead(TypeHandlingContext context)
        {
            var length = context.Variables.Declare("length");
            var exists = context.Variables.Declare(VariableKeys.NotNull);

            TypeHandlers.Boolean.HandleRead(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("var {0}", exists)
            });

            context.Builder.AppendFormat("if({0})", exists);
            context.Builder.Append("{");
            TypeHandlers.Int32.HandleRead(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("var {0}", length)
            });
            context.Builder.AppendFormat("if({0} > 0)", length);
            context.Builder.Append("{");
            context.Builder.AppendFormat("{0} = System.Text.Encoding.UTF8.GetString(bytes, index, {1});", context.TypeOwnerName, length);
            context.Builder.AppendFormat("index += System.Text.Encoding.UTF8.GetByteCount({0});", context.TypeOwnerName);
            context.Builder.Append("}");
            context.Builder.Append("else{");
            context.Builder.AppendFormat("{0} = String.Empty;", context.TypeOwnerName);
            context.Builder.Append("}");
            context.Builder.Append("}");

            context.Variables.Dispose("length");
        }
예제 #8
0
 public void HandleGetSize(TypeHandlingContext context)
 {
     TypeHandlers.Boolean.HandleGetSize(context);
     context.Builder.AppendFormat("if({0} != null)", context.TypeOwnerName);
     context.Builder.Append("{");
     context.Builder.AppendFormat("{2} += {0}.{1}();", context.TypeOwnerName, GetBinarySizeMethodGenerator.MethodName, context.GetSizeVariableName());
     context.Builder.Append("}");
 }
예제 #9
0
        public void HandleGetSize(TypeHandlingContext context)
        {
            IDeclaredType valueType = context.Type.GetScalarType();

            if (valueType == null)
            {
                throw new NotSupportedException();
            }

            ITypeHandler valueHandler = TypeHandlers.All.SingleOrDefault(h => h.CanHandle(context.WithType(valueType)));

            if (valueHandler == null)
            {
                throw new NotSupportedException();
            }

            var exists = context.Variables.Declare(VariableKeys.NotNull);

            context.Builder.AppendFormat("var {0} = {1} != null;", exists, context.TypeOwnerName);
            TypeHandlers.Boolean.HandleGetSize(new TypeHandlingContext(context)
            {
                TypeOwnerName = exists
            });

            context.Builder.AppendFormat("if({0})", exists).Append("{");
            TypeHandlers.Int32.HandleGetSize(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("{0}.Length", context.TypeOwnerName)
            });
            context.Builder.AppendFormat("if({0}.Length > 0)", context.TypeOwnerName);
            context.Builder.Append("{");
            if (valueHandler.BinarySizePersistent)
            {
                var size = context.Variables.Declare(VariableKeys.ValueSize);

                context.Builder.AppendFormat("var {0} = 0;", size);

                valueHandler.HandleGetSize(new TypeHandlingContext(context)
                {
                    SizeVariableKey = VariableKeys.ValueSize
                });

                context.Builder.AppendFormat("{0} += {1}*{2}.Length;", context.GetSizeVariableName(), size, context.TypeOwnerName);
            }
            else
            {
                var indexName = context.Variables.Declare(Index);
                context.Builder.AppendFormat("for(Int32 {0} = 0; {0} < {1}.Length; {0}++)", indexName, context.TypeOwnerName);
                context.Builder.Append("{");
                valueHandler.HandleGetSize(new TypeHandlingContext(context)
                {
                    TypeOwnerName = String.Format("{0}[{1}]", context.TypeOwnerName, indexName)
                });
                context.Builder.Append("}");
            }
            context.Builder.Append("}}");
        }
        public override void Populate(CSharpGeneratorContext context)
        {
            // use context.ProvidedElements.AddRange to add new
            // generator elements (e.g., GeneratorDeclaredElement<T>)
            IClassLikeDeclaration typeDeclaration = context.ClassDeclaration;
            ITypeElement          typeElement     = typeDeclaration.DeclaredElement;

            ListHandler.Initialize(context);
            MethodGeneratorBase.Initialize(context);
            GetBytesMethodGenerator.Initialize(context);
            SetBytesMethodGenerator.Initialize(context);

            if (typeElement is IClass || typeElement is IStruct)
            {
                var ctx = new TypeHandlingContext(context);

                foreach (ITypeMember member in typeElement.GetMembers())
                {
                    ITypeOwner owner = null;

                    var field = member as IField;
                    if (field != null)
                    {
                        if (field.GetAccessRights() != AccessRights.PRIVATE &&
                            !field.IsConstant &&
                            !field.IsReadonly &&
                            !field.IsStatic)
                        {
                            owner = field;
                        }
                    }

                    var property = member as IProperty;
                    if (property != null)
                    {
                        if (property.IsReadable &&
                            property.IsWritable &&
                            !property.IsStatic)
                        {
                            owner = property;
                        }
                    }

                    if (owner != null)
                    {
                        ctx.Resolve(owner);

                        if (TypeHandlers.All.Any(h => h.CanHandle(ctx)))
                        {
                            context.ProvidedElements.Add(new GeneratorDeclaredElement <ITypeOwner>(owner));
                        }
                    }
                }
            }
        }
예제 #11
0
 public void HandleGetSize(TypeHandlingContext context)
 {
     TypeHandlers.Boolean.HandleGetSize(context);
     context.Builder.AppendFormat("if({0} != null)", context.TypeOwnerName);
     context.Builder.Append("{");
     TypeHandlers.Int32.HandleGetSize(context);
     context.Builder.AppendFormat("if(!String.IsNullOrEmpty({0}))", context.TypeOwnerName);
     context.Builder.Append("{");
     context.Builder.AppendFormat("{1} += System.Text.Encoding.UTF8.GetByteCount({0});", context.TypeOwnerName, context.GetSizeVariableName());
     context.Builder.Append("}");
     context.Builder.Append("}");
 }
예제 #12
0
        public void HandleGetSize(TypeHandlingContext context)
        {
            IEnum enumType = context.Type.GetEnumType();

            if (enumType == null)
            {
                throw new NotSupportedException();
            }

            IType baseType = enumType.GetUnderlyingType();

            context.Builder.AppendFormat("{1} += sizeof({0});", baseType.GetPresentableName(context.PresentationLanguage), context.GetSizeVariableName());
        }
예제 #13
0
        public bool CanHandle(TypeHandlingContext context)
        {
            var arrayType = context.Type as IArrayType;

            if (arrayType != null && arrayType.Rank == 1)
            {
                var scalarType = context.Type.GetScalarType();
                if (scalarType != null)
                {
                    return(TypeHandlers.All.Any(h => h.CanHandle(context.WithType(scalarType))));
                }
            }

            return(false);
        }
예제 #14
0
        public void HandleWrite(TypeHandlingContext context)
        {
            var haveValue = context.Variables.Declare("haveValue");

            context.Builder.Append("{");
            context.Builder.AppendFormat("var {0} = {1} != null;", haveValue, context.TypeOwnerName);
            TypeHandlers.Boolean.HandleWrite(new TypeHandlingContext(context)
            {
                TypeOwnerName = haveValue
            });
            context.Builder.AppendFormat("if({0} != null)", context.TypeOwnerName);
            context.Builder.Append("{");
            context.Builder.AppendFormat("index += {0}.{1}(bytes, index);", context.TypeOwnerName, WriteMethodGenerator.Instance.MethodName);
            context.Builder.Append("}}");

            context.Variables.Dispose("haveValue");
        }
예제 #15
0
        public void HandleRead(TypeHandlingContext context)
        {
            var haveValue = context.Variables.Declare("haveValue");

            context.Builder.Append("{");
            TypeHandlers.Boolean.HandleRead(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("var {0}", haveValue)
            });
            context.Builder.AppendFormat("if({0})", haveValue);
            context.Builder.Append("{");
            context.Builder.AppendFormat("{0} = new {1}();", context.TypeOwnerName, context.TypeName);
            context.Builder.AppendFormat("index += {0}.{1}(bytes, index);", context.TypeOwnerName, ReadMethodGenerator.Instance.MethodName);
            context.Builder.Append("}}");

            context.Variables.Dispose("haveValue");
        }
예제 #16
0
        public void HandleRead(TypeHandlingContext context)
        {
            IDeclaredType valueType = context.Type.GetScalarType();

            if (valueType == null)
            {
                throw new NotSupportedException();
            }

            ITypeHandler valueHandler = TypeHandlers.All.SingleOrDefault(h => h.CanHandle(context.WithType(valueType)));

            if (valueHandler == null)
            {
                throw new NotSupportedException();
            }

            var indexName  = context.Variables.Declare(Index);
            var lengthName = context.Variables.Declare(Length);
            var exists     = context.Variables.Declare(VariableKeys.NotNull);

            TypeHandlers.Boolean.HandleRead(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("var {0}", exists)
            });
            context.Builder.AppendFormat("if({0})", exists);
            context.Builder.Append("{");
            context.Builder.AppendFormat("var {0} = BitConverter.ToInt32(bytes, index);", lengthName);
            context.Builder.Append("index += sizeof(Int32);");
            context.Builder.AppendFormat("{0} = new {1}[{2}];", context.TypeOwnerName, valueType.GetPresentableName(context.PresentationLanguage), lengthName);
            context.Builder.AppendFormat("if({0} > 0)", lengthName);
            context.Builder.Append("{");
            context.Builder.AppendFormat("for(Int32 {0} = 0; {0} < {1}; {0}++)", indexName, lengthName);
            context.Builder.Append("{");
            valueHandler.HandleRead(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("{0}[{1}]", context.TypeOwnerName, indexName),
                Type          = valueType,
                TypeName      = valueType.GetPresentableName(context.PresentationLanguage),
                TypeOwner     = context.TypeOwner
            });
            context.Builder.Append("}}}");

            context.Variables.Dispose(Index);
            context.Variables.Dispose(Length);
        }
예제 #17
0
        public void HandleWrite(TypeHandlingContext context)
        {
            IDeclaredType valueType = context.Type.GetScalarType();

            if (valueType == null)
            {
                throw new NotSupportedException();
            }

            ITypeHandler valueHandler = TypeHandlers.All.SingleOrDefault(h => h.CanHandle(context.WithType(valueType)));

            if (valueHandler == null)
            {
                throw new NotSupportedException();
            }

            String indexName = context.Variables.Declare(Index);

            var exists = context.Variables.Declare(VariableKeys.NotNull);

            context.Builder.AppendFormat("var {0} = {1} != null;", exists, context.TypeOwnerName);
            TypeHandlers.Boolean.HandleWrite(new TypeHandlingContext(context)
            {
                TypeOwnerName = exists
            });
            context.Builder.AppendFormat("if({0})", exists);
            context.Builder.Append("{");
            TypeHandlers.Int32.HandleWrite(new TypeHandlingContext(context)
            {
                TypeName      = TypeHandlers.Int32.TypeName,
                TypeOwnerName = String.Format("{0}.Length", context.TypeOwnerName)
            });
            context.Builder.AppendFormat("if({0}.Length > 0)", context.TypeOwnerName);
            context.Builder.Append("{");
            context.Builder.AppendFormat("for(Int32 {0} = 0; {0} < {1}.Length; {0}++)", indexName, context.TypeOwnerName);
            context.Builder.Append("{");
            valueHandler.HandleWrite(new TypeHandlingContext(context)
            {
                TypeName      = valueType.GetPresentableName(context.PresentationLanguage),
                TypeOwnerName = String.Format("{0}[{1}]", context.TypeOwnerName, indexName)
            });
            context.Builder.Append("}}}");
            context.Variables.Dispose(Index);
        }
예제 #18
0
        public void HandleGetSize(TypeHandlingContext context)
        {
            var valueType    = context.Type.GetGenericUnderlyingType(_listTypeElement);
            var valueHandler = TypeHandlers.All.First(h => h.CanHandle(context.WithType(valueType)));

            TypeHandlers.Boolean.HandleGetSize(context);
            context.Builder.AppendFormat("if({0} != null)", context.TypeOwnerName);
            context.Builder.Append("{");
            TypeHandlers.Int32.HandleGetSize(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("{0}.Length", context.TypeOwnerName)
            });

            if (valueHandler.BinarySizePersistent)
            {
                var valueSize = context.Variables.Declare(VariableKeys.ValueSize);

                context.Builder.AppendFormat("var {0} = 0;", valueSize);
                valueHandler.HandleGetSize(new TypeHandlingContext(context)
                {
                    SizeVariableKey = VariableKeys.ValueSize
                });

                context.Builder.AppendFormat("{0} += {1}*{2}.Count;", context.GetSizeVariableName(), valueSize, context.TypeOwnerName);
            }
            else
            {
                var i = context.Variables.Declare("i");
                var v = context.Variables.Declare("v");
                context.Builder.AppendFormat("for(Int32 {0} = 0; {0} < {1}.Count; {0}++)", i, context.TypeOwnerName);
                context.Builder.Append("{");
                context.Builder.AppendFormat("var {0} = {1}[{2}];", v, context.TypeOwnerName, i);
                valueHandler.HandleGetSize(new TypeHandlingContext(context)
                {
                    TypeOwnerName = v
                });
                context.Builder.Append("}");
                context.Variables.Dispose("v");
                context.Variables.Dispose("i");
            }
            context.Builder.Append("}");
        }
예제 #19
0
        public void HandleWrite(TypeHandlingContext context)
        {
            IEnum enumType = context.Type.GetEnumType();

            if (enumType == null)
            {
                throw new NotSupportedException();
            }

            IType baseType = enumType.GetUnderlyingType();
            IEnumBaseTypeHandler handler =
                TypeHandlers.EnumBaseTypeHandlers.SingleOrDefault(h => h.CanHandle(context.WithType(baseType)));

            if (handler == null)
            {
                throw new NotImplementedException();
            }

            handler.HandleEnumWrite(context.TypeOwner, context.Builder, context.Args);
        }
        private static void Generate(CSharpGeneratorContext context,
                                     IMethodDeclaration declaration,
                                     IList <GeneratorDeclaredElement <ITypeOwner> > elements,
                                     CSharpElementFactory factory)
        {
            var owner = (IParametersOwner)declaration.DeclaredElement;

            if (owner == null)
            {
                return;
            }

            var ctx = new TypeHandlingContext(context);

            var size = ctx.GetSizeVariableName();

            ctx.Builder.Append("{");
            ctx.Builder.AppendFormat("var {0} = 0;", size);
            if (elements.Count > 0)
            {
                foreach (var element in elements)
                {
                    ctx.Resolve(element.DeclaredElement);

                    ITypeHandler handler = TypeHandlers.All.SingleOrDefault(h => h.CanHandle(ctx));
                    if (handler != null)
                    {
                        handler.HandleGetSize(ctx);
                    }
                }
            }
            ctx.Builder.AppendFormat("return {0};", size);
            ctx.Builder.Append("}");

            IBlock body = factory.CreateBlock(ctx.Builder.ToString(), ctx.Args.ToArray());

            declaration.SetBody(body);
        }
예제 #21
0
        public void HandleRead(TypeHandlingContext context)
        {
            var valueType    = context.Type.GetGenericUnderlyingType(_listTypeElement);
            var valueHandler = TypeHandlers.All.First(h => h.CanHandle(context.WithType(valueType)));
            var count        = context.Variables.Declare("count");
            var existed      = context.Variables.Declare("existed");

            context.Builder.Append("{");
            TypeHandlers.Boolean.HandleRead(new TypeHandlingContext(context)
            {
                TypeOwnerName = "var " + existed
            });
            context.Builder.AppendFormat("if({0})", existed);
            context.Builder.Append("{");
            TypeHandlers.Int32.HandleRead(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("var {0} ", count)
            });
            context.Builder.AppendFormat("if({0} > 0)", count);
            context.Builder.Append("{");
            context.Builder.AppendFormat("{0} = new List<{2}>({1});", context.TypeOwnerName, count, valueType);
            context.Builder.Append("} else {");
            context.Builder.AppendFormat("{0} = new List<{1}>();", context.TypeOwnerName, valueType);
            context.Builder.Append("}");
            context.Builder.AppendFormat("for(Int32 i = 0; i < {0}; i++)", count);
            context.Builder.Append("{");
            context.Builder.AppendFormat("var {0} = default({1});", VariableKeys.Value, valueType.GetPresentableName(context.PresentationLanguage));
            valueHandler.HandleRead(new TypeHandlingContext(context)
            {
                TypeOwnerName = VariableKeys.Value,
                TypeName      = valueType.GetPresentableName(context.PresentationLanguage)
            });
            context.Builder.AppendFormat("{0}.Add(value);", context.TypeOwnerName);
            context.Builder.Append("}}}");
            context.Variables.Dispose("count");
            context.Variables.Dispose("existed");
        }
        protected override void Generate(CSharpGeneratorContext context,
                                         IMethodDeclaration declaration,
                                         IList <GeneratorDeclaredElement <ITypeOwner> > elements,
                                         CSharpElementFactory factory)
        {
            var owner = (IParametersOwner)declaration.DeclaredElement;

            if (owner == null)
            {
                return;
            }

            var ctx = new TypeHandlingContext(context);

            ctx.Builder.Append("{");
            ctx.Builder.Append("var index = startIndex;");
            ctx.Builder.Append("Byte[] tmp;");
            if (elements.Count > 0)
            {
                foreach (var element in elements)
                {
                    ctx.Resolve(element.DeclaredElement);

                    ITypeHandler handler = TypeHandlers.All.SingleOrDefault(h => h.CanHandle(ctx));
                    if (handler != null)
                    {
                        handler.HandleRead(ctx);
                    }
                }
            }
            ctx.Builder.Append("return index;");
            ctx.Builder.Append("}");

            IBlock body = factory.CreateBlock(ctx.Builder.ToString(), ctx.Args.ToArray());

            declaration.SetBody(body);
        }
예제 #23
0
        public void HandleWrite(TypeHandlingContext context)
        {
            var exists = context.Variables.Declare(VariableKeys.NotNull);

            context.Builder.AppendFormat("var {0} = {1} != null;", exists, context.TypeOwnerName);
            TypeHandlers.Boolean.HandleWrite(new TypeHandlingContext(context)
            {
                TypeOwnerName = exists
            });

            context.Builder.AppendFormat("if({0})", exists);
            context.Builder.Append("{");
            TypeHandlers.Int32.HandleWrite(new TypeHandlingContext(context)
            {
                TypeOwnerName = String.Format("{0}.Length", context.TypeOwnerName)
            });
            context.Builder.AppendFormat("if({0}.Length > 0)", context.TypeOwnerName);
            context.Builder.Append("{");
            context.Builder.AppendFormat("tmp = System.Text.Encoding.UTF8.GetBytes({0});", context.TypeOwnerName);
            context.Builder.Append("Array.Copy(tmp, 0, bytes, index, tmp.Length);");
            context.Builder.Append("index += tmp.Length;");
            context.Builder.Append("}");
            context.Builder.Append("}");
        }
 public void HandleGetSize(TypeHandlingContext context)
 {
     context.Builder.AppendFormat("{0} += sizeof(Boolean);", context.GetSizeVariableName());
 }
 public void HandleRead(TypeHandlingContext context)
 {
     context.Builder.AppendFormat("{0} = BitConverter.ToBoolean(bytes, index);", context.TypeOwnerName);
     context.Builder.AppendFormat("index += sizeof(Boolean);");
 }
 public void HandleWrite(TypeHandlingContext context)
 {
     context.Builder.AppendFormat("tmp = BitConverter.GetBytes({0});", context.TypeOwnerName);
     context.Builder.Append("Array.Copy(tmp, 0, bytes, index, tmp.Length);");
     context.Builder.Append("index += tmp.Length;");
 }
 public bool CanHandle(TypeHandlingContext context)
 {
     return(context.Type.IsBool());
 }
 public void HandleGetSize(TypeHandlingContext context)
 {
     context.Builder.AppendFormat("{1} += sizeof({0});", _typeName, context.GetSizeVariableName());
 }
예제 #29
0
        public bool CanHandle(TypeHandlingContext context)
        {
            var valueType = context.Type.GetGenericUnderlyingType(_listTypeElement);

            return(valueType != null && TypeHandlers.All.Any(h => h.CanHandle(context.WithType(valueType))));
        }
 public void HandleRead(TypeHandlingContext context)
 {
     context.Builder.AppendFormat("{0} = BitConverter.To{1}(bytes, index);", context.TypeOwnerName, _typeName);
     context.Builder.AppendFormat("index += sizeof({0});", _typeName);
 }