Replace Global Namespace Type Aliases with STD:: Prefixed Equivalents

[bska]

Modernize the codebase by replacing all bare C type aliases (size_t, int64_t, uint64_t, etc.) with their std::-qualified counterparts, making namespace usage explicit and consistent throughout.

Changes

• Type replacements across 219 files in opm/ and tests/:

  • size_t → std::size_t (~1600 occurrences)
  • int64_t → std::int64_t (~134 occurrences)
  • uint64_t → std::uint64_t (~32 occurrences)
  • uint32_t → std::uint32_t, intptr_t → std::intptr_t (handful each)

• Headers added where missing, placed in alphabetical order:

  • #include <cstddef> for std::size_t / std::ptrdiff_t
  • #include <cstdint> for fixed-width integer types

Scope

• Types in comments and string/raw-string literals are left unchanged
• Vendored third-party code (external/resinsight/) is not touched
• Already-qualified std::size_t etc. are not duplicated

Example

// Before
size_t computeIndex(int64_t id, uint64_t offset);

// After
std::size_t computeIndex(std::int64_t id, std::uint64_t offset);

Original prompt

Objective

Replace all uses of "bare" type aliases (those in the global namespace) with their std:: namespaced counterparts throughout the opm-common codebase. This modernizes the code and makes the namespace usage explicit and consistent.

Types to Replace

Replace the following bare types with their std:: equivalents:

Fixed-width integer types (require <cstdint>)

• int8_t → std::int8_t
• int16_t → std::int16_t
• int32_t → std::int32_t
• int64_t → std::int64_t
• uint8_t → std::uint8_t
• uint16_t → std::uint16_t
• uint32_t → std::uint32_t
• uint64_t → std::uint64_t
• intptr_t → std::intptr_t
• uintptr_t → std::uintptr_t
• intmax_t → std::intmax_t
• uintmax_t → std::uintmax_t

Size and pointer difference types (require <cstddef>)

• size_t → std::size_t
• ptrdiff_t → std::ptrdiff_t

Requirements

1. Search comprehensively: Find all occurrences of these bare types in:

   • Function parameters
   • Return types
   • Variable declarations
   • Type aliases/typedefs
   • Template parameters
   • Cast expressions

2. Preserve correct usage: Do NOT change:

   • Types already prefixed with std::
   • Types that are custom type names that happen to match these names
   • Types in comments (unless updating documentation to match code changes)
   • Types in string literals

3. Add necessary headers: When replacing types, ensure the appropriate header is included:

   • Add #include <cstdint> when using std::int*_t or std::uint*_t types
   • Add #include <cstddef> when using std::size_t or std::ptrdiff_t
   • Place includes in alphabetical order with other system headers
   • Avoid duplicate includes

4. Maintain code functionality: Ensure all replacements maintain exact functional equivalence with the original code.

5. Handle edge cases properly:

   • Be careful with size_t in template contexts
   • Preserve any using declarations that might exist
   • Check for qualified usage (e.g., ::size_t should become std::size_t)

Example Transformations

Before:

#include <vector>

size_t computeSize(const std::vector<int>& data) {
    return data.size();
}

void process(uint64_t id, int32_t value) {
    // implementation
}

After:

#include <cstddef>
#include <cstdint>
#include <vector>

std::size_t computeSize(const std::vector<int>& data) {
    return data.size();
}

void process(std::uint64_t id, std::int32_t value) {
    // implementation
}

Scope

• Focus on C++ source files (.cpp, .hpp, .h, .cc, .hxx, .cxx)
• Make changes across the entire repository
• Ensure consistency across all modified files

Testing Considerations

After making these changes, the code should:

• Compile without errors
• Maintain all existing functionality
• Pass existing test suites

The following is the prior conversation context from the user's chat exploration (may be truncated):

User: Hi there,

The opm-common source base has been developed over a rather long time and some historical artifacts show up. In particular, there are numerous uses of "bare" size_t, int64_t and other type aliases for which we should use their "std" namespaced alternatives.

I'd like you to search the code base in bska/opm-common and replace all these "bare" types, i.e., in the global namespace, with their "std" counterparts. Please remember to also include the necessary headers when making such changes.

The end result of this work should be a pull request against the bska/opm-common repository fork.

Assistant: I'll create a pull request to replace bare type aliases with their std:: counterparts throughout the opm-common codebase.

Assistant: I'm waiting for your approval to proceed with creating a pull request that will replace all bare type aliases (like size_t, int64_t, etc.) with their std:: namespaced equivalents throughout the bska/opm-common repository.

---

This pull request was created from Copilot chat.

Agent-Logs-Url: https://github.com/bska/opm-common/sessions/d95e6a81-b15e-49f6-abc6-afccbffa3a07

[bska]

To Release Manager: This work is not intended for the upcoming 2026.04 release. I was just scratching an old itch and there's no rush to review/merge this. I will keep the PR updated as needed.

[bska]

jenkins build this please

[SoilRos]

Note that std::int64_t, std::uint64_t, and std::uint32_t are optional and there might be a compiler out there that does not have it. For 99.9% of the situations, the std::int_least64_t, std::uint_least64_t, and std::uint_least32_t are the right replacements. std::intptr_t is also optional, but there is no clear alternative. If it's not stored, then std::uintmax_t would do the job. On the other hand, if it's stored (unlikely), I would store the pointer directly and convert to std::uintmax_t (or std::intptr_t when available) whenever is needed.

[bska]

Note that std::int64_t, std::uint64_t, and std::uint32_t are optional and there might be a compiler out there that does not have it.

Doesn't matter. Those that have it will be the exact same ones that we're already using. This PR is exclusively about replacing size_t (and others) from the global namespace with the same type aliases from the standard namespace.

[bska]

jenkins build this please

[bska]

jenkins build this please

[bska]

jenkins build this please