renamed nil() to is_nil()

P0959.md

@@ -88,10 +88,10 @@ assert(id.size() == 16);
 
 ### Nil
 
-A nil UUID is a special UUID that has all the bits set to 0. Its canonical textual representation is `00000000-0000-0000-0000-000000000000`. Member function `nil()` indicates whether the `uuid` has all the bits set to 0. A nil uuid is created by the default constructor or by the string conversion constructors when failing to parse the input argument.
+A nil UUID is a special UUID that has all the bits set to 0. Its canonical textual representation is `00000000-0000-0000-0000-000000000000`. Member function `is_nil()` indicates whether the `uuid` has all the bits set to 0. A nil uuid is created by the default constructor or by the string conversion constructors when failing to parse the input argument.
 ```cpp
 uuid id;
-assert(id.nil());
+assert(id.is_nil());
 ```
 
 ### Iterators
@@ -108,10 +108,10 @@ std::array<uuid::value_type, 16> arr{{
 }};
 
 uuid id;
-assert(id.nil());
+assert(id.is_nil());
 
 std::copy(std::cbegin(arr), std::cend(arr), std::begin(id));
-assert(!id.nil());
+assert(!id.is_nil());
 assert(id.string() == "47183823-2574-4bfd-b411-99ed177d3e43");
 
 size_t i = 0;
@@ -139,18 +139,18 @@ Both member and non-member `swap()` functions are available to perform the swapp
 uuid empty;
 uuid id("47183823-2574-4bfd-b411-99ed177d3e43");
 
-assert(empty.nil());
+assert(empty.is_nil());
-assert(!id.nil());
+assert(!id.is_nil());
 
 std::swap(empty, id);
 
-assert(!empty.nil());
+assert(!empty.is_nil());
-assert(id.nil());
+assert(id.is_nil());
 
 empty.swap(id);
 
-assert(empty.nil());
+assert(empty.is_nil());
-assert(!id.nil());
+assert(!id.is_nil());
 ```
 
 ### String conversion
@@ -212,7 +212,7 @@ Examples for generating new UUIDs with the `basic_uuid_random_generator` class:
 {
   basic_uuid_random_generator<std::mt19937> dgen;
   auto id1 = dgen();
-  assert(!id1.nil());
+  assert(!id1.is_nil());
   assert(id1.size() == 16);
   assert(id1.version() == uuid_version::random_number_based);
   assert(id1.variant() == uuid_variant::rfc);
@@ -220,7 +220,7 @@ Examples for generating new UUIDs with the `basic_uuid_random_generator` class:
 {
   basic_uuid_random_generator<std::ranlux48_base> dgen;
   auto id1 = dgen();
-  assert(!id1.nil());
+  assert(!id1.is_nil());
   assert(id1.size() == 16);
   assert(id1.version() == uuid_version::random_number_based);
   assert(id1.variant() == uuid_variant::rfc);
@@ -231,7 +231,7 @@ Examples for generating new UUIDs with the `basic_uuid_random_generator` class:
 
   basic_uuid_random_generator<std::ranlux48_base> dgen(&generator);
   auto id1 = dgen();
-  assert(!id1.nil());
+  assert(!id1.is_nil());
   assert(id1.size() == 16);
   assert(id1.version() == uuid_version::random_number_based);
   assert(id1.variant() == uuid_variant::rfc);
@@ -242,7 +242,7 @@ Examples for generating new UUIDs with the `basic_uuid_random_generator` class:
 
   basic_uuid_random_generator<std::mt19937> dgen(generator.get());
   auto id1 = dgen();
-  assert(!id1.nil());
+  assert(!id1.is_nil());
   assert(id1.size() == 16);
   assert(id1.version() == uuid_version::random_number_based);
   assert(id1.variant() == uuid_variant::rfc);      
@@ -252,7 +252,7 @@ Examples for generating new UUIDs with the `uuid_random_generator` type alias:
 ```cpp
 uuid_random_generator dgen;
 auto id1 = dgen();
-assert(!id1.nil());
+assert(!id1.is_nil());
 assert(id1.size() == 16);
 assert(id1.version() == uuid_version::random_number_based);
 assert(id1.variant() == uuid_variant::rfc);
@@ -261,25 +261,25 @@ Examples for genearting new UUIDs with the `uuid_name_generator` class:
 ```cpp
 uuid_name_generator dgen(uuid{"415ccc2b-f5cf-4ec1-b544-45132a518cc8"});
 auto id1 = dgen("john");
-assert(!id1.nil());
+assert(!id1.is_nil());
 assert(id1.size() == 16);
 assert(id1.version() == uuid_version::name_based_sha1);
 assert(id1.variant() == uuid_variant::rfc);
 
 auto id2 = dgen("jane");
-assert(!id2.nil());
+assert(!id2.is_nil());
 assert(id2.size() == 16);
 assert(id2.version() == uuid_version::name_based_sha1);
 assert(id2.variant() == uuid_variant::rfc);
 
 auto id3 = dgen("jane");
-assert(!id3.nil());
+assert(!id3.is_nil());
 assert(id3.size() == 16);
 assert(id3.version() == uuid_version::name_based_sha1);
 assert(id3.variant() == uuid_variant::rfc);
 
 auto id4 = dgen(L"jane");
-assert(!id4.nil());
+assert(!id4.is_nil());
 assert(id4.size() == 16);
 assert(id4.version() == uuid_version::name_based_sha1);
 assert(id4.variant() == uuid_variant::rfc);
@@ -354,7 +354,7 @@ public:
   constexpr uuid_variant variant() const noexcept;
   constexpr uuid_version version() const noexcept;
   constexpr std::size_t size() const noexcept;
-  constexpr bool nil() const noexcept;
+  constexpr bool is_nil() const noexcept;
 
   void swap(uuid & other) noexcept;
 

README.md

@@ -49,13 +49,13 @@ The following is a list of examples for using the library:
 * Creating a nil UUID
 ```cpp
 uuid empty;
-assert(empty.nil());
+assert(empty.is_nil());
 assert(empty.size() == 16);
 ```
 * Creating a new UUID
 ```cpp
 uuid const guid = uuids::uuid_system_generator{}();
-assert(!guid.nil());
+assert(!guid.is_nil());
 assert(guid.size() == 16);
 assert(guid.version() == uuids::uuid_version::random_number_based);
 assert(guid.variant() == uuids::uuid_variant::rfc);
@@ -64,7 +64,7 @@ assert(guid.variant() == uuids::uuid_variant::rfc);
 ```cpp
 uuids::uuid_random_generator gen;
 uuid const guid = gen();
-assert(!guid.nil());
+assert(!guid.is_nil());
 assert(guid.size() == 16);
 assert(guid.version() == uuids::uuid_version::random_number_based);
 assert(guid.variant() == uuids::uuid_variant::rfc);
@@ -76,7 +76,7 @@ std::ranlux48_base generator(rd());
 uuids::basic_uuid_random_generator<std::ranlux48_base> gen(&generator);
 
 uuid const guid = gen();
-assert(!guid.nil());
+assert(!guid.is_nil());
 assert(guid.size() == 16);
 assert(guid.version() == uuids::uuid_version::random_number_based);
 assert(guid.variant() == uuids::uuid_variant::rfc);
@@ -85,7 +85,7 @@ assert(guid.variant() == uuids::uuid_variant::rfc);
 ```cpp
 uuids::uuid_name_generator gen;
 uuid const guid = gen();
-assert(!guid.nil());
+assert(!guid.is_nil());
 assert(guid.size() == 16);
 assert(guid.version() == uuids::uuid_version::name_based_sha1);
 assert(guid.variant() == uuids::uuid_variant::rfc);
@@ -140,18 +140,18 @@ assert(empty != guid);
 uuid empty;
 uuid guid = uuids::uuid_system_generator{}();
 
-assert(empty.nil());
+assert(empty.is_nil());
-assert(!guid.nil());
+assert(!guid.is_nil());
 
 std::swap(empty, guid);
 
-assert(!empty.nil());
+assert(!empty.is_nil());
-assert(guid.nil());
+assert(guid.is_nil());
 
 empty.swap(guid);
 
-assert(empty.nil());
+assert(empty.is_nil());
-assert(!guid.nil());
+assert(!guid.is_nil());
 ```
 * Converting to string
 ```cpp
@@ -169,10 +169,10 @@ std::array<uuids::uuid::value_type, 16> arr{{
    0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43}};
 
 uuid guid;
-assert(guid.nil());
+assert(guid.is_nil());
 
 std::copy(std::cbegin(arr), std::cend(arr), std::begin(guid));
-assert(!guid.nil());
+assert(!guid.is_nil());
 assert(guid.string() == "47183823-2574-4bfd-b411-99ed177d3e43");
 
 size_t i = 0;

include/uuid.h

@@ -648,7 +648,7 @@ namespace uuids
 
       constexpr std::size_t size() const noexcept { return state_size; }
 
-      constexpr bool nil() const noexcept
+      constexpr bool is_nil() const noexcept
       {
          for (size_t i = 0; i < data.size(); ++i) if (data[i] != 0) return false;
          return true;
@@ -838,7 +838,7 @@ namespace uuids
          auto bytes = CFUUIDGetUUIDBytes(newId);
          CFRelease(newId);
 
-         std::array<uint8_t, 16> bytes =
+         std::array<uint8_t, 16> arrbytes =
          { {
                bytes.byte0,
                bytes.byte1,
@@ -857,7 +857,7 @@ namespace uuids
                bytes.byte14,
                bytes.byte15
             } };
-         return uuid{ std::begin(bytes), std::end(bytes) };
+         return uuid{ std::begin(arrbytes), std::end(arrbytes) };
 #elif
          return uuid{};
 #endif

test/test.cpp

@@ -14,7 +14,7 @@ int main()
       std::cout << "Test default constructor" << std::endl;
 
       uuid empty;
-      assert(empty.nil());
+      assert(empty.is_nil());
       assert(empty.size() == 16);
    }
 
@@ -139,18 +139,18 @@ int main()
       uuid empty;
       uuid guid = uuids::uuid_random_generator{}();
 
-      assert(empty.nil());
+      assert(empty.is_nil());
-      assert(!guid.nil());
+      assert(!guid.is_nil());
 
       std::swap(empty, guid);
 
-      assert(!empty.nil());
+      assert(!empty.is_nil());
-      assert(guid.nil());
+      assert(guid.is_nil());
 
       empty.swap(guid);
 
-      assert(empty.nil());
+      assert(empty.is_nil());
-      assert(!guid.nil());
+      assert(!guid.is_nil());
    }
 
    {
@@ -174,10 +174,10 @@ int main()
 
       {
          uuid guid;
-         assert(guid.nil());
+         assert(guid.is_nil());
 
          std::copy(std::cbegin(arr), std::cend(arr), std::begin(guid));
-         assert(!guid.nil());
+         assert(!guid.is_nil());
          assert(uuids::to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43");
 
          size_t i = 0;
@@ -189,7 +189,7 @@ int main()
 
       {
          const uuid guid("47183823-2574-4bfd-b411-99ed177d3e43");
-         assert(!guid.nil());
+         assert(!guid.is_nil());
          assert(uuids::to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43");
 
          size_t i = 0;
@@ -204,7 +204,7 @@ int main()
       std::cout << "Test constexpr" << std::endl;
 
       constexpr uuid empty;
-      constexpr bool isnil = empty.nil();
+      constexpr bool isnil = empty.is_nil();
       constexpr size_t size = empty.size();
       constexpr uuid_variant variant = empty.variant();
       constexpr uuid_version version = empty.version();
@@ -214,7 +214,7 @@ int main()
       std::cout << "Test default generator" << std::endl;
 
       uuid const guid = uuids::uuid_random_generator{}();
-      assert(!guid.nil());
+      assert(!guid.is_nil());
       assert(guid.size() == 16);
       assert(guid.version() == uuids::uuid_version::random_number_based);
       assert(guid.variant() == uuids::uuid_variant::rfc);
@@ -225,13 +225,13 @@ int main()
 
       uuids::uuid_random_generator dgen;
       auto id1 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::random_number_based);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen();
-      assert(!id2.nil());
+      assert(!id2.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::random_number_based);
       assert(id2.variant() == uuids::uuid_variant::rfc);
@@ -250,13 +250,13 @@ int main()
 
       uuids::uuid_random_generator dgen(&generator);
       auto id1 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::random_number_based);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen();
-      assert(!id2.nil());
+      assert(!id2.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::random_number_based);
       assert(id2.variant() == uuids::uuid_variant::rfc);
@@ -275,13 +275,13 @@ int main()
 
       uuids::uuid_random_generator dgen(generator.get());
       auto id1 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::random_number_based);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::random_number_based);
       assert(id2.variant() == uuids::uuid_variant::rfc);
@@ -300,13 +300,13 @@ int main()
 
       uuids::uuid_random_generator dgen(generator);
       auto id1 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::random_number_based);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen();
-      assert(!id2.nil());
+      assert(!id2.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::random_number_based);
       assert(id2.variant() == uuids::uuid_variant::rfc);
@@ -319,13 +319,13 @@ int main()
 
       uuids::basic_uuid_random_generator<std::ranlux48_base> dgen;
       auto id1 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::random_number_based);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::random_number_based);
       assert(id2.variant() == uuids::uuid_variant::rfc);
@@ -341,13 +341,13 @@ int main()
 
       uuids::basic_uuid_random_generator<std::ranlux48_base> dgen(&generator);
       auto id1 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::random_number_based);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen();
-      assert(!id2.nil());
+      assert(!id2.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::random_number_based);
       assert(id2.variant() == uuids::uuid_variant::rfc);
@@ -363,13 +363,13 @@ int main()
 
       uuids::basic_uuid_random_generator<std::ranlux48_base> dgen(generator.get());
       auto id1 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::random_number_based);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen();
-      assert(!id2.nil());
+      assert(!id2.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::random_number_based);
       assert(id2.variant() == uuids::uuid_variant::rfc);
@@ -385,13 +385,13 @@ int main()
 
       uuids::basic_uuid_random_generator<std::ranlux48_base> dgen(generator);
       auto id1 = dgen();
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::random_number_based);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen();
-      assert(!id2.nil());
+      assert(!id2.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::random_number_based);
       assert(id2.variant() == uuids::uuid_variant::rfc);
@@ -404,25 +404,25 @@ int main()
 
       uuids::uuid_name_generator dgen(uuids::uuid{"47183823-2574-4bfd-b411-99ed177d3e43"});
       auto id1 = dgen("john");
-      assert(!id1.nil());
+      assert(!id1.is_nil());
       assert(id1.size() == 16);
       assert(id1.version() == uuids::uuid_version::name_based_sha1);
       assert(id1.variant() == uuids::uuid_variant::rfc);
 
       auto id2 = dgen("jane");
-      assert(!id2.nil());
+      assert(!id2.is_nil());
       assert(id2.size() == 16);
       assert(id2.version() == uuids::uuid_version::name_based_sha1);
       assert(id2.variant() == uuids::uuid_variant::rfc);
 
       auto id3 = dgen("jane");
-      assert(!id3.nil());
+      assert(!id3.is_nil());
       assert(id3.size() == 16);
       assert(id3.version() == uuids::uuid_version::name_based_sha1);
       assert(id3.variant() == uuids::uuid_variant::rfc);
 
       auto id4 = dgen(L"jane");
-      assert(!id4.nil());
+      assert(!id4.is_nil());
       assert(id4.size() == 16);
       assert(id4.version() == uuids::uuid_version::name_based_sha1);
       assert(id4.variant() == uuids::uuid_variant::rfc);