tidwall 6257ddba78 Faster point in polygon / GeoJSON updates
The big change is that the GeoJSON package has been completely
rewritten to fix a few of geometry calculation bugs, increase
performance, and to better follow the GeoJSON spec RFC 7946.

GeoJSON updates

- A LineString now requires at least two points.
- All json members, even foreign, now persist with the object.
- The bbox member persists too but is no longer used for geometry
  calculations. This is change in behavior. Previously Tile38 would
  treat the bbox as the object's physical rectangle.
- Corrections to geometry intersects and within calculations.

Faster spatial queries

- The performance of Point-in-polygon and object intersect operations
  are greatly improved for complex polygons and line strings. It went
  from O(n) to roughly O(log n).
- The same for all collection types with many children, including
  FeatureCollection, GeometryCollection, MultiPoint, MultiLineString,
  and MultiPolygon.

Codebase changes

- The pkg directory has been renamed to internal
- The GeoJSON internal package has been moved to a seperate repo at
  https://github.com/tidwall/geojson. It's now vendored.

Please look out for higher memory usage for datasets using complex
shapes. A complex shape is one that has 64 or more points. For these
shapes it's expected that there will be increase of least 54 bytes per
point.
2018-10-13 04:30:48 -07:00

73 lines
1.1 KiB
Go

package controller
import (
"sync"
"sync/atomic"
"time"
)
type aint struct{ v uintptr }
func (a *aint) add(d int) int {
if d < 0 {
return int(atomic.AddUintptr(&a.v, ^uintptr((d*-1)-1)))
}
return int(atomic.AddUintptr(&a.v, uintptr(d)))
}
func (a *aint) get() int {
return int(atomic.LoadUintptr(&a.v))
}
func (a *aint) set(i int) int {
return int(atomic.SwapUintptr(&a.v, uintptr(i)))
}
type abool struct{ v uint32 }
func (a *abool) on() bool {
return atomic.LoadUint32(&a.v) != 0
}
func (a *abool) set(t bool) bool {
if t {
return atomic.SwapUint32(&a.v, 1) != 0
}
return atomic.SwapUint32(&a.v, 0) != 0
}
type astring struct {
mu sync.Mutex
v string
}
func (a *astring) get() string {
a.mu.Lock()
p := a.v
a.mu.Unlock()
return p
}
func (a *astring) set(s string) string {
a.mu.Lock()
p := a.v
a.v = s
a.mu.Unlock()
return p
}
type atime struct {
mu sync.Mutex
v time.Time
}
func (a *atime) get() time.Time {
a.mu.Lock()
p := a.v
a.mu.Unlock()
return p
}
func (a *atime) set(t time.Time) time.Time {
a.mu.Lock()
p := a.v
a.v = t
a.mu.Unlock()
return p
}