generics.cairo

%lang starknet

from starkware.cairo.common.alloc import alloc
from starkware.cairo.common.invoke import invoke
from starkware.cairo.common.registers import get_ap, get_label_location

from structs import Class

func invoke_func(size: felt, func_ptr : codeoffset, args_len : felt, args : felt*) -> (loc_ptr : felt*):
    let (func_pc) = get_label_location(func_ptr)
    invoke(func_pc, args_len, args)

    let (ap_val) = get_ap()
    let loc_ptr = ap_val - size
    return (loc_ptr)
end

func new_(class : Class, args_len : felt, args : felt*) -> (obj_ptr : felt*):
    let (new_obj) = invoke_func(class.size, class.ctor, args_len, args)
    return (new_obj)
end

func typeof(obj_ptr : felt*) -> (c : Class):
    let c = cast(obj_ptr, Class*)[0]
    return (c=c)
end

func sizeof(obj_ptr : felt*) -> (size : felt):
    let c = cast(obj_ptr, Class*)[0]
    return (size=c.size)
end

structs.cairo

%lang starknet

from starkware.cairo.common.alloc import alloc

struct Class:
    member size : felt
    member ctor : codeoffset  # constructor
    member clone : codeoffset
    member differ : codeoffset
end

struct LocationData:
    member x: felt
    member y: felt
end

struct Location:
    member class_ : Class
    member loc_data : LocationData
end

struct Location3:
    member class_ : Class
    member loc_data: LocationData
    member z : felt
end


namespace Loc:
    func distance_2d(loc_ptr: felt*) -> (dist: felt):
        let loc = cast(loc_ptr, Location*)[0]
        %{ print('x:', ids.loc.loc_data.x) %}
        %{ print('y:', ids.loc.loc_data.y) %}
        return (loc.loc_data.x * loc.loc_data.x + loc.loc_data.y * loc.loc_data.y)
    end

    func get_class() -> (class: Class):
        return (class=Class(size=Location.SIZE, ctor=loc_ctor, clone=loc_clone, differ=loc_differ))
    end

    let _Location : Class = Class(size=Location.SIZE, ctor=loc_ctor, clone=loc_clone, differ=loc_differ)

    func loc_ctor(x, y) -> (l : Location):
        let (class_) = get_class()
        let loc_data: LocationData = LocationData(x=x, y=y)
        let l = Location(class_=class_, loc_data=loc_data)
        return (l=l)
    end

    func loc_clone(l : Location) -> (loc : Location):
        let (loc) = loc_ctor(l.loc_data.x, l.loc_data.y)
        return (loc)
    end

    func loc_differ(l1 : Location, l2 : Location) -> (is_diff : felt):
        if l1.loc_data.x == l2.loc_data.x:
            if l1.loc_data.y == l2.loc_data.y:
                return (1)
            end
        end
        return (0)
    end
end

namespace Loc3:
    func get_class() -> (class: Class):
        return (class=Class(size=Location3.SIZE, ctor=loc3_ctor, clone=loc3_clone, differ=loc3_differ))
    end

    func loc3_ctor(x, y, z) -> (l : Location3):
        let (class_) = get_class()
        let loc_data: LocationData = LocationData(x=x, y=y)
        let l = Location3(class_=class_, loc_data=loc_data, z=z)
        return (l=l)
    end

    func loc3_clone(l : Location3) -> (loc : Location3):
        let (loc) = loc3_ctor(l.loc_data.x, l.loc_data.y, l.z)
        return (loc)
    end

    func loc3_differ(l1 : Location3, l2 : Location3) -> (is_diff : felt):
        if l1.loc_data.x == l2.loc_data.x:
            if l1.loc_data.y == l2.loc_data.y:
                if l1.z == l2.z:
                    return (1)
                end
            end
        end
        return (0)
    end
end

test.cairo

%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin
from starkware.cairo.common.alloc import alloc
from starkware.cairo.common.serialize import serialize_word

from structs import Class, Location, Location3, Loc, Loc3
from generic import new_, typeof, sizeof

@external
func test_location_generic{syscall_ptr : felt*, range_check_ptr, pedersen_ptr : HashBuiltin*}():
    alloc_locals

    let (_Location) = Loc.get_class()

    let (args) = alloc()
    assert args[0] = 1
    assert args[1] = 2
    let (loc_ptr) = new_(_Location, 2, args)

    let (class_: Class) = typeof(loc_ptr)
    let (size: felt) = sizeof(loc_ptr)

    %{ print(ids.class_.size) %}
    %{ print(ids.size) %}

    let (args2) = alloc()
    assert args2[0] = 3
    assert args2[1] = 4
    assert args2[2] = 5
    let (_Location3) = Loc3.get_class()
    let (loc3_ptr) = new_(_Location3, 3, args2)

    let (size3: felt) = sizeof(loc3_ptr)
    %{ print(ids.size3) %}

    let (dist) = Loc.distance_2d(loc_ptr)
    %{ print(ids.dist) %}

    let (dist3) = Loc.distance_2d(loc3_ptr)
    %{ print(ids.dist3) %}

    return ()
end