Re: [swift-users] SwiftPM manual dependency management

2017-07-20 Thread Ankit Aggarwal via swift-users 
On Thu, Jul 20, 2017 at 10:34 PM, Geordie J via swift-users <
swift-users@swift.org> wrote:

> Hi all,
>
> My team and I are trying to use SwiftPM to develop a relatively complex
> app with multiple dependencies, all of which are being developed locally
> and in parallel. The reason for this is compatibility with an existing
> module/import structure used by our iOS app. Maybe I’m doing something very
> wrong but my experience so far (2 months in) is that this is extremely
> difficult with SwiftPM.
>
> What I’d love to be able to do is to just run `git add submodule
> http://blah.com/mysubmodule.git` in the Packages subdirectory and SwiftPM
> would just let me manage dependencies from there myself.
>
> I was excited to see that SwiftPM 4 has a "Top of Tree" development option
> for this purpose. So far my experience with this has not been good. Firstly
> because SwiftPM *still* unnecessarily tries to clone my repos itself
> (some of which are huge), and secondly because this creates an absolute
> path dependency in `.build/dependencies-state.json`, meaning this setup
> isn’t sharable within our dev team.
>
> Attempting this with "local" git urls adds an almost absurd level of
> complexity, having to tag each commit for SwiftPM to build. The fact that
> we'd need to make a commit to test whether the project even builds is
> insane enough as is, let alone the tagging and trying to tell the base
> project to use a newer minor version etc etc.
>
> Adding multiple subtargets is also not an option because the dependencies
> (as dynamic libraries) really are shared between multiple
> targets/sub-dependencies, which SwiftPM seems to deal with quite well.
>
> *tldr;* *Please* let us manage dependencies ourselves. It’d be so easy if
> Package.swift had an option along the lines of *.Package.local(named:
> "XYZ")* that it then looked for in ./Packages/XYZ. Again, maybe I’m
> overlooking something but this seems like an obvious and vital option to
> have. It’d also simplify the introductory SwiftPM docs significantly.
>
> Is anyone else having this issue? Would this change really be as simple
> and painless as it sounds? I would be prepared to make a pull request along
> these lines.
>

I think you're not really using the Top of Tree feature. You need to add
each dependency using its canonical URL, hosted at some server like github.
After adding the dependencies, you can use edit feature to put a dependency
in Top of Tree mode. To do so, run:

$ swift package edit  --path
../path/to/self/managed/checkout/of/the/package

The package manager will then stop using the cloned repository and use the
checkout present at that path (regardless of the state it is in). Sharing
this setup is not automatic, but simple. Each user just needs to run the
above command once per dependency. Also, you only need to do this if you're
actively working on a dependency. The new manifest also supports using
branch instead of version range, which is very helpful during the
development period. Let me know if something is unclear or if you have more
questions!


> Best Regards,
> Geordie
>
>
> PS. In SwiftPM 3 we had been using a hack that worked great: by filling in
> the dependencies' "basedOn" key in `workspace-state.json`, SwiftPM just
> left us alone.. We were able to commit `workspace-state.json` into our base
> project’s git repo and the rest Just Worked™. Now with the absolute paths
> being checked for this doesn’t seem to be an option.
>
>
Please do not rely on internals of the package manager as they're not
stable and will change without notice.



> ___
> swift-users mailing list
> swift-users@swift.org
> https://lists.swift.org/mailman/listinfo/swift-users
>
>
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

Re: [swift-users] Can I use a tuple to force a certain memory layout?

2017-07-20 Thread Taylor Swift via swift-users 
Okay, apparently layout is only guaranteed if the reference is to the tuple
itself, not a member of the tuple. Don’t know if this is a bug or intended
behavior. The above code works when written as

var buffers:(VBO:GL.UInt, EBO:GL.UInt) = (0, 0)
withUnsafeMutablePointer(to: )
{
$0.withMemoryRebound(to: UInt32.self, capacity: 2)
{
glGenBuffers(n: 2, buffers: $0)
}
}



On Thu, Jul 20, 2017 at 3:01 PM, Taylor Swift via swift-users <
swift-users@swift.org> wrote:

