`Public Sub AddValuesItems(ByVal property_path As String, ParamArray Items() As Variant)`
In the class
``` Private Sub ICxpSimplifier_AddValuesItems(ByVal property_path As String, ParamArray Items() As Variant) AddValuesItems this_property_path ,items End sub ```
and
`Public Sub AddValuesItems(ByVal property_path As String, ParamArray Items() as Variant)`
grabs all the tables that it has and soon for the access databases, the modules and module versions so i can keep track of if something really needs an update to the modules
> > **ParamArray array is passed as a ParamArray argument** > An array of parameter values ('ParamArray') is being passed as the first element of a 'ParamArray' argument: the invoked procedure will recceive the variant array at the base index of its own parameter array. Procedures taking a 'ParamArray' argument should take steps to verify whether the only element of the array contains another array.
Okay that's tentative wording - and definitely needs some work. But the triggering code would
> @SteveLaycock that's what I suspected. It's not really to do with the interfaces as @retailcoder pointed out. See my prior comment for workarounds in that case since you are calling a class implementation of the function from the class' implementation of the interface.
> Its the implication that is the problem. If I pass a list of variables via an interface I expect the class to receive the same list of variables. That's whatcaught me out. If I were passing a paramarray to another procedure I would know exactly what to expect.
I just had a light bulb moment. (First one all week, I'm excited!)
I've modified my logger (Thanks Mug!!) to allow me to change the logging level while the log's open.
Now that I'm saying this out loud, I'm not so sure it's a bright bulb...
In my error handlers, I was thinking it would be a good idea to change the logging level from whatever it was to Trace so I can get more details as execution completes.
However, since I'm going through and putting an error handler jsut about everywhere with Error level logging that will get logged almost no matter what, I'm not so certain that makes sense anymore.
I'll just go with the "change logging levels on the fly" as the light bulb moment.
Then, I can look at where my last higher level log line came from and put Trace level logging in from there to minimize the amount of log I need to read through.
thanks, self, for being the duck...
I s'pose I should submit a PR for the LogManager.ChangeLogLevel code.
I have this code which opens 2 worksbooks, copies a sheet and pastes to master workbook. It is currently taking 3 minutes, can this be done quicker? Ie without opening each workbook to copy ?
Takes roughly 3 minutes to do.
Sub Load()
Dim masterWB As Workbook
Dim dailyWB As Workbook
Dim lastwe...
> @SteveLaycock sounds like your interface implementation is invoking some equivalent procedure on the class' default public interface, so you're passing a ParamArray parameter as a ParamArray argument, correct?
e.g.
```vb Implements Thing
Public Sub DoStuff(ParamArray stuff() As Variant) Thing_DoStuff stuff End Sub
Public Sub Thing_DoStuff(ParamArray stuff() As Variant) 'here stuff is only 1 element when invoked from Me.DoStuff End Sub ```
It shouldn't be - there'd be a parameter declaration on both sides of the call with a paramarray flag, and didn't you just add a method to the DeclarationFinder to resolve the passed arguments?
but then do you want the inspection result if you are accounting for that fact and verifying the length of the array and, given 1, verifying whether IsArray is true for the first element?
> Well yes and no. I understand how paramarray works and I don't have a problem with it. However I mistakenly assumed that the interface would be transparent and not mutate the structure of of the procedure parameter list. Its what happens when you are ' Clever enough to understand you're not clever enough'
Public Sub DoStuff(ParamArray stuff() As Variant)
DoStuffTrampoline stuff
End Sub
Private Sub DoStuffTrampoline(stuff As Variant)
Thing_DoStuff stuff
End Sub
Public Sub Thing_DoStuff(ParamArray stuff() As Variant)
'here stuff is only 1 element when invoked from Me.DoStuff
End Sub
Public Sub Foo(ParamArray bar() As Variant)
Doit bar
End Sub
Public Sub Baz(ParamArray bar() As Variant)
DoIt bar
End Sub
Private Sub DoIt(Args As Variant)
'do something...
End Sub
@MathieuGuindon Pretty sure the marshaller takes care of wrapping and unwrapping the array when you do that. It'd need to verify it though - it's kind of a hack.
Although I like the other QF better - it's a trivial method extraction (the entire method).
close but as an easter egg have few random princess bride quotes.... 1) Inconceivable!, 2) You keep using that word. I do not think it means what you think it means., 3) My name is Rubberduck. You killed my sanity. Prepare to die.
Frankly, I'd be good with an inspection with a warning that says "This isn't going to do what you think it's going to do." I recall spending some time trying to figure out what was going on there, as well.
@MathieuGuindon i'm wondering - have you ever had a scenario where you exposed a class' backing UDT (e.g. for easy passing in via a Init method perhaps)?
> I think one reason why a ParamArray parameter on a public member is problematic, especially on an interface, is that you cannot write a decorator for such class. Thus, the natural way to emulate implementation inheritance on in VBA is barred, unless there is a method that takes an explicit array and mirrors the method with the ParamArray.
@MathieuGuindon fyi, I'm thinking I'm missing something in regards to the factory and setting the private fields. In the blog, they have examples of public properties that are both gettable and settable.
However to support get-only property, it seems that I have to do something like that....
Interface Ifoo:
'@Folder("Test")
'@Interface
Option Explicit
Public Property Get Something() As String
End Property
Public Sub DoSomething()
End Sub
Predeclared class Foo:
'@Folder("Test")
Option Explicit
Implements IFoo
Private Type TFoo
Something As String
End Type
Private This As TFoo
Public Property Let Something(NewValue As String)
This.Something = NewValue
End Property
Public Function Create(Something As String) As IFoo
Dim Result As Foo
Set Result = New Foo
Result.Something = Something
Set Create = Result
End Function
Private Sub IFoo_DoSomething()
Debug.Print This.Something
End Sub
Private Property Get IFoo_Something() As String
this works but feels a bit too magic-y due to splitting the members between two "interfaces", and adding a backing field means lot of additions to the implementation to boot. Am I overcomplicating this?
In addition, we can't use LSet since the UDT is private, nor would setting it make sense.
Seems to me that using a model class as the backing field rather than a UDT means that the base class don't have to have more than 2 methods that's off the interface.
I think that model class instead of a UDT is probably better since it avoids the need to change the base class, at least for this case of needing a class that contains a set of get-only properties.
(well, more specifically "readonly" get-only properties), in the C#'s meaning of readonly.
IDK if they'll understand better if we simply refer to them as "model class" vs POCO. Need poll, I guess.
one major problem with using POCO as the backing field, though is that you lose compile-time validation. The Create factory method probably should still have them split as individual parameter if that matters.
NB: the other terminology I've seen is DTO (data transfer object, IIRC). But I think that's mainly with PHP.
I might be doing it wrong but normally I have a class that is responsible for something... let's say XMLWriter.... I'm going to have a model named XMLWriterModel
@this XmlModel doesn't sound weird though, but what's the difference between that an XmlDoc, other than implying that it's geared toward a particular architecture?
Mind you, I agree with you that if there's a obvious name, we'll use that; no need to go all HN on all possible classes. Especially when it's a model that's used by several different consumers.
But it seems that lot of times, the model end up being used by only one consumer.
so the <consumer>Model simplifies the naming nomenclature. #Lazy
@Comintern Not sure how you arrive to that conclusion.
TBH, though, I don't see why people complain about Trump so bad (or Obama, or anyone). The other one would likely be just as good/bad and have the same general policies--except it would be OK because the news they watch would say it was OK because of party lines.
To quote OP: "I need a user friendly way to store and backup over 400GB of photos". Speaking as someone who is fully comfortable with the command line, hashing, etc., and I think a manual hash comparison procedure is crazy. Let alone a layperson who couldn't even consolidate/organize their photos in the first place. — Alexanderyesterday
I have this code which opens 2 worksbooks, copies a sheet and pastes to master workbook. It is currently taking 3 minutes, can this be done quicker? Ie without opening each workbook to copy ?
Takes roughly 3 minutes to do.
Sub Load()
Dim masterWB As Workbook
Dim dailyWB As Workbook
Dim lastwe...
VBA Rubberducking
VBA Rubberducking