vendor/github.com/syndtr/goleveldb/leveldb/options.go

   1 // Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
   2 // All rights reserved.
   3 //
   4 // Use of this source code is governed by a BSD-style license that can be
   5 // found in the LICENSE file.
   6
   7 package leveldb
   8
   9 import (
  10         "github.com/syndtr/goleveldb/leveldb/filter"
  11         "github.com/syndtr/goleveldb/leveldb/opt"
  12 )
  13
  14 func dupOptions(o *opt.Options) *opt.Options {
  15         newo := &opt.Options{}
  16         if o != nil {
  17                 *newo = *o
  18         }
  19         if newo.Strict == 0 {
  20                 newo.Strict = opt.DefaultStrict
  21         }
  22         return newo
  23 }
  24
  25 func (s *session) setOptions(o *opt.Options) {
  26         no := dupOptions(o)
  27         // Alternative filters.
  28         if filters := o.GetAltFilters(); len(filters) > 0 {
  29                 no.AltFilters = make([]filter.Filter, len(filters))
  30                 for i, filter := range filters {
  31                         no.AltFilters[i] = &iFilter{filter}
  32                 }
  33         }
  34         // Comparer.
  35         s.icmp = &iComparer{o.GetComparer()}
  36         no.Comparer = s.icmp
  37         // Filter.
  38         if filter := o.GetFilter(); filter != nil {
  39                 no.Filter = &iFilter{filter}
  40         }
  41
  42         s.o = &cachedOptions{Options: no}
  43         s.o.cache()
  44 }
  45
  46 const optCachedLevel = 7
  47
  48 type cachedOptions struct {
  49         *opt.Options
  50
  51         compactionExpandLimit []int
  52         compactionGPOverlaps  []int
  53         compactionSourceLimit []int
  54         compactionTableSize   []int
  55         compactionTotalSize   []int64
  56 }
  57
  58 func (co *cachedOptions) cache() {
  59         co.compactionExpandLimit = make([]int, optCachedLevel)
  60         co.compactionGPOverlaps = make([]int, optCachedLevel)
  61         co.compactionSourceLimit = make([]int, optCachedLevel)
  62         co.compactionTableSize = make([]int, optCachedLevel)
  63         co.compactionTotalSize = make([]int64, optCachedLevel)
  64
  65         for level := 0; level < optCachedLevel; level++ {
  66                 co.compactionExpandLimit[level] = co.Options.GetCompactionExpandLimit(level)
  67                 co.compactionGPOverlaps[level] = co.Options.GetCompactionGPOverlaps(level)
  68                 co.compactionSourceLimit[level] = co.Options.GetCompactionSourceLimit(level)
  69                 co.compactionTableSize[level] = co.Options.GetCompactionTableSize(level)
  70                 co.compactionTotalSize[level] = co.Options.GetCompactionTotalSize(level)
  71         }
  72 }
  73
  74 func (co *cachedOptions) GetCompactionExpandLimit(level int) int {
  75         if level < optCachedLevel {
  76                 return co.compactionExpandLimit[level]
  77         }
  78         return co.Options.GetCompactionExpandLimit(level)
  79 }
  80
  81 func (co *cachedOptions) GetCompactionGPOverlaps(level int) int {
  82         if level < optCachedLevel {
  83                 return co.compactionGPOverlaps[level]
  84         }
  85         return co.Options.GetCompactionGPOverlaps(level)
  86 }
  87
  88 func (co *cachedOptions) GetCompactionSourceLimit(level int) int {
  89         if level < optCachedLevel {
  90                 return co.compactionSourceLimit[level]
  91         }
  92         return co.Options.GetCompactionSourceLimit(level)
  93 }
  94
  95 func (co *cachedOptions) GetCompactionTableSize(level int) int {
  96         if level < optCachedLevel {
  97                 return co.compactionTableSize[level]
  98         }
  99         return co.Options.GetCompactionTableSize(level)
 100 }
 101
 102 func (co *cachedOptions) GetCompactionTotalSize(level int) int64 {
 103         if level < optCachedLevel {
 104                 return co.compactionTotalSize[level]
 105         }
 106         return co.Options.GetCompactionTotalSize(level)
 107 }