> This does not seem to be the case…
>
> var buffers:(VBO:GL.UInt, EBO:GL.UInt) = (0, 0)
> glGenBuffers(n: 2, buffers: )
> print(buffers)
> // > (VBO: 4, EBO: 0)
>
> var buffers:(VBO:GL.UInt, EBO:GL.UInt) = (0, 0)
> glGenBuffers(n: 1, buffers: )
> glGenBuffers(n: 1, buffers: )
> print(buffers)
> // > (VBO: 4, EBO: 5)
>
> On Thu, Jul 20, 2017 at 1:18 PM, Johannes Weiß 
> wrote:
>
>> Hi,
>>
>> > On 20 Jul 2017, at 5:41 pm, Taylor Swift  wrote:
>> >
>> > Does addressof count as legally observing it?
>> >
>> > var buffers:(GL.UInt, GL.UInt) = (0, 0)
>> > glGenBuffers(n: 2, buffers: )
>> >
>> > Also, I assume Swift performs a swizzle if the tuple is defined in a
>> separate module from where the pointer to it is constructed?
>>
>> yes, that's legal assuming the called function doesn't store the pointer
>> and read/write it later.
>>
>>
>> >
>> > On Thu, Jul 20, 2017 at 4:59 AM, Johannes Weiß 
>> wrote:
>> > When you can (legally) observe it, tuples in Swift have guaranteed
>> standard C-style layout.
>> >
>> > John McCall confirms this here: https://lists.swift.org/piperm
>> ail/swift-dev/Week-of-Mon-20170424/004481.html
>> >
>> > > On 20 Jul 2017, at 4:33 am, Taylor Swift via swift-users <
>> swift-users@swift.org> wrote:
>> > >
>> > > Many APIs like OpenGL take arrays where the atomic unit is multiple
>> elements long. For example, a buffer of coordinates laid out like
>> > >
>> > > :[Float] = [ x1, y1, z1, x2, y2, z2, ... , xn, yn, zn ]
>> > >
>> > > I want to be able to define in Swift (i.e., without creating and
>> importing a Objective C module) a struct that preserves the layout, so that
>> I can do withMemoryRebound(to:capacity:_) or something similar and treat
>> the buffer as
>> > >
>> > > struct Point
>> > > {
>> > > let x:Float,
>> > > y:Float,
>> > > z:Float
>> > > }
>> > >
>> > > :[Point] = [ point1, point2, ... , pointn ]
>> > >
>> > > The memory layout of the struct isn’t guaranteed, but will the layout
>> be guaranteed to be in declaration order if I use a tuple inside the struct
>> instead?
>> > >
>> > > struct Point
>> > > {
>> > > let _point:(x:Float, y:Float, z:Float)
>> > >
>> > > var x:Float
>> > > {
>> > > return self._point.x
>> > > }
>> > >
>> > > var y:Float
>> > > {
>> > > return self._point.y
>> > > }
>> > >
>> > > var z:Float
>> > > {
>> > > return self._point.z
>> > > }
>> > > }
>> > >
>> > > This is an ugly workaround, but I can’t really think of any
>> alternatives that don’t involve “import something from Objective C”. I am
>> aware that the implementation of structs currently lays them out in
>> declaration order, but I’m looking for something that’s actually defined in
>> the language.
>> > >
>> > >
>> > > ___
>> > > swift-users mailing list
>> > > swift-users@swift.org
>> > > https://lists.swift.org/mailman/listinfo/swift-users
>> >
>> >
>>
>>
>
> ___
> swift-users mailing list
> swift-users@swift.org
> https://lists.swift.org/mailman/listinfo/swift-users
>
>
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

Re: [swift-users] Can I use a tuple to force a certain memory layout?

2017-07-20 Thread Taylor Swift via swift-users 
This does not seem to be the case…

var buffers:(VBO:GL.UInt, EBO:GL.UInt) = (0, 0)
glGenBuffers(n: 2, buffers: )
print(buffers)
// > (VBO: 4, EBO: 0)

var buffers:(VBO:GL.UInt, EBO:GL.UInt) = (0, 0)
glGenBuffers(n: 1, buffers: )
glGenBuffers(n: 1, buffers: )
print(buffers)
// > (VBO: 4, EBO: 5)

On Thu, Jul 20, 2017 at 1:18 PM, Johannes Weiß 
wrote:

> Hi,
>
> > On 20 Jul 2017, at 5:41 pm, Taylor Swift  wrote:
> >
> > Does addressof count as legally observing it?
> >
> > var buffers:(GL.UInt, GL.UInt) = (0, 0)
> > glGenBuffers(n: 2, buffers: )
> >
> > Also, I assume Swift performs a swizzle if the tuple is defined in a
> separate module from where the pointer to it is constructed?
>
> yes, that's legal assuming the called function doesn't store the pointer
> and read/write it later.
>
>
> >
> > On Thu, Jul 20, 2017 at 4:59 AM, Johannes Weiß 
> wrote:
> > When you can (legally) observe it, tuples in Swift have guaranteed
> standard C-style layout.
> >
> > John McCall confirms this here: https://lists.swift.org/
> pipermail/swift-dev/Week-of-Mon-20170424/004481.html
> >
> > > On 20 Jul 2017, at 4:33 am, Taylor Swift via swift-users <
> swift-users@swift.org> wrote:
> > >
> > > Many APIs like OpenGL take arrays where the atomic unit is multiple
> elements long. For example, a buffer of coordinates laid out like
> > >
> > > :[Float] = [ x1, y1, z1, x2, y2, z2, ... , xn, yn, zn ]
> > >
> > > I want to be able to define in Swift (i.e., without creating and
> importing a Objective C module) a struct that preserves the layout, so that
> I can do withMemoryRebound(to:capacity:_) or something similar and treat
> the buffer as
> > >
> > > struct Point
> > > {
> > > let x:Float,
> > > y:Float,
> > > z:Float
> > > }
> > >
> > > :[Point] = [ point1, point2, ... , pointn ]
> > >
> > > The memory layout of the struct isn’t guaranteed, but will the layout
> be guaranteed to be in declaration order if I use a tuple inside the struct
> instead?
> > >
> > > struct Point
> > > {
> > > let _point:(x:Float, y:Float, z:Float)
> > >
> > > var x:Float
> > > {
> > > return self._point.x
> > > }
> > >
> > > var y:Float
> > > {
> > > return self._point.y
> > > }
> > >
> > > var z:Float
> > > {
> > > return self._point.z
> > > }
> > > }
> > >
> > > This is an ugly workaround, but I can’t really think of any
> alternatives that don’t involve “import something from Objective C”. I am
> aware that the implementation of structs currently lays them out in
> declaration order, but I’m looking for something that’s actually defined in
> the language.
> > >
> > >
> > > ___
> > > swift-users mailing list
> > > swift-users@swift.org
> > > https://lists.swift.org/mailman/listinfo/swift-users
> >
> >
>
>
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

Re: [swift-users] Can I use a tuple to force a certain memory layout?

2017-07-20 Thread Johannes Weiß via swift-users 
Hi,

> On 20 Jul 2017, at 5:41 pm, Taylor Swift  wrote:
> 
> Does addressof count as legally observing it?
> 
> var buffers:(GL.UInt, GL.UInt) = (0, 0)
> glGenBuffers(n: 2, buffers: )
> 
> Also, I assume Swift performs a swizzle if the tuple is defined in a separate 
> module from where the pointer to it is constructed?

yes, that's legal assuming the called function doesn't store the pointer and 
read/write it later.


> 
> On Thu, Jul 20, 2017 at 4:59 AM, Johannes Weiß  
> wrote:
> When you can (legally) observe it, tuples in Swift have guaranteed standard 
> C-style layout.
> 
> John McCall confirms this here: 
> https://lists.swift.org/pipermail/swift-dev/Week-of-Mon-20170424/004481.html
> 
> > On 20 Jul 2017, at 4:33 am, Taylor Swift via swift-users 
> >  wrote:
> >
> > Many APIs like OpenGL take arrays where the atomic unit is multiple 
> > elements long. For example, a buffer of coordinates laid out like
> >
> > :[Float] = [ x1, y1, z1, x2, y2, z2, ... , xn, yn, zn ]
> >
> > I want to be able to define in Swift (i.e., without creating and importing 
> > a Objective C module) a struct that preserves the layout, so that I can do 
> > withMemoryRebound(to:capacity:_) or something similar and treat the buffer 
> > as
> >
> > struct Point
> > {
> > let x:Float,
> > y:Float,
> > z:Float
> > }
> >
> > :[Point] = [ point1, point2, ... , pointn ]
> >
> > The memory layout of the struct isn’t guaranteed, but will the layout be 
> > guaranteed to be in declaration order if I use a tuple inside the struct 
> > instead?
> >
> > struct Point
> > {
> > let _point:(x:Float, y:Float, z:Float)
> >
> > var x:Float
> > {
> > return self._point.x
> > }
> >
> > var y:Float
> > {
> > return self._point.y
> > }
> >
> > var z:Float
> > {
> > return self._point.z
> > }
> > }
> >
> > This is an ugly workaround, but I can’t really think of any alternatives 
> > that don’t involve “import something from Objective C”. I am aware that the 
> > implementation of structs currently lays them out in declaration order, but 
> > I’m looking for something that’s actually defined in the language.
> >
> >
> > ___
> > swift-users mailing list
> > swift-users@swift.org
> > https://lists.swift.org/mailman/listinfo/swift-users
> 
> 

___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

[swift-users] SwiftPM manual dependency management

2017-07-20 Thread Geordie J via swift-users 
Hi all,

My team and I are trying to use SwiftPM to develop a relatively complex app 
with multiple dependencies, all of which are being developed locally and in 
parallel. The reason for this is compatibility with an existing module/import 
structure used by our iOS app. Maybe I’m doing something very wrong but my 
experience so far (2 months in) is that this is extremely difficult with 
SwiftPM.

What I’d love to be able to do is to just run `git add submodule 
http://blah.com/mysubmodule.git`  in the 
Packages subdirectory and SwiftPM would just let me manage dependencies from 
there myself.

I was excited to see that SwiftPM 4 has a "Top of Tree" development option for 
this purpose. So far my experience with this has not been good. Firstly because 
SwiftPM still unnecessarily tries to clone my repos itself (some of which are 
huge), and secondly because this creates an absolute path dependency in 
`.build/dependencies-state.json`, meaning this setup isn’t sharable within our 
dev team.

Attempting this with "local" git urls adds an almost absurd level of 
complexity, having to tag each commit for SwiftPM to build. The fact that we'd 
need to make a commit to test whether the project even builds is insane enough 
as is, let alone the tagging and trying to tell the base project to use a newer 
minor version etc etc.

Adding multiple subtargets is also not an option because the dependencies (as 
dynamic libraries) really are shared between multiple targets/sub-dependencies, 
which SwiftPM seems to deal with quite well.

tldr; *Please* let us manage dependencies ourselves. It’d be so easy if 
Package.swift had an option along the lines of .Package.local(named: "XYZ") 
that it then looked for in ./Packages/XYZ. Again, maybe I’m overlooking 
something but this seems like an obvious and vital option to have. It’d also 
simplify the introductory SwiftPM docs significantly.

Is anyone else having this issue? Would this change really be as simple and 
painless as it sounds? I would be prepared to make a pull request along these 
lines.

Best Regards,
Geordie


PS. In SwiftPM 3 we had been using a hack that worked great: by filling in the 
dependencies' "basedOn" key in `workspace-state.json`, SwiftPM just left us 
alone.. We were able to commit `workspace-state.json` into our base project’s 
git repo and the rest Just Worked™. Now with the absolute paths being checked 
for this doesn’t seem to be an option.___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

Re: [swift-users] Can I use a tuple to force a certain memory layout?

2017-07-20 Thread Taylor Swift via swift-users 
Does addressof count as legally observing it?

var buffers:(GL.UInt, GL.UInt) = (0, 0)
glGenBuffers(n: 2, buffers: )

Also, I assume Swift performs a swizzle if the tuple is defined in a
separate module from where the pointer to it is constructed?

On Thu, Jul 20, 2017 at 4:59 AM, Johannes Weiß 
wrote:

> When you can (legally) observe it, tuples in Swift have guaranteed
> standard C-style layout.
>
> John McCall confirms this here: https://lists.swift.org/
> pipermail/swift-dev/Week-of-Mon-20170424/004481.html
>
> > On 20 Jul 2017, at 4:33 am, Taylor Swift via swift-users <
> swift-users@swift.org> wrote:
> >
> > Many APIs like OpenGL take arrays where the atomic unit is multiple
> elements long. For example, a buffer of coordinates laid out like
> >
> > :[Float] = [ x1, y1, z1, x2, y2, z2, ... , xn, yn, zn ]
> >
> > I want to be able to define in Swift (i.e., without creating and
> importing a Objective C module) a struct that preserves the layout, so that
> I can do withMemoryRebound(to:capacity:_) or something similar and treat
> the buffer as
> >
> > struct Point
> > {
> > let x:Float,
> > y:Float,
> > z:Float
> > }
> >
> > :[Point] = [ point1, point2, ... , pointn ]
> >
> > The memory layout of the struct isn’t guaranteed, but will the layout be
> guaranteed to be in declaration order if I use a tuple inside the struct
> instead?
> >
> > struct Point
> > {
> > let _point:(x:Float, y:Float, z:Float)
> >
> > var x:Float
> > {
> > return self._point.x
> > }
> >
> > var y:Float
> > {
> > return self._point.y
> > }
> >
> > var z:Float
> > {
> > return self._point.z
> > }
> > }
> >
> > This is an ugly workaround, but I can’t really think of any alternatives
> that don’t involve “import something from Objective C”. I am aware that the
> implementation of structs currently lays them out in declaration order, but
> I’m looking for something that’s actually defined in the language.
> >
> >
> > ___
> > swift-users mailing list
> > swift-users@swift.org
> > https://lists.swift.org/mailman/listinfo/swift-users
>
>
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

Re: [swift-users] Can I use a tuple to force a certain memory layout?

2017-07-20 Thread Johannes Weiß via swift-users 
When you can (legally) observe it, tuples in Swift have guaranteed standard 
C-style layout.

John McCall confirms this here: 
https://lists.swift.org/pipermail/swift-dev/Week-of-Mon-20170424/004481.html

> On 20 Jul 2017, at 4:33 am, Taylor Swift via swift-users 
>  wrote:
> 
> Many APIs like OpenGL take arrays where the atomic unit is multiple elements 
> long. For example, a buffer of coordinates laid out like 
> 
> :[Float] = [ x1, y1, z1, x2, y2, z2, ... , xn, yn, zn ]
> 
> I want to be able to define in Swift (i.e., without creating and importing a 
> Objective C module) a struct that preserves the layout, so that I can do 
> withMemoryRebound(to:capacity:_) or something similar and treat the buffer as 
> 
> struct Point 
> {
> let x:Float, 
> y:Float, 
> z:Float
> }
> 
> :[Point] = [ point1, point2, ... , pointn ]
> 
> The memory layout of the struct isn’t guaranteed, but will the layout be 
> guaranteed to be in declaration order if I use a tuple inside the struct 
> instead?
> 
> struct Point 
> {
> let _point:(x:Float, y:Float, z:Float)
> 
> var x:Float 
> {
> return self._point.x
> }
> 
> var y:Float 
> {
> return self._point.y
> }
> 
> var z:Float 
> {
> return self._point.z
> }
> }
> 
> This is an ugly workaround, but I can’t really think of any alternatives that 
> don’t involve “import something from Objective C”. I am aware that the 
> implementation of structs currently lays them out in declaration order, but 
> I’m looking for something that’s actually defined in the language.
> 
> 
> ___
> swift-users mailing list
> swift-users@swift.org
> https://lists.swift.org/mailman/listinfo/swift-users

___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users