Example #1
0
        private byte[] readblockdata(AllocationBlock ab)
        {
            byte[] data   = new byte[ab.datalength];
            long   offset = 0;
            int    len    = ab.datalength;
            int    dbsize = _BlockSize - _blockheader.Length - ab.keylen;

            ab.Blocks.ForEach(x =>
            {
                byte[] b = _datastore.ReadBlock(x);
                int c    = len;
                if (c > dbsize)
                {
                    c = dbsize;
                }
                Buffer.BlockCopy(b, _blockheader.Length + ab.keylen, data, (int)offset, c);
                offset += c;
                len    -= c;
            });
            if (ab.isCompressed)
            {
                data = MiniLZO.Decompress(data);
            }
            return(data);
        }
Example #2
0
        public long WriteObject(T key, object obj)
        {
            StorageItem <T> meta = new StorageItem <T>();

            meta.key = key;
            //meta.typename = fastJSON.Reflection.Instance.GetTypeAssemblyName(obj.GetType());//fastJSON
            meta.typename = Reflection.Instance.GetTypeAssemblyName(obj.GetType());

            byte[] data;
            if (_saveFormat == SF_FORMAT.BSON)
            {
                //data = fastBinaryJSON.BJSON.ToBJSON(obj);//fastBinaryJSON
                data = _bson.SerializeObject(obj);
            }
            else
            {
                //data = Helper.GetBytes(fastJSON.JSON.ToJSON(obj));//fastJSON
                data = Helper.GetBytes(_json.SerializeObject(obj));
            }
            //超过压缩最大值界限就开启压缩
            if (data.Length > (int)Global.CompressDocumentOverKiloBytes * _KILOBYTE)
            {
                meta.isCompressed = 1;
                data = MiniLZO.Compress(data); //MiniLZO
            }
            return(internalWriteData(meta, data, false));
        }
Example #3
0
        //public long WriteReplicationObject(T key, object obj)
        //{
        //    StorageItem<T> meta = new StorageItem<T>();
        //    meta.key = key;
        //    meta.isReplicated = true;
        //    meta.typename = fastJSON.Reflection.Instance.GetTypeAssemblyName(obj.GetType());//fastJSON
        //    byte[] data;
        //    if (_saveFormat == SF_FORMAT.BSON)
        //        data = fastBinaryJSON.BJSON.ToBJSON(obj);//fastBinaryJSON
        //    else
        //        data = Helper.GetBytes(fastJSON.JSON.ToJSON(obj));//fastJSON
        //    if (data.Length > (int)Global.CompressDocumentOverKiloBytes * _KILOBYTE)
        //    {
        //        meta.isCompressed = 1;
        //        data = MiniLZO.Compress(data);
        //    }
        //    return internalWriteData(meta, data, false);
        //}

        public long WriteData(T key, byte[] data)
        {
            StorageItem <T> meta = new StorageItem <T>();

            meta.key = key;

            if (data.Length > (int)Global.CompressDocumentOverKiloBytes * _KILOBYTE)
            {
                meta.isCompressed = 1;
                data = MiniLZO.Compress(data);
            }

            return(internalWriteData(meta, data, false));
        }
Example #4
0
        internal byte[] ReadBytes(long recnum, out StorageItem <T> meta)
        {
            meta = null;
            if (recnum >= _lastRecordNum)
            {
                return(null);
            }
            lock (_readlock)
            {
                long       off  = ComputeOffset(recnum);
                FileStream fs   = GetReadFileStreamWithSeek(off);
                byte[]     data = internalReadBytes(fs, out meta);

                if (meta.isCompressed > 0)
                {
                    data = MiniLZO.Decompress(data);
                }

                return(data);
            }
        }
Example #5
0
        private void SaveNew(string key, byte[] keybytes, object obj)
        {
            byte[]          data;
            AllocationBlock ab = new AllocationBlock();

            ab.key    = key;
            ab.keylen = (byte)keybytes.Length;

            //data = fastBinaryJSON.BJSON.ToBJSON(obj);//fastBinaryJSON
            data            = _bson.SerializeObject(obj);
            ab.isBinaryJSON = true;

            if (data.Length > (int)Global.CompressDocumentOverKiloBytes * _KILOBYTE)
            {
                ab.isCompressed = true;
                data            = MiniLZO.Compress(data);
            }
            ab.datalength = data.Length;

            int firstblock = internalSave(keybytes, data, ab);

            // save keys
            _keys.Set(key, firstblock);
        }