Exemple #1
0
        /// <summary>
        /// 获取类型信息
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private Xml.Node get(Type type)
        {
            if (type != null)
            {
                Xml.Node node;
                if (typeLock.TryGetValue(type, out node))
                {
                    return(node);
                }

                HashString typeName;
                AutoCSer.Memory.Pointer buffer = UnmanagedPool.Default.GetPointer();
                try
                {
                    using (typeNameStream)
                    {
                        typeNameStream.Reset(ref buffer);
                        AutoCSer.Extensions.TypeExtensionCodeGenerator.NameBuilder nameBuilder = new AutoCSer.Extensions.TypeExtensionCodeGenerator.NameBuilder {
                            NameStream = typeNameStream, IsXml = true
                        };
                        nameBuilder.Xml(type);
                        typeName = typeNameStream.ToString();
                    }
                }
                finally { UnmanagedPool.Default.PushOnly(ref buffer); }
                if (types.TryGetValue(typeName, out node))
                {
                    types.Remove(typeName);
                }
                typeLock.Set(type, node);
                return(node);
            }
            return(default(Xml.Node));
        }
Exemple #2
0
 /// <summary>
 /// 获取属性信息
 /// </summary>
 /// <param name="property"></param>
 /// <returns></returns>
 private Xml.Node get(PropertyInfo property)
 {
     if (property != null)
     {
         HashString propertyName;
         AutoCSer.Memory.Pointer buffer = UnmanagedPool.Default.GetPointer();
         try
         {
             using (propertyNameStream)
             {
                 propertyNameStream.Reset(ref buffer);
                 AutoCSer.Extensions.TypeExtensionCodeGenerator.NameBuilder nameBuilder = new AutoCSer.Extensions.TypeExtensionCodeGenerator.NameBuilder {
                     NameStream = propertyNameStream, IsXml = true
                 };
                 nameBuilder.Xml(property.DeclaringType);
                 propertyNameStream.Write('.');
                 propertyNameStream.SimpleWrite(property.Name);
                 propertyName = propertyNameStream.ToString();
             }
         }
         finally { UnmanagedPool.Default.PushOnly(ref buffer); }
         Xml.Node node;
         properties.TryGetValue(propertyName, out node);
         return(node);
     }
     return(default(Xml.Node));
 }
Exemple #3
0
 /// <summary>
 /// 获取字段信息
 /// </summary>
 /// <param name="field"></param>
 /// <returns></returns>
 private Xml.Node get(FieldInfo field)
 {
     if (field != null)
     {
         HashString fieldName;
         AutoCSer.Memory.Pointer buffer = UnmanagedPool.Default.GetPointer();
         try
         {
             using (fieldNameStream)
             {
                 fieldNameStream.Reset(ref buffer);
                 AutoCSer.Extensions.TypeExtensionCodeGenerator.NameBuilder nameBuilder = new AutoCSer.Extensions.TypeExtensionCodeGenerator.NameBuilder {
                     NameStream = fieldNameStream, IsXml = true
                 };
                 nameBuilder.Xml(field.DeclaringType);
                 fieldNameStream.Write('.');
                 fieldNameStream.SimpleWrite(field.Name);
                 fieldName = fieldNameStream.ToString();
             }
         }
         finally { UnmanagedPool.Default.PushOnly(ref buffer); }
         Xml.Node node;
         fields.TryGetValue(fieldName, out node);
         return(node);
     }
     return(default(Xml.Node));
 }
Exemple #4
0
 /// <summary>
 /// 获取类型名称
 /// </summary>
 /// <param name="type">类型</param>
 /// <returns>类型名称</returns>
 public unsafe string GetName(Type type)
 {
     if (type.IsArray)
     {
         AutoCSer.Memory.Pointer buffer = UnmanagedPool.Tiny.GetPointer();
         try
         {
             using (NameStream = new CharStream(ref buffer))
             {
                 new AutoCSer.Reflection.TypeNameBuilder {
                     NameStream = NameStream
                 }.Array(type, false);
                 return(NameStream.ToString());
             }
         }
         finally { UnmanagedPool.Tiny.PushOnly(ref buffer); }
     }
     if (type.IsGenericType)
     {
         AutoCSer.Memory.Pointer buffer = UnmanagedPool.Tiny.GetPointer();
         try
         {
             using (NameStream = new CharStream(ref buffer))
             {
                 new AutoCSer.Reflection.TypeNameBuilder {
                     NameStream = NameStream
                 }.GenericName(type);
                 return(NameStream.ToString());
             }
         }
         finally { UnmanagedPool.Tiny.PushOnly(ref buffer); }
     }
     return(type.Name);
 }
Exemple #5
0
 /// <summary>
 /// ASCII字节搜索器
 /// </summary>
 /// <param name="data">数据起始位置</param>
 internal ByteSearcher(ref AutoCSer.Memory.Pointer data)
 {
     if (data.Data == null)
     {
         State     = bytes = null;
         tableType = 0;
     }
     else
     {
         int stateCount = *data.Int;
         State = data.Byte + sizeof(int);
         bytes = State + stateCount * 3 * sizeof(int);
         if (stateCount < 256)
         {
             tableType = 0;
         }
         else if (stateCount < 65536)
         {
             tableType = 1;
         }
         else
         {
             tableType = 2;
         }
     }
 }
Exemple #6
0
 internal bool ResponsePage(ref AutoCSer.Memory.Pointer buffer, ref AutoCSer.Memory.Pointer encodeBuffer)
 {
     if (ResponseStream == null)
     {
         ResponseStream = new UnmanagedStream(default(AutoCSer.Memory.Pointer));
     }
     buffer = UnmanagedPool.Default.GetPointer();
     ResponseStream.Reset(ref buffer);
     using (ResponseStream)
     {
         if (EncodeStream == null)
         {
             EncodeStream = new UnmanagedStream(default(AutoCSer.Memory.Pointer));
         }
         encodeBuffer = UnmanagedPool.Default.GetPointer();
         EncodeStream.Reset(ref encodeBuffer);
         using (EncodeStream)
         {
             Response bodyResponse = new Response {
                 Stream = ResponseStream, EncodeStream = EncodeStream, Encoding = DomainServer.ResponseEncoding
             };
             if (page(ref bodyResponse))
             {
                 HttpResponse.SetBody(ResponseStream);
                 return(true);
             }
         }
     }
     return(false);
 }
Exemple #7
0
        /// <summary>
        /// 重建数据
        /// </summary>
        protected void create()
        {
            int heapIndex = Array.Length, newCount = heapIndex << 1, newHeapSize = newCount * sizeof(int);

            KeyValue <keyType, valueType>[] newArray = new KeyValue <keyType, valueType> [newCount];
            AutoCSer.Memory.Pointer         newHeap = isStaticUnmanaged ? Unmanaged.GetStaticPointer(newHeapSize, false) : Unmanaged.GetPointer(newHeapSize, false), oldHeap = Heap;
            int *newHeapFixed = newHeap.Int;

            Array.CopyTo(newArray, 0);
            AutoCSer.Memory.Common.CopyNotNull(Heap.Byte, newHeapFixed, newHeapSize >> 1);
            do
            {
                --newCount;
                newHeapFixed[newCount] = newCount;
            }while (newCount != heapIndex);
            Array = newArray;
            Heap  = newHeap;
            if (isStaticUnmanaged)
            {
                Unmanaged.FreeStatic(ref oldHeap);
            }
            else
            {
                Unmanaged.Free(ref oldHeap);
            }
        }
Exemple #8
0
        /// <summary>
        /// 获取解压数据
        /// </summary>
        /// <returns>解压数据</returns>
        internal byte[] Get()
        {
            AutoCSer.SubBuffer.PoolBufferFull buffer = default(AutoCSer.SubBuffer.PoolBufferFull);
            AutoCSer.Memory.Pointer           data   = UnmanagedPool.Default.GetPointer();
            try
            {
                AutoCSer.SubBuffer.Pool.GetBuffer(ref buffer, bufferSize);
                using (dataStream = new UnmanagedStream(ref data))
                {
                    fixed(byte *bufferFixed = buffer.GetFixedBuffer())
                    {
                        byte *start = bufferFixed + buffer.StartIndex;

                        do
                        {
                            int length = CompressStream.Read(buffer.Buffer, buffer.StartIndex, bufferSize);
                            if (length == 0)
                            {
                                break;
                            }
                            dataStream.WriteNotEmpty(start, length);
                        }while (true);
                    }
                    return(dataStream.Data.GetArray());
                }
            }
            finally
            {
                UnmanagedPool.Default.PushOnly(ref data);
                buffer.Free();
            }
        }
Exemple #9
0
 /// <summary>
 /// 创建客户端命令数据
 /// </summary>
 /// <param name="commandData"></param>
 /// <param name="commands"></param>
 /// <returns></returns>
 internal bool CreateCommandData(ref AutoCSer.Memory.Pointer commandData, ref MemoryMap commands)
 {
     if (this.commandData.Data != null)
     {
         commandData = Unmanaged.GetPointer8(this.commandData.ByteSize, true);
         commands    = new MemoryMap(commandData.Data);
         commands.Set(TcpServer.Server.CheckCommandIndex);
         //if (isCustomData) commands.Set(TcpServer.Server.CustomDataCommandIndex);
         if (isKeepCallback)
         {
             commands.Set(TcpServer.Server.CancelKeepCommandIndex);
         }
         if (isMergeCommand)
         {
             commands.Set(TcpServer.Server.MergeCommandIndex);
         }
         //if (Attribute.IsRemoteExpression)
         //{
         //    commands.Set(TcpServer.Server.RemoteExpressionNodeIdCommandIndex);
         //    commands.Set(TcpServer.Server.RemoteExpressionCommandIndex);
         //}
         return(true);
     }
     return(false);
 }
Exemple #10
0
 /// <summary>
 /// 清除数据
 /// </summary>
 internal void Clear()
 {
     if (Array.Length == defaultArrayLength)
     {
         int *heapFixed = Heap.Int;
         if (*heapFixed != 0)
         {
             reset(heapFixed);
             System.Array.Clear(Array, 0, Array.Length);
         }
     }
     else
     {
         KeyValue <keyType, valueType>[] newArray = new KeyValue <keyType, valueType> [defaultArrayLength];
         AutoCSer.Memory.Pointer         newHeap = isStaticUnmanaged ? Unmanaged.GetStaticPointer(defaultArrayLength * sizeof(int), false) : Unmanaged.GetPointer(defaultArrayLength * sizeof(int), false), oldHeap = Heap;
         reset(newHeap.Int);
         Array = newArray;
         Heap  = newHeap;
         if (isStaticUnmanaged)
         {
             Unmanaged.FreeStatic(ref oldHeap);
         }
         else
         {
             Unmanaged.Free(ref oldHeap);
         }
     }
 }
Exemple #11
0
        /// <summary>
        /// 解析多值集合
        /// </summary>
        private void getValues()
        {
            HashSet <SubString> hashSet = HashSetCreator.CreateSubString();

            foreach (SubString value in this.value.split(','))
            {
                if (value.Length != 0)
                {
                    hashSet.Add(value);
                }
            }
            this.value = null;
            if (hashSet.Count > 1)
            {
                valueData = AutoCSer.StateSearcher.CharBuilder.Create(hashSet.getArray(value => (string)value), false);
                values    = new StateSearcher.CharSearcher(ref valueData);
            }
            else
            {
                foreach (string value in hashSet)
                {
                    this.value = value;
                }
            }
        }
Exemple #12
0
        /// <summary>
        /// 获取数据库连接信息
        /// </summary>
        /// <param name="isPool">是否启用数据库连接池</param>
        /// <returns>数据库连接信息</returns>
        public unsafe Sql.Connection Get(bool isPool = false)
        {
            ProviderAttribute provider = EnumAttribute <Provider, ProviderAttribute> .Array((byte)Provider);

            AutoCSer.Memory.Pointer buffer = UnmanagedPool.Default.GetPointer();
            try
            {
                using (CharStream connectionStream = new CharStream(ref buffer))
                {
                    connectionStream.SimpleWrite("Provider=");
                    connectionStream.Write(provider.Name);
                    connectionStream.SimpleWrite(";Data Source=");
                    connectionStream.Write(DataSource);
                    if (Password != null)
                    {
                        connectionStream.Write(";Database Password="******";Extended Properties='");
                    connectionStream.Write(provider.Excel);
                    connectionStream.Write(IsTitleColumn ? ";HDR=YES;IMEX=" : ";HDR=NO;IMEX=");
                    AutoCSer.Extensions.NumberExtension.ToString((byte)Intermixed, connectionStream);
                    connectionStream.Write('\'');
                    return(new Sql.Connection {
                        Type = ClientKind.Excel, ConnectionString = connectionStream.ToString(), IsPool = isPool
                    });
                }
            }
            finally { UnmanagedPool.Default.Push(ref buffer); }
        }
Exemple #13
0
 /// <summary>
 /// 数组模拟最小堆
 /// </summary>
 /// <param name="isStaticUnmanaged">是否固定内存申请</param>
 internal ArrayHeap(bool isStaticUnmanaged = false)
 {
     Array = new KeyValue <keyType, valueType> [defaultArrayLength];
     this.isStaticUnmanaged = isStaticUnmanaged;
     Heap = isStaticUnmanaged ? Unmanaged.GetStaticPointer(defaultArrayLength * sizeof(int), false) : Unmanaged.GetPointer(defaultArrayLength * sizeof(int), false);
     reset(Heap.Int);
 }
Exemple #14
0
 /// <summary>
 /// 连接字符串集合
 /// </summary>
 /// <param name="array"></param>
 /// <param name="join"></param>
 /// <param name="nullString">null 值替换字符串</param>
 /// <returns></returns>
 public unsafe static string JoinString(ref SubArray <valueType> array, char join, string nullString = null)
 {
     if (nullString == null)
     {
         nullString = string.Empty;
     }
     if (array.Length == 0)
     {
         return(nullString);
     }
     if (NumberJoinChar == null)
     {
         return(subArrayJoinChar(array, join, nullString));
     }
     AutoCSer.Memory.Pointer buffer = UnmanagedPool.Default.GetPointer();
     try
     {
         using (CharStream stream = new CharStream(ref buffer))
         {
             NumberJoinChar(stream, array.Array, array.Start, array.Length, join, nullString);
             return(new string(stream.Char, 0, stream.Length));
         }
     }
     finally { UnmanagedPool.Default.PushOnly(ref buffer); }
 }
Exemple #15
0
 /// <summary>
 /// 域名搜索
 /// </summary>
 /// <param name="domains">域名信息集合</param>
 /// <param name="servers">域名服务信息集合</param>
 private DomainSearchData(byte[][] domains, DomainServer[] servers)
 {
     this.domains = domains;
     this.servers = servers;
     data         = AutoCSer.StateSearcher.ByteBuilder.Create(domains, false);
     searcher     = new DomainSearcher(ref data);
 }
Exemple #16
0
 internal void ResponseLocationPathAjax(ref AutoCSer.Memory.Pointer buffer)
 {
     buffer = UnmanagedPool.Default.GetPointer();
     AjaxStream.Reset(ref buffer);
     using (AjaxStream)
     {
         SetJsContentType();
         bool isCallBack = ResponseAjaxCallBack(AjaxStream);
         if (LocationPath.ErrorPath == null)
         {
             AjaxStream.Write(@"{""LocationPath"":");
             AjaxStream.WriteJson(LocationPath.LocationPath ?? notFound404);
         }
         else
         {
             AjaxStream.Write(@"{""ErrorPath"":");
             AjaxStream.WriteJson(LocationPath.ErrorPath);
             if (LocationPath.ReturnPath != null)
             {
                 AjaxStream.Write(@",""ReturnPath"":");
                 AjaxStream.WriteJson(LocationPath.ReturnPath);
             }
         }
         AjaxStream.Write('}');
         if (isCallBack)
         {
             AjaxStream.Write(')');
         }
         PageResponse.SetBody(AjaxStream, ref DomainServer.ResponseEncoding);
     }
 }
Exemple #17
0
 public bool CreateResponse(ref AutoCSer.Memory.Pointer buffer, ref CallResponse response)
 {
     if (CreateResponse(ref buffer))
     {
         response = CallResponse;
         return(true);
     }
     return(false);
 }
Exemple #18
0
        /// <summary>
        /// 增加数据
        /// </summary>
        /// <param name="value">新增的数据</param>
        private void onInserted(valueType value)
        {
            int *intCounts = counts.Int;
            int  identity  = GetKey(value);

            if (identity >= size)
            {
                int newLength = int.MaxValue - 1, oldLength = size;
                if ((identity & 0x40000000) == 0 && oldLength != 0x40000000)
                {
                    for (newLength = oldLength << 1; newLength <= identity; newLength <<= 1)
                    {
                        ;
                    }
                }
                Array.ToSize(newLength);
                AutoCSer.Memory.Pointer newCounts = Unmanaged.GetPointer8(newLength * sizeof(int), true);
                try
                {
                    AutoCSer.Memory.Common.CopyNotNull(intCounts, newCounts.Int, size * sizeof(int));
                    Unmanaged.Free(ref counts);
                    counts = newCounts;
                    size   = newLength;
                    newCounts.SetNull();

                    int index = oldLength, count = (intCounts = counts.Int)[--index];
                    for (int step = 1; (index -= step) != 0; step <<= 1)
                    {
                        count += intCounts[index];
                    }
                    intCounts[oldLength] = count;
                }
                catch (Exception error)
                {
                    SqlTable.Log.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer);
                }
                finally { Unmanaged.Free(ref newCounts); }
            }
            valueType newValue = AutoCSer.Metadata.DefaultConstructor <valueType> .Constructor();

            AutoCSer.MemberCopy.Copyer <modelType> .Copy(newValue, value, MemberMap);

            setMemberCacheAndValue(newValue);
            Array[identity] = newValue;
            for (uint index = (uint)identity, countStep = 1, length = (uint)size; index <= length; countStep <<= 1)
            {
                ++intCounts[index];
                while ((index & countStep) == 0)
                {
                    countStep <<= 1;
                }
                index += countStep;
            }
            ++Count;
            callOnInserted(newValue);
        }
Exemple #19
0
 /// <summary>
 /// 释放资源
 /// </summary>
 public void Dispose()
 {
     if (CharTypeData.Data != DefaultCharTypeData.Data)
     {
         Unmanaged.Free(ref CharTypeData);
         CharTypeData = new AutoCSer.Memory.Pointer {
             Data = DefaultCharTypeData.Data
         };
     }
 }
Exemple #20
0
 /// <summary>
 /// AJAX 响应输出
 /// </summary>
 /// <typeparam name="valueType">输出数据类型</typeparam>
 /// <param name="value">输出数据</param>
 internal unsafe void Response <valueType>(ref valueType value) where valueType : struct
 {
     AutoCSer.Memory.Pointer buffer = UnmanagedPool.Default.GetPointer();
     try
     {
         Response(ref value, ref buffer);
         SocketResponse(ref PageResponse);
     }
     finally { UnmanagedPool.Default.PushOnly(ref buffer); }
 }
 /// <summary>
 /// 释放资源
 /// </summary>
 public override void Dispose()
 {
     base.Dispose();
     if (CharTypeData.Data != StringTrieGraph.DefaultCharTypeData.Data)
     {
         Unmanaged.Free(ref CharTypeData);
         CharTypeData = new AutoCSer.Memory.Pointer {
             Data = StringTrieGraph.DefaultCharTypeData.Data
         };
     }
 }
Exemple #22
0
            protected void checkMatchMap()
            {
                int matchMapSize = (formatLength + 7) >> 3, matchMapDataSize = Math.Max((int)((uint)matchMapSize).UpToPower2(), 8);

                if (matchMapData.ByteSize < matchMapDataSize)
                {
                    Unmanaged.Free(ref matchMapData);
                    matchMapData = Unmanaged.GetPointer(matchMapDataSize, false);
                }
                matchMap.Set(matchMapData.ULong, (matchMapSize + 7) >> 3);
            }
Exemple #23
0
 /// <summary>
 /// 输出缓冲区池测试
 /// </summary>
 /// <param name="left"></param>
 /// <param name="right"></param>
 public void AddBuffer(int left, int right)
 {
     AutoCSer.Memory.Pointer buffer = UnmanagedPool.Tiny.GetPointer();
     try
     {
         if (CreateResponse(ref buffer))
         {
             Response(left + right);
             RepsonseEnd();
         }
     }
     finally { UnmanagedPool.Tiny.Push(ref buffer); }
 }
Exemple #24
0
            /// <summary>
            /// 获取文本的匹配索引位置
            /// </summary>
            /// <param name="key">数据关键字</param>
            /// <param name="text">数据文本</param>
            /// <param name="maxLength">最大长度</param>
            /// <returns>匹配索引位置集合</returns>
            public unsafe KeyValue <int, int>[] FormatTextIndexs(ref keyType key, ref SubString text, int maxLength)
            {
                int size = ((text.Length + 63) >> 3) & (int.MaxValue - 7);

                if (getResultIndexsMapBuffer.ByteSize < size)
                {
                    Unmanaged.Free(ref getResultIndexsMapBuffer);
                    getResultIndexsMapBuffer = Unmanaged.GetPointer(size, true);
                }
                int count = searcher.FormatTextIndexs(ref key, ref text, ref queryResult, maxLength, ref resultIndexs, ref getResultIndexsMapBuffer);

                return(new LeftArray <KeyValue <int, int> >(count, resultIndexs).GetArray());
            }
Exemple #25
0
 internal void Response(ref AutoCSer.Memory.Pointer buffer)
 {
     AjaxStream.Reset(ref buffer);
     using (AjaxStream)
     {
         SetJsContentType();
         if (ResponseAjaxCallBack(AjaxStream))
         {
             AjaxStream.Write(')');
         }
         PageResponse.SetBody(AjaxStream, ref DomainServer.ResponseEncoding);
     }
 }
Exemple #26
0
        /// <summary>
        /// 获取查询信息
        /// </summary>
        /// <typeparam name="valueType">对象类型</typeparam>
        /// <typeparam name="modelType">模型类型</typeparam>
        /// <param name="sqlTool">SQL操作工具</param>
        /// <param name="createQuery"></param>
        /// <param name="query">查询信息</param>
        /// <returns>对象集合</returns>
        internal override void GetSelectQuery <valueType, modelType>
            (Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query)
        {
            CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);

            if (sqlStream == null)
            {
                sqlStream = new CharStream(default(AutoCSer.Memory.Pointer));
            }
            AutoCSer.Memory.Pointer buffer = default(AutoCSer.Memory.Pointer);
            try
            {
                buffer = UnmanagedPool.Default.GetPointer();
                sqlStream.Reset(ref buffer);
                if ((createQuery.GetCount | query.SkipCount) != 0)
                {
                    sqlStream.Write("select * from(");
                }
                sqlStream.Write("select ");
                if (query.MemberMap != null)
                {
                    DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap, constantConverter);
                }
                else
                {
                    sqlStream.Write('*');
                }
                sqlStream.Write(" from ");
                sqlStream.Write(sqlTool.TableName);
                sqlStream.Write(' ');
                createQuery.WriteWhere(sqlTool, sqlStream, ref query);
                createQuery.WriteOrder(sqlTool, sqlStream, constantConverter, ref query);
                if ((createQuery.GetCount | query.SkipCount) != 0)
                {
                    sqlStream.Write(")where rownum between ");
                    AutoCSer.Extensions.NumberExtension.ToString(query.SkipCount, sqlStream);
                    sqlStream.Write(" and ");
                    AutoCSer.Extensions.NumberExtension.ToString(createQuery.GetCount, sqlStream);
                    sqlStream.Write(" order by rownum asc");
                }
                query.Sql = sqlStream.ToString();
            }
            finally
            {
                UnmanagedPool.Default.Push(ref buffer);
                sqlStream.Dispose();
                Interlocked.Exchange(ref this.sqlStream, sqlStream);
            }
        }
Exemple #27
0
        /// <summary>
        /// 重新加载数据
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="query">查询信息</param>
        internal override void Reset(ref DbConnection connection, ref SelectQuery <modelType> query)
        {
            ReturnValue <LeftArray <valueType> > valueArray = SqlTable.SelectQueue(ref connection, ref query);

            if (valueArray.ReturnType == ReturnType.Success)
            {
                int maxIdentity = valueArray.Value.maxKey(value => GetKey(value), 0);
                if (memberGroup == 0)
                {
                    SqlTable.Identity64 = maxIdentity + baseIdentity;
                }
                int length = maxIdentity >= IdentityArray.ArraySize ? 1 << ((uint)maxIdentity).bits() : IdentityArray.ArraySize;
                IdentityArray <valueType> newValues = new IdentityArray <valueType>(length);
                AutoCSer.Memory.Pointer   newCounts = Unmanaged.GetPointer8(length * sizeof(int), true);
                try
                {
                    int *intCounts = newCounts.Int;
                    foreach (valueType value in valueArray.Value)
                    {
                        setMemberCacheAndValue(value);
                        int identity = GetKey(value);
                        newValues[identity] = value;
                        intCounts[identity] = 1;
                    }
                    for (int step = 2; step != length; step <<= 1)
                    {
                        for (int index = step, countStep = step >> 1; index != length; index += step)
                        {
                            intCounts[index] += intCounts[index - countStep];
                        }
                    }
                    Unmanaged.Free(ref counts);
                    this.Array = newValues;
                    counts     = newCounts;
                    size       = length;
                    Count      = valueArray.Value.Length;
                    newCounts.SetNull();
                }
                catch (Exception error)
                {
                    SqlTable.Log.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer);
                }
                finally { Unmanaged.Free(ref newCounts); }
            }
            else
            {
                SqlTable.Log.Fatal(typeof(valueType).fullName() + " 数据加载失败 " + valueArray.ReturnType.ToString(), LogLevel.Fatal | LogLevel.AutoCSer);
            }
        }
Exemple #28
0
 internal void Response <valueType>(ref valueType value, ref AutoCSer.Memory.Pointer buffer) where valueType : struct
 {
     AjaxStream.Reset(ref buffer);
     using (AjaxStream)
     {
         SetJsContentType();
         bool isCallBack = ResponseAjaxCallBack(AjaxStream);
         AutoCSer.JsonSerializer.Serialize(ref value, AjaxStream, JsonSerializeConfig);
         if (isCallBack)
         {
             AjaxStream.Write(')');
         }
         PageResponse.SetBody(AjaxStream, ref DomainServer.ResponseEncoding);
     }
 }
Exemple #29
0
 /// <summary>
 /// 对象转换JSON字符串
 /// </summary>
 /// <typeparam name="valueType">目标数据类型</typeparam>
 /// <param name="value">数据对象</param>
 /// <param name="config">配置参数</param>
 /// <returns>Json字符串</returns>
 private string serialize <valueType>(ref valueType value, SerializeConfig config)
 {
     Config = config ?? DefaultConfig;
     AutoCSer.Memory.Pointer buffer = UnmanagedPool.Default.GetPointer();
     try
     {
         CharStream.Reset(ref buffer);
         using (CharStream)
         {
             serialize(ref value);
             return(CharStream.ToString());
         }
     }
     finally { UnmanagedPool.Default.PushOnly(ref buffer); }
 }
Exemple #30
0
        /// <summary>
        /// 获取页面输出数据流
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        internal UnmanagedStream GetResponseStream(ref AutoCSer.Memory.Pointer buffer)
        {
            UnmanagedStream responseStream = Interlocked.Exchange(ref ResponseStream, null);

            if (responseStream == null)
            {
                responseStream = new UnmanagedStream(ref buffer);
            }
            else
            {
                responseStream.Reset(ref buffer);
            }
            CallResponse.Set(responseStream, ref DomainServer.ResponseEncoding);
            return(responseStream);
        }