mirror of
https://github.com/nim-lang/Nim.git
synced 2025-12-28 17:04:41 +00:00
b809562c7c
* fix megatest newlines * still allow missing trailing newline for now but in a more strict way than before
131 lines
2.8 KiB
Nim
131 lines
2.8 KiB
Nim
|
|
discard """
|
|
output: '''5.0 10.0
|
|
=destroy
|
|
=destroy
|
|
'''
|
|
"""
|
|
|
|
type
|
|
MyOpt[T] = object
|
|
case has: bool:
|
|
of true: val: T
|
|
of false: nil
|
|
|
|
MyVal = object
|
|
f: ptr float
|
|
|
|
proc `=destroy`(x: var MyVal) =
|
|
if x.f != nil:
|
|
dealloc(x.f)
|
|
|
|
proc `=sink`(x1: var MyVal, x2: Myval) =
|
|
if x1.f != x2.f:
|
|
`=destroy`(x1)
|
|
x1.f = x2.f
|
|
|
|
proc `=`(x1: var MyVal, x2: Myval) =
|
|
if x1.f != x2.f:
|
|
`=destroy`(x1)
|
|
x1.f = create(float)
|
|
x1.f[] = x2.f[]
|
|
|
|
proc newVal(x: float): MyVal =
|
|
result.f = create(float)
|
|
result.f[] = x
|
|
|
|
template getIt[T, R](self: MyOpt[T], body: untyped, default: R): R =
|
|
if self.has:
|
|
template it: untyped {.inject.} = self.val
|
|
body
|
|
else:
|
|
default
|
|
|
|
proc myproc(h: MyOpt[float]) =
|
|
let (a, b) = h.getIt((newVal(it), newVal(it * 2)), (newVal(1.0), newVal(1.0)))
|
|
echo a.f[], " ", b.f[]
|
|
|
|
let h = MyOpt[float](has: true, val: 5.0)
|
|
myproc(h)
|
|
|
|
|
|
#-------------------------------------------------------------
|
|
type
|
|
MyObject* = object
|
|
len*: int
|
|
amount: UncheckedArray[float]
|
|
|
|
MyObjPtr* = ptr MyObject
|
|
|
|
MyObjContainer* {.byref.} = object
|
|
size1: int
|
|
size2: int
|
|
data: ptr UncheckedArray[MyObjPtr]
|
|
|
|
|
|
proc size1*(m: MyObjContainer): int {.inline.} = m.size1
|
|
proc size2*(m: MyObjContainer): int {.inline.} = m.size2
|
|
|
|
proc allocateMyObjPtr(size2: int): MyObjPtr =
|
|
cast[MyObjPtr](allocShared(sizeof(MyObject) + sizeof(float) * size2.int))
|
|
|
|
proc `=destroy`*(m: var MyObjContainer) {.inline.} =
|
|
if m.data != nil:
|
|
for i in 0..<m.size1:
|
|
if m.data[i] != nil:
|
|
deallocShared(m.data[i])
|
|
m.data[i] = nil
|
|
deallocShared(m.data)
|
|
echo "=destroy"
|
|
m.data = nil
|
|
|
|
proc `=sink`*(m: var MyObjContainer, m2: MyObjContainer) {.inline.} =
|
|
if m.data != m2.data:
|
|
`=destroy`(m)
|
|
m.size1 = m2.size1
|
|
m.size2 = m2.size2
|
|
m.data = m2.data
|
|
|
|
|
|
proc `=`*(m: var MyObjContainer, m2: MyObjContainer) {.error.}
|
|
## non copyable
|
|
|
|
func newMyObjContainer*(size2: Natural): MyObjContainer =
|
|
result.size2 = size2
|
|
|
|
proc push(m: var MyObjContainer, cf: MyObjPtr) =
|
|
## Add MyObjPtr to MyObjContainer, shallow copy
|
|
m.size1.inc
|
|
m.data = cast[ptr UncheckedArray[MyObjPtr]](reallocShared(m.data, m.size1 * sizeof(MyObjPtr)))
|
|
m.data[m.size1 - 1] = cf
|
|
|
|
|
|
proc add*(m: var MyObjContainer, amount: float) =
|
|
assert m.size2 > 0, "MyObjContainer is not initialized, use newMyObjContainer() to initialize object before use"
|
|
let cf = allocateMyObjPtr(m.size2)
|
|
for i in 0..<m.size2:
|
|
cf.amount[i.int] = amount
|
|
|
|
m.push(cf)
|
|
|
|
proc add*(dest: var MyObjContainer, src: sink MyObjContainer) =
|
|
# merge containers
|
|
|
|
for i in 0..<src.size1:
|
|
dest.push src.data[i]
|
|
src.data[i] = nil
|
|
|
|
|
|
proc test =
|
|
var cf1 = newMyObjContainer(100)
|
|
cf1.add(1)
|
|
cf1.add(2)
|
|
|
|
var cf3 = newMyObjContainer(100)
|
|
cf3.add(2)
|
|
cf3.add(3)
|
|
|
|
cf1.add(cf3)
|
|
|
|
test()
|