unnoticed | Unranked leaderboards for osu | Game Engine library

Firstly, create a temporary branch while experimenting, in this case you could just do:

Not sure what you're trying to achieve but this works fine:

I think there's multiple ways to do it though the way I would do it would be to add a reference to the styled component.

There is already a way to automate this by going to File >> New >> Activity. By going through this way studio will automate both creation of Java / Kotlin File and addding the entry to Manifest file.

If you instead create a class & then extend Android activity then studio will not automate this behavior because in some more advanced cases users want to do this step on there own thus having a better understanding of how the system is wired.

As to why this is not being done by compile time error checking is because this is not an error like a null pointer exception i.e. logical code error instead this is about how the app is being configured. Configuration errors are never part of compile-time checking.

After much head banging, I finally figured out the root cause of this. And it's a bit obscure..

The wireless video transmitter in the drone is able to dynamically change the video bitrate depending on the radio link's available bandwidth. Or put in another way: When the drone is too far away or there is strong interference, the video quality degrades.

When this happens, video frames (contained in only one slice within a single NAL) start to become significantly smaller. Since I'm reading 512-byte chunks of an h264 stream with no particular alignment and forwarding them to GStreamer as GstBuffers, if the size of data needed for one frame is lower than 512 bytes, there is a possibility that a buffer contains multiple frames. In this case, h264parse sees this as N different buffers with identical timestamps. The default behavior then seems to be to ignore both upstream PTS and DTS and try to compute the timestamp based on the duration of the frame by reading the VUI from the SPS, which is not present in my stream. Therefore, the buffer leaving the source pad of h264parse will have no PTS and no DTS, thus making mp4mux complain.

As I've previously mentioned, my stream is quite simple so I wrote a simple parser to detect the beginning of each NAL. This way I can 'unpack' the stream coming from the USB hardware and make sure that every buffer pushed into my pipeline will contain only one NAL (therefore, as much as one frame), independently timestamped.

And for redundancy, I added a probe attached to the sink pad of my tee element to make sure I have correct timestamps in every buffer through it. Otherwise, they're forced to the running time of the element like this.

There are two solutions to this. The first was through my own experimentation. The second is a line of thought spawned thanks Solar Mike reminding me of an all too useful feature that I forgot about due to lack of use (generally do not have a need for it): Very Hidden Sheets. The avenue he seemed to be suggesting may not work exactly as he intended as, ideally, this Revit macro and Excel file combo should be usable by anyone in my company, but there is a method to make it work for anyone. Below are the two methods to resolve my issue, and hopefully anyone else in a similar bind that is, for some reason, unable to use Protect Sheet to do this job.

By setting Allow: Custom and Formula: "", I can trigger the Error Alert feature with Style set to "Stop" that will disallow any alterations.

Even better, if I want to disallow the deletion of cell data, unchecking the "Ignore blank" box causes an Error Alert upon hitting the Delete key on the cell as well.

Using this in conjunction with hiding the column obfuscates the process for editing these cells through sheer volume of steps to enable editing, discouraging users from bothering to mess with cell contents.

• Can utilize Input Message to warn users of the danger of altering cell contents
• Can use Error Alert to outright block data entry or deletion of cell contents
• Requires additional steps before people can alter values, using effort as a deterrent

• Does not protect against the following (read further for detailed descriptions):
  • Deletion of rows (offset by using this macro on the workbook in the Visual Basic editor)
  • Copy and paste another cell(s) over read-only cell(s) (working on a macro to eliminate this issue)
  • Alteration of cells through code or macro
• Requires macros to mitigate some of the above limitations, which can be disabled and put data at risk of outlined issues.
• Requires additional column (which can and likely should be hidden) in your data, which becomes obvious to those who look at column letters.
• Does not prevent people from turning off data validation, should someone deem the effort worth it

Deletion of row:

This does not matter as much for me with this solution, as I am reading data from excel row by row, using the ElementId cell to find the Revit element. If an Excel row was deleted, the associated Revit element simply misses get data with that import, and is then re-added into the Excel file from the schdule upon the next export run, as long as the element still exists in Revit. But if row data needs to be maintained to avoid data corruption in your situation, you can use the linked macro to disable it.

Alteration by code:

At least external code; I have not tested this against a VBA macro from within Excel, but I assume the same to be true. I reason this is due to the fact that Data Validation is activated by a user interacting with the cell on an interface level, but when writing to the cell using the Microsoft.Office.Interop.Excel library in C# you are bypassing the interface and interacting directly with the cell data, thus not triggering Data Validation. I am not concerned about security or validation issues arising from this as few in our AEC firm know how to code, and the ones that do have no reason to interact with these files and/or lack the permission to access the folder (seperation of disciplines). While imperfect for most cases, this is the best solution I can come up with for our current needs.

This method utilizes two features of Excel:

• Very hidden sheet visibility setting
• Macros

Specifically, the macro I am referring to is the link from Solution 1's Con section, Prevent Row/Column Removal.

The solution is to have your script write to two different sheets, one for your overall data, and the second for your unique identifiers. The writing of these should be coded in such a way that you would write to a line in each sheet before moving to the next one to ensure the identifier and data are placed on the same row and to reduce errors when editing the code in the future.

When saving the newly generated and format- and filter-less Excel file, set the identifier sheet's visibility to xlSheetVeryHidden, or 2. This setting should be exposed through the Interop.Excel interface as a worksheet property. This way, only advanced users who can use macros can unhide the sheet, and that's if they even know to look for it.

• Ensures unique identifier is accessible only to those explicitly told of its existence, and even then only to those with the ability or given the tools to access it
• By utilizing the Row Deletion Prevention macro, identifier will always be paired with correct data, as long as code writes the data to Excel correctly
• Is more secure than Data Validation by way of eliminating copy/paste as a risk

• Requires file to be saved as .xlsm, or Macro Enabled Workbook, which depending on your company's security settings may send a red flag to those who are unfamiliar with why the file is set this way
• If macros are disabled via security settings, validity of data cannot be guaranteed as the row deletion prevention would be disabled

While I prefer Solution 2 and the usability it would provide, I can't in good conscience use it. Our firm's OOTB Excel install disables macros by default, and several people consider them non-essential to their tasks in the file and just ignore the warning at the top of the file all together. The risk of data becoming compromised purely because someone doesn't want to enable macros is too great.

I'd also like to add: If you are not in exactly the same situation as me, I do NOT readily recommend either solution. Protect Sheet is the strongest way to protect cell data, and does not disallow the use of existing Sort/Filter features. I am only using these as my go-to solutions due to the experience and/or knowledge level of those in the office who could potentially use my macro (and hopefully future addin), and recognize that neither route is a perfect defense.

If anyone has any other suggestions, I'd appreciate hearing them and I'll definitely update this answer if/when I have a better working version of either solution going.

I agree you hit overflow. But it isn't because system_clock::rep is int. Indeed your system_clock::rep is int64_t, and yes it does overflow for this operation.

Your system_clock::period is nano. And the conversion factor to convert nano to std::ratio<1, 256'000'000> is ³²/₁₂₅. And 32 * 1628286679505051812 overflows the common rep : uint64_t.

There are several ways to avoid the overflow and get the correct answer. And you show one of them. Another way is to use 128 bit arithmetic, which is available on your platform:

This depends on whether you consider arg being None to be an error.

If it's a supported value that just means there's nothing to work on then checking for it and returning, as per your first solution, makes the most sense.

If it should never be None and someone passing that in is an error then just let the exception happen. Or, my personal choice, check it and throw an exception in __init__ to say the caller passed an invalid argument. Exceptions happening earlier (at the time the invalid thing happened) feels better than them happening later once a bunch of other things are going on and it's harder to figure out.

The workaround to the problem is to encapsulate the declaration of the decorated function inside (yet) another wrapper function that handles the "setup". The decorator's argument can be passed as an argument to the outer "setup" function, which will actually redeclare the same functions (but different decorator behavior) each time.

Now there's a scope issue to solve, since our original function is now nested. For that, we can simply return the decorated function or assign it to a global variable.

The code solution